c_f515f8a12d7a4356cb

Side A implements a substantive algorithmic improvement (spanning-tree bridge preference and rank-adjacent zipping) with well-reasoned sub-priorities and new targeted tests validating the behavior. Side B is a smaller cleanup/consistency fix removing dead-code duplication (toolbar + action), which is useful but far more limited in scope and lasting design impact.

A redesigns core pair-selection (established-component merge before isolate attach, then rank-adjacent zip refinement) with supporting layout/sort keys and targeted tests—lasting ranking behavior. B only removes a redundant ExpandNewThreadForm path and SSRs the home compose slot for consistency, a useful but smaller cleanup.

Side A materially improves the pair-selection algorithm by introducing structured bridge and within-component priorities, preferring attachment to established voted components and then rank-adjacent refinement once the pool is connected. It also adds multiple targeted tests covering the new selection behavior. Side B mainly simplifies the HTML flow by server-rendering the new-thread slot on the home page and removing the now-redundant UI action and tests, which is a useful cleanup but has a narrower long-term impact.

Side A is a small, focused fix that removes duplicate/dead UI code (the toolbar + ExpandNewThreadForm action) and unifies the new-thread compose flow, directly simplifying the codebase with tests updated accordingly. Side B is a large, unfocused commit ('nice') that deletes a legacy parser file while duplicating nearly the same 1800-line reddit-URL parser under new module names (parser.rs, parser_action.rs) and bolts on an unrelated, seemingly experimental 'parser-panel' navigation demo feature, adding bulk and complexity without clear lasting value or coherent purpose.

A is a precise design cleanup: SSR the home compose slot like rooms, delete the toolbar/+ dual path, and remove ExpandNewThreadForm plus its handler/tests—less surface and one consistent flow. B mostly relocates ~1.8k lines of legacy parser (UIAction→ParserAction rename), plus .gitignore noise; the real new value is wiring (ParseQuery, parser_render, JS tab/input), which matters but is thinner relative to the churn.

Side A makes a focused architectural simplification: it removes the now-redundant `ExpandNewThreadForm` UI action and server handler, and changes the home page to server-render `#new-thread-ui-slot` directly with the same compose/login state used on room pages. This eliminates duplicate interaction flow and dead code, whereas Side B is dominated by importing a very large parser subsystem and deleting a legacy file, adding substantial complexity whose lasting value is less certain despite the new demo UI and tests.

Side B removes real duplicated logic (a redundant toolbar and matching server action/tests) by wiring home to SSR the same collapsed compose slot as room pages, simplifying the codebase and reducing surface area. Side A adds a display feature with decent test coverage, but it's a smaller, purely additive UI convenience versus B's genuine cleanup and unification of two divergent code paths.

A adds lasting product value by surfacing existing ConnectivityStats (density, components, comparisons-to-connect) in the pair CLI with tested formatting, directly aiding voting decisions on sparse graphs. B is worthwhile simplification—SSR #new-thread-ui-slot on home and deleting ExpandNewThreadForm plus the extra toolbar—but it mainly removes a redundant morph path rather than introducing new capability.

Side B simplifies the HTML/UI architecture by removing the dedicated ExpandNewThreadForm action, deleting its server-side dispatch and parsing logic, and rendering the new-thread slot directly on the home page using the same SSR flow as room pages. Side A usefully exposes existing connectivity statistics in CLI output with formatting and tests, but it is primarily a presentation enhancement rather than a structural simplification that reduces duplicated behavior.

Side A is a trivial config addition (adds GITHUB_API_BASE_URL env var) that doesn't even show the actual bugfix code using it. Side B removes real dead-code duplication (an unused/redundant ExpandNewThreadForm action and toolbar), simplifies the SSR flow for the home page to match room pages, and cleans up corresponding tests, yielding a clearer, more maintainable codebase.

B removes an entire redundant ExpandNewThreadForm action, its handler, tests, and the dual toolbar/+ morph path, so home SSRs #new-thread-ui-slot like room pages—lasting UI consistency and less surface area. A is a real but tiny fix (define GITHUB_API_BASE_URL) with less architectural impact.

Side B simplifies the HTML flow by server-rendering the `#new-thread-ui-slot` on the home page, removing the redundant `ExpandNewThreadForm` UI action, its dispatch handler, enum variant, and associated parsing test. This eliminates an unnecessary client round-trip and duplicate code path, whereas Side A is a narrowly scoped fix that defines `GITHUB_API_BASE_URL` to prevent a missing-variable `NameError` in the GitHub OAuth callback.

Side B removes real dead code and a duplicated code path (ExpandNewThreadForm action plus its toolbar), unifying home page compose rendering with room pages via direct SSR—reducing complexity and maintenance burden. Side A adds a legitimate feature (vote counts, unpin form) but with more surface area of speculative UI polish (CSS across two themes, vote count formatting) that is less structurally significant than B's consolidation, though A does include a solid regression test for its new helper function.

A adds lasting product behavior: correct unpin via POST set_garden_pin clear (replacing a wrong permalink HUD), pairwise edge vote counts in the garden UI with a focused helper + unit/browser tests, and supporting CSS/docs. B only deletes ExpandNewThreadForm and the home toolbar +, inlining the already-existing new-thread slot SSR—valuable cleanup but no new capability comparable to A’s fix and feature.

Side B simplifies the UI architecture by removing the `ExpandNewThreadForm` HTML action and its server-side dispatch, replacing the home page's extra toolbar with the same SSR `#new-thread-ui-slot` used on room pages. This eliminates duplicated interaction flow and dead code across `ui_html.rs`, `ui_action.rs`, and `feed.rs`, whereas Side A mainly adds UI enhancements (vote counts, HUD unpin button), styling, and supporting helpers/tests without a comparable architectural simplification.

Side A fixes a real functional bug (pinned/stickied posts polluting import results) with a targeted implementation plus a dedicated regression test. Side B is a reasonable cleanup/simplification (removing a redundant toolbar action and always-SSR-ing the compose slot) but is more of a refactor/dead-code removal without a new capability or bugfix, and adds no new tests.

B removes a redundant ExpandNewThreadForm action, handler, toolbar POST, and tests, SSR-ing #new-thread-ui-slot on home like room pages so compose is one consistent path instead of collapsed-then-morph. A is a correct, tested filter for stickied/pinned Reddit children, but it is a narrow import tweak versus B’s lasting UI simplification and deleted surface area.

Side A fixes a concrete data-import issue by filtering stickied/pinned Reddit posts during subreddit listing parsing, adds a dedicated helper, and includes a regression test covering both `stickied` and `pinned` flags. Side B simplifies the HTML/UI flow by removing the `ExpandNewThreadForm` action and server-rendering the compose slot on the home page, but it is primarily a refactor and UX consolidation rather than a functional correctness improvement.

Side B adds a real end-to-end feature (CLI `room create` command, RPC simplification removing an unused/confusing visibility field, updated docs, tests, and cross-module consistency changes to reducer/events/timeline), representing more substantial and broader-reaching work. Side A is a smaller, focused UI cleanup that removes a redundant toolbar/action, which is valuable but narrower in scope and impact than B's feature completion plus data-model simplification.

B lands the real room-create path (CLI command + RPC) and a lasting domain cleanup: drop ThreadVisibility/RoomState, store rooms as a HashSet, and tighten create/events/reducer/tests. A only unifies home SSR compose and deletes ExpandNewThreadForm—useful UX consistency, but far smaller architectural impact.

Side B adds a substantive end-user capability by introducing a CLI `room create` command wired through the existing RPC, updates documentation, and simplifies the room model by removing the unused visibility field and replacing the room registry with a `HashSet` of room IDs. Side A is a focused UI cleanup that server-renders the collapsed new-thread slot on the home page and removes the now-redundant `ExpandNewThreadForm` action, but its impact is primarily eliminating duplicate UI flow rather than adding or restructuring core functionality.

Side A fixes an actual data-correctness bug (Reddit children imported as duplicate deep paths instead of direct children, and unranked titles falling back to raw ids) and backs it with integration test coverage. Side B is a smaller cleanup that removes redundant client-triggered toolbar/action in favor of SSR, which is nice but lower-impact and removes rather than adds test coverage.

A fixes real import semantics: children attach via apply_entity_under_parent (entity data + direct parent link without ensure_path pulling /comments/ segments) and ranking_panel/child_label show imported titles, with expanded SSE/integration coverage. B is useful UX/consistency cleanup (SSR home compose slot, delete ExpandNewThreadForm + toolbar) but mainly removes a redundant morph path rather than correcting core data wiring.

Side A fixes a functional Reddit import bug by introducing `apply_entity_under_parent` to attach imported children without `ensure_path` creating unwanted `/comments/...` hierarchy, and updates the ranking panel to display imported child titles from the global tree instead of fallback labels. It also propagates the required tree context through the UI and adds integration tests covering SSE updates, child fetching, and rendering, whereas Side B is primarily a UI simplification that removes a redundant expand action and server-renders the collapsed compose state on the home page.

Side A fixes a real architectural inconsistency (auth endpoints doing full redirects instead of participating in the poem-JS morph pattern used elsewhere), adding proper success/error fragments and matching CSS for both themes — a genuine, self-contained UX bugfix. Side B is a solid but narrower cleanup that removes a duplicate toolbar/action by SSRing initial state, reducing code but with less functional impact than A's fix.

A redesigns auth to return HTML fragments and extends the shared poem fetch interceptor to morph non-empty bodies, unifying layouts and giving lasting inline success/error UX without breaking empty-body ingest forms. B is worthwhile cleanup (SSR #new-thread-ui-slot on home, delete ExpandNewThreadForm + toolbar), but it mainly removes redundant indirection already solved on room pages rather than adding comparable capability.

Side A changes the authentication flow to return HTML fragments for inline success/error handling, updates the shared Poem JS form interceptor to morph non-empty responses, factors the auth form into reusable markup, and removes redirect-based error handling. This is a lasting behavioral improvement that simplifies UX and infrastructure for form submissions, whereas Side B mainly removes a specialized UI action and redundant toolbar by server-rendering the existing collapsed compose state, a useful but narrower cleanup.

Side A fixes a real semantic bug (silently defaulting to index 0 via unwrap_or, masking mismatches) with an explicit invariant-asserting expect, removes an inconsistent conditional link-hiding UI branch, and adds targeted regression tests plus doc corrections across three files. Side B is a reasonable UI simplification/dedup (removing a redundant toolbar action) but is more of a cleanup/refactor with less correctness impact and no new test coverage.

A fixes real indexing semantics: rank-history thread_post_index aligns with 0-based /t/tag/N routes, drops the silent unwrap_or(0)/+1 skew, and locks it with RPC/HTML expect + integration asserts. B is worthwhile UI cleanup (SSR home compose like rooms, delete ExpandNewThreadForm and the extra toolbar), but it is path consolidation rather than a correctness/API fix.

Side B removes the now-redundant `ExpandNewThreadForm` UI action end-to-end, simplifies the home page to server-render the collapsed compose/login state directly, and deletes the associated parsing and tests, reducing maintenance for a unified single-`+` flow. Side A fixes `thread_post_index` semantics by enforcing the invariant with `expect`, switching rank-history links to consistent 0-based URLs, updating documentation, and adding tests, but its scope is narrower than the architectural simplification in Side B.

Side A completes a necessary module split for a 1400-line monolithic forum.rs into clear submodules (feed, ingest, nav, page, paginator, post_single, profile, thread_morph, views), removing a duplicate module that would otherwise cause ambiguity, and establishing the file layout that later commits (like B) build on. Side B is a smaller, useful behavioral simplification (removing a redundant morph action and toolbar in favor of direct SSR), but it's a narrower fix built atop the structure A created, so it has less independent architectural value.

A removes the leftover 1400-line monolithic forum.rs so forum/mod.rs is the unambiguous module root and splits the real handlers (feed, views, paginator, morph, profile, etc.) into lasting structure. B only deletes ExpandNewThreadForm and the home toolbar +, SSR-ing #new-thread-ui-slot like rooms—a smaller consistency cleanup on one compose path.

Side A fixes a structural module-resolution problem by deleting the obsolete monolithic `server/src/html/forum.rs`, adding `forum/mod.rs`, and making the split `forum/` directory the single module root. This removes duplicate sources of truth and prevents `mod forum` ambiguity, whereas Side B mainly removes the redundant `ExpandNewThreadForm` UI action and toolbar in favor of server-rendering the same collapsed new-thread slot, which is a useful simplification but has narrower long-term impact.

Side A removes duplicate/dead code paths (ExpandNewThreadForm action, its dispatch handler, and tests) and consolidates the home page to reuse the same SSR compose slot as room pages, simplifying the codebase with a real behavioral unification. Side B is a useful but minor config simplification (auto-discovering test namespaces instead of hand-listing them) that reduces future maintenance friction but has no functional code impact and carries some risk of accidentally picking up unintended test namespaces.

A removes a full UI action path (ExpandNewThreadForm handler, enum variant, and the home toolbar POST+) and SSRs #new-thread-ui-slot like room pages, fixing real UX inconsistency and dead complexity. B only rewrites tests.edn to one auto ns-pattern—useful DX hygiene, but a small config change with no product or runtime impact.

Side A simplifies the UI architecture by removing the `ExpandNewThreadForm` action and its server-side handler, instead server-rendering the `#new-thread-ui-slot` directly on the home page with the same collapsed compose/login-hint behavior used elsewhere. This eliminates duplicated flow and dead RPC parsing/tests while making public home consistent with room pages. Side B improves test maintenance by auto-discovering `test.*` namespaces, but it is a build-configuration convenience rather than a functional or architectural improvement.

A removes a duplicated UI action (ExpandNewThreadForm) and toolbar, consolidating on a single SSR-based compose flow for both room and home pages—an actual simplification of user-facing behavior and codebase surface, with tests removed for the eliminated action. B merely deletes a defensive zero-ratio guard in the reducer, trading redundant safety for marginal code reduction while making item/pair registration behavior change slightly riskier if reachable from another path, offering less durable value than A's consolidation.

A removes an entire UI action (ExpandNewThreadForm), the home toolbar + hop, and SSRs #new-thread-ui-slot like room pages—real lasting simplification of the compose flow. B only deletes a dead zero-ratio guard already enforced upstream, plus a small test tweak; correct hygiene but far less product impact.

Side A removes the now-redundant ExpandNewThreadForm UI action and its server handler, switching the public home page to server-render the same collapsed new-thread slot used on room pages. This simplifies the architecture by eliminating duplicate interaction paths and associated parsing/tests while preserving logged-in and logged-out behavior. Side B mainly deletes a dead zero-ratio guard and updates a test to reflect existing downstream handling, which is a smaller cleanup with less architectural impact.

Commit A removes a redundant UI action/toolbar and duplicated form logic, unifying the compose flow with SSR consistency and deleting dead code plus its test, yielding a net simplification with clear lasting value. Commit B changes sibling grouping behavior (each unranked item its own group) with a test update, which is a reasonable but narrower, more speculative UX tweak whose correctness/value is less clearly justified in the diff.

A removes an entire UI RPC (ExpandNewThreadForm), its handler, and the home-only toolbar, SSRing #new-thread-ui-slot like room pages so compose is one consistent path. B only changes unranked sibling bundling into per-item groups plus a test—useful but a narrower nav tweak versus A’s lasting simplification of the public compose flow.

Side A simplifies the UI architecture by removing the `ExpandNewThreadForm` action and its server-side dispatch logic, and instead server-renders the collapsed compose/login state directly into `#new-thread-ui-slot` on the home page, eliminating duplicated flows and obsolete parsing/tests. Side B improves sibling navigation by placing each unranked sibling into its own group and adds a regression test, but it is a narrower behavioral adjustment compared with A's broader reduction of redundant code paths.

Side A fixes several real bugs (regex split instead of string split, correct getRequestBody, nil-safe state/token handling, proper error handling to prevent silent hangs) that were causing legitimate test crashes in the OAuth mock infrastructure, restoring E2E test reliability. Side B is a reasonable simplification/refactor of a UI action into inline SSR, but it's a smaller-scope cleanup with less clear bug-fixing value and removes test coverage without adding new safety guarantees.

A repairs concrete mock-OAuth/Reddit failures (string split on "=" vs regex, getRequestBody vs getInputStream, null-safe token/state handling, response headers, handler try/catch) that had broken Playwright auth E2E, plus selector fixes in the login helper. B is a worthwhile UX consistency cleanup (SSR #new-thread-ui-slot and delete ExpandNewThreadForm/toolbar) but removes a working indirection rather than fixing correctness or restoring critical test capability.

Side A fixes concrete failures in the test infrastructure by correcting query parsing (`str/split` regex), reading POST bodies from `getRequestBody`, handling null tokens/states safely, fixing redirect responses, and wrapping the mock OAuth handler to avoid crashes, restoring end-to-end authentication tests. Side B is primarily a UI simplification that removes the `ExpandNewThreadForm` action and server-renders the existing compose slot on the home page, which reduces code but is a design cleanup rather than a broad correctness fix.

Side A is a focused, well-documented fix that removes duplicate UI logic (ExpandNewThreadForm) and unifies the home page's compose slot with the room page pattern, including removal of the now-obsolete test — a clear, verifiable improvement in code clarity and correctness. Side B's diff deletes the old URL engine and tests but references new modules (graph.rs, parse.rs, registry_tests.rs) that are not shown in the patch, making the actual substance of the replacement unverifiable and the vague commit message ('url stuff') further undermines confidence in its completeness and intent.

B replaces the ad-hoc ParsedUrl combinators and per-host normalize paths with a lasting graph/DFA-based canonicalization design (and thins registry to that API), which underpins ItemId identity project-wide. A is a correct, focused UX cleanup (SSR #new-thread-ui-slot on home and delete ExpandNewThreadForm + toolbar), but it only simplifies one compose flow rather than core URL architecture.

Side B replaces the URL canonicalization implementation with a new graph- and parser-based architecture, rewires the public registry API to use it, and reorganizes the module structure, representing a foundational redesign of a core subsystem. Side A is a targeted UI simplification that removes the `ExpandNewThreadForm` action and server-renders the collapsed compose/login hint on the home page, which reduces duplication but has a narrower, feature-specific impact.

Side A adds a genuinely new capability (vote-compare page/route, slider UI, typed :i32 form holes, next-navigation) with new tests covering the added behavior, representing net-new functionality. Side B is a clean simplification/dead-code removal (dropping a redundant toolbar and action) which is valuable but smaller in scope and mostly deletes rather than builds lasting functionality.

A lands a real feature slice: typed $form:i32 substitution with tests, RecordVote next-navigation, vote CTA/routes/CSS/slider wiring, and dependency support—durable product behavior. B only deletes ExpandNewThreadForm and SSRs the home compose slot, a worthwhile consistency cleanup that removes churn but adds no comparable capability.

Side A introduces substantive functionality: typed form-template substitution for `i32` fields with tests, adds a `next` navigation field to vote handling, wires a new `/vote` route and vote entry point, and updates the client to support vote sliders and redirects. Side B is primarily a UI simplification that removes the `ExpandNewThreadForm` action and replaces a toolbar with server-rendered content, improving flow but mostly deleting and reorganizing existing behavior rather than adding lasting capabilities.

Commit A removes a genuinely redundant code path (ExpandNewThreadForm action, its dispatch handler, and test) and unifies public-home rendering with the same SSR pattern used elsewhere, reducing action surface and eliminating a duplicated UI flow — a real simplification with lasting design value. Commit B is a solid UX/CSS refactor of cli_panel (grouping commands, hover-copy, JS-safety assert) but is more of a polish/consistency change across call sites without removing any structural redundancy or fixing a design flaw.

A removes an entire UI action (ExpandNewThreadForm), its handler, tests, and a redundant home toolbar in favor of SSR’ing #new-thread-ui-slot like room pages—real consistency and less surface area. B improves cli_panel (multi-command grouping, click-to-copy rows, JS safety asserts) but is peripheral UX polish rather than a lasting structural fix.

Side A removes the dedicated `ExpandNewThreadForm` HTML UI action and its server dispatch/tests, instead rendering the collapsed compose or login hint directly in the SSR `#new-thread-ui-slot` on the home page. This eliminates duplicated flow and unnecessary client/server interaction, simplifying the architecture. Side B improves the CLI panel by supporting grouped commands, click-to-copy rows, and adding assertions for JS-safe embedded strings, but these are primarily UX and component enhancements rather than removing a redundant subsystem.

B makes an actual product/UX fix: it removes a redundant, duplicated toolbar+action path and unifies home page rendering with room pages, deleting dead code (ExpandNewThreadForm variant, dispatch handler, and its test), which is a real simplification of production behavior. A is pure test-infrastructure deduplication (moving shared HTTP/OAuth helpers into common/oauth modules) which is useful but lower-stakes churn with no behavioral change to the shipped product.

B permanently simplifies core product UI by SSR-ing #new-thread-ui-slot on home (matching rooms), deleting the ExpandNewThreadForm action/handler, toolbar morph, and its unit test—reducing real code surface. A only DRY-refactors duplicated test helpers (assert/pass-fail, HTTP clients, mock Google, server env) into common.bb/oauth.bb with no product behavior change.

Side A substantially refactors the test infrastructure by extracting duplicated HTTP/OAuth helpers, test assertions, server environment construction, and cargo build logic into shared modules (`test.common` and `test.oauth`), then updates multiple integration test suites to use them. It also adds reusable capabilities such as configurable mock Google users, registration helpers, and standardized HTTP timeouts, reducing duplication and making future test maintenance easier, whereas Side B mainly simplifies one UI flow by removing the `ExpandNewThreadForm` action and server-rendering the existing compose slot on the home page.