c_4a5c84c0a37bd34c8f

Commit A delivers a substantial new feature set spanning multiple subsystems. It introduces an extensible external URL foundation with a GitHub resolver, on-demand import workflow, new UI actions and controls, system-ingest support in the write actor, resolver cooldown state, URL normalization improvements, external preview handling, recursive child ranking depth, parser enhancements for fenced JSON, extensive tests, and browser end-to-end coverage. It changes application behavior, persistence flow, APIs, state management, and user experience across many files. Commit B is a focused improvement that switches vote-related URLs to display paths and significantly strengthens the browser test by exercising all 45 pairwise comparisons and validating the resulting ranking. While valuable for correctness and UX consistency, its scope and architectural impact are much smaller than the broad platform capabilities added in Commit A.

Commit A introduces a substantial new capability: an extensible external URL foundation with a full GitHub resolver pipeline (API client, rate limiting, DSL generation, system ingest path, UI actions, and browser tests). It also touches many layers (state, write actor, UI, normalization, tests), adding meaningful product functionality. Commit B is a focused improvement to URL display in vote links plus a stronger end-to-end test. While useful, it is comparatively small in scope and impact.

Side A introduces a substantial new feature set: extensible URL normalization (including GitHub and YouTube handling), an on-demand GitHub external resolver with API integration, system-level ingest plumbing, UI controls, cooldown state, DSL/test updates, and new browser coverage. It touches many core modules (state, writer actor, HTML, URL identity, external resolver, tests) and adds meaningful new capabilities. Side B is a focused improvement to vote pool href encoding plus a stronger end-to-end test asserting full ranking behavior. While valuable, it is comparatively small in scope and architectural impact.

Commit A combines a user-facing correctness fix with a substantially stronger end-to-end test. It changes vote URLs to use display paths instead of internal storage URLs, aligning generated links with the UI and DSL, and rewrites the browser test to exercise all 45 pairwise comparisons in a 10-item pool before validating the resulting ranking through the ranking API. That significantly increases coverage and verifies an important algorithmic property rather than just basic flow. Commit B is also valuable, restoring broken OAuth-based E2E authentication by fixing the mock servers and improving test helpers, but its changes are primarily test infrastructure and bug fixes for the mock environment rather than application behavior. Overall, A contributes more functionality and long-term regression protection.

Commit B restores broken OAuth mock infrastructure that multiple end-to-end auth tests depend on, fixing request parsing, response handling, null safety, and adding error isolation. These changes unblock entire test flows and improve reliability across the suite. Commit A improves URL correctness and adds a strong, exhaustive test for ranking logic, but its impact is more localized compared to the broad test infrastructure repair in B.

Commit B fixes broken OAuth mock servers and Playwright auth helpers, restoring end-to-end login flows. It addresses crashing handlers, incorrect request body reading, redirect semantics, null token handling, query parsing, and improves test selectors—changes that unblock multiple E2E authentication scenarios. Commit A improves URL display consistency and significantly strengthens a specific vote-pool test with full pair coverage and ranking assertions, but its scope is narrower. Restoring the auth test infrastructure has broader impact across the test suite and developer workflow.

Side A adds substantial new functionality and infrastructure: an extensible external URL foundation with GitHub resolution, on-demand system ingests (`WriteCmd::SystemIngest`), URL normalization changes, resolver cooldown state, UI actions for external resolution, external preview handling, and accompanying parser and browser tests. Side B is a focused improvement that switches vote links to use `display_path` instead of storage URLs and strengthens the vote-pool browser test by exercising all 45 pairings and asserting the resulting ranking, but it does not introduce comparable lasting capabilities.

Side A introduces a substantial new capability: an extensible external resolver system with a full GitHub integration, new write path (SystemIngest), UI actions, state management, and URL normalization changes, all backed by tests. Side B is a narrow improvement—switching vote URLs to display paths and strengthening a browser test—which is useful but comparatively minor in scope and lasting architectural impact.

Side A introduces a substantial new extensible URL and external resolution foundation: it adds a GitHubResolver with API integration, cooldown tracking in AppState, a new SystemIngest write path, DSL support for fenced JSON bodies, URL normalization changes, UI controls, and end-to-end browser tests. Side B is a focused improvement to vote_compare_href/vote_pool_href to use display_path plus a stronger browser test asserting all 45 pairwise votes and final ranking, which is valuable but much narrower in scope and architectural impact.

Side A implements a substantial, well-tested feature set (GitHub external resolver with rate-limiting, URL identity normalization overhaul stripping tracking params, UI actions and templates, new AppState fields, agents.md doc updates, and a full browser test) representing significant lasting architectural value. Side B is a small, focused bugfix (using display_path in vote hrefs) plus a stronger test, which is valuable but far narrower in scope and impact than Side A's broad foundational work.

A delivers lasting product infrastructure: URL identity redesign (strip query/fragment by default, GitHub/YouTube canonicalization), a full on-demand GitHub resolver with SystemIngest, cooldowns, UI, and E2E coverage. B is a correct, focused fix (display_path in vote hrefs) plus a much stronger 45-pair ranking assertion, but its scope and durability are much narrower than A’s foundation and feature work.

Side B fixes multiple concrete failures in the OAuth test infrastructure that were breaking end-to-end authentication: it corrects request parsing (`getRequestBody` instead of `getInputStream`, regex-based query splitting), prevents null-related crashes, fixes redirect handling, and wraps mock handlers to return diagnostics instead of crashing. Side A improves URL generation by using display paths and substantially strengthens the vote-pool test with full pairwise coverage and ranking assertions, but much of its patch is expanded test logic rather than core functionality, whereas Side B restores a foundational test/auth flow used across the project.

A changes production code to use `display_path()` in vote URLs instead of full storage URLs, aligning links with user-visible paths, and adds a comprehensive test that exercises all 45 pairwise votes and validates final ranking correctness. B primarily fixes test infrastructure (query parsing, request body reading, null handling, and mock server robustness) to restore OAuth E2E tests, which is valuable but less impactful than A’s user-facing behavior change plus stronger correctness guarantees.

Side B fixes concrete crashes in the OAuth test infrastructure: it corrects query parsing (`str/split pair #"=" 2`), reads POST bodies from `.getRequestBody`, guards `parse-token-user` against nil, ensures redirects send a 0-length body instead of -1, and wraps the HttpHandler in a try/catch to prevent server crashes—restoring broken Playwright login flows. Side A improves URL display paths and strengthens a vote-pool test to cover all 45 pairs with a ranking assertion, but B addresses fundamental test auth failures that blocked E2E flows.

Side B fixes genuine crashing bugs in shared OAuth test infrastructure (str/split called with a string instead of a regex, .getInputStream vs the correct .getRequestBody, missing nil-guards, plus a catch-all error handler) that were breaking all Playwright-based E2E auth flows—this is a real, broadly-impactful bugfix. Side A improves href display and rewrites one test to be more thorough, which is useful but narrower in scope and affects only vote-pool link rendering and one test's coverage.

B fixes concrete test-infra bugs (Clojure `str/split` on "=" vs #"=", `getRequestBody` vs `getInputStream`, null-safe token/state handling, 302 response length) that had broken OAuth mocks and thus all Playwright auth E2E flows. A’s `display_path` href change is a real prod consistency fix and the 45-pair ranking assertion is stronger coverage, but it extends one feature path rather than restoring foundational auth testing across the suite.

Side B fixes a genuine correctness bug (vote hrefs leaking full storage URLs instead of display paths, which could break links/UX) and replaces a weak 15-iteration test with an exhaustive 45-pair test that asserts the resulting ranking via RPC, giving much stronger regression coverage. Side A's changes are mostly UI polish (slider CSS/JS, highlighting gradient) with a real but narrower bugfix to rank_row_style scaling, plus decent unit tests, but of smaller functional impact than B's href fix and end-to-end verification.

A fixes real ranking/UI polarity bugs (per-group gradients instead of a global ordinal, center-anchored winner fill, history bars aligned to the HUD slider mapping) and locks them in with focused unit tests. B’s display_path href fix and 45-pair ranking assertion are valuable, but smaller in product surface—mostly URL encoding plus one strengthened integration test.

Side B fixes URL generation to use `display_path()` instead of stored full paths for vote compare and pool links, aligning hrefs with the user-facing path format, and greatly strengthens the browser test by exercising all 45 pairwise votes and verifying the final RPC ranking. Side A is primarily a UI correctness change (per-group rank gradient highlighting plus vote-history slider visualization) with useful regression tests, but its impact is narrower than the routing fix and comprehensive end-to-end validation added in Side B.

Side B fixes a real user-facing bug (hrefs leaking full storage URLs instead of display paths) and substantially strengthens test coverage to actually validate ranking correctness across all pairs, which is meaningful lasting value. Side A adds a small, correct feature (skipping pinned posts) with a focused unit test, which is solid but narrower in scope than B's combined bugfix + test rigor improvement.

B fixes production vote hrefs to encode short display_path forms (matching UI/DSL) and upgrades the pool browser test from a shallow ≤15-iteration smoke check into a full C(10,2)=45-pair run with GetGardenRank assertions (one component, a→j). A is a correct, well-tested Reddit import filter for stickied/pinned posts, but it is a narrower edge-case skip versus B’s core voting UX fix plus substantial ranking coverage.

Side B fixes link generation to use `display_path()` instead of stored full URLs for `left`, `right`, and `pool` parameters, aligning vote URLs with the user-facing path format, and adds an end-to-end test that exercises all 45 pairwise votes and verifies the resulting ranking. Side A is a targeted correctness fix that skips `stickied`/`pinned` Reddit posts during import with a focused unit test, but its impact is narrower than the combination of user-visible URL correctness and substantially stronger integration coverage in Side B.

B delivers a genuine user-facing feature (clickable unpin from ranked child groups) with corresponding CSS and an expanded browser test covering the new interaction, providing real functional value. A is a solid bugfix (display_path in hrefs) plus a much stronger, more rigorous test rewrite, but it's a narrower display-string fix versus B's added interactive capability.

A fixes real href correctness (encode display_path short forms instead of storage URLs in vote_compare/pool links) and turns the pool browser test into a full C(10,2)=45-pair exhaustive vote plus GetGardenRank assertion of a→j ranking—durable coverage of core ranking behavior. B is a useful but narrower UX polish: wire the existing set_garden_pin clear flow to ranked-child pin icons with CSS/test updates, without the same foundational correctness or regression weight.

Side A changes vote URL generation to use `display_path()` instead of storage URLs for left/right/pool parameters, aligning links with the user-facing path format, and substantially strengthens the browser test by exercising all 45 pairwise votes and verifying the final `GetGardenRank` ordering. Side B adds a useful UI improvement by making pinned icons in ranked child lists submit the existing unpin flow and covers it with browser tests, but its impact is narrower and primarily affects one interaction path.

B fixes a genuine functional bug (hrefs encoding the raw storage path instead of the user-facing display path) and replaces a shallow, loosely-bounded browser test with an exhaustive 45-pair test that asserts actual ranking correctness end-to-end via the RPC API. A is a clean, well-tested improvement to color gradient logic, but it only affects cosmetic rendering, whereas B corrects user-facing link generation and substantially strengthens regression coverage of the core ranking feature.

B fixes real href correctness (encode display_path ~/…/-/… instead of full storage URLs in vote_compare_href/vote_pool_href) and turns a shallow “≥1 vote” smoke test into a full C(10,2)=45-pair flow that asserts one component ranked a→j via GetGardenRank. A is a solid UX tweak (score min–max gradient vs list ordinal) with unit tests, but it is visual polish rather than path/ranking correctness.

Side B fixes user-facing URL generation by using display_path instead of internal storage URLs in vote links, aligning hrefs with the application's displayed path format, and substantially strengthens end-to-end coverage by exercising all 45 pairwise votes and asserting the resulting ranking through the RPC API. Side A improves the visual color gradient by basing row colors on normalized score ranges within a group and adds focused unit tests, but this is primarily a presentation enhancement rather than a functional correctness change.

B is a substantive CLI restructuring (forum list/show/post subcommands, removal of confusing thread/delegate flags on ingest, updated docs/DSL, and updated integration tests) that meaningfully changes the user-facing command surface for correctness and clarity. A is a smaller, valid fix (display_path in hrefs) plus a much stronger test rewrite, but its production code change is narrow in scope compared to B's broader interface redesign affecting CLI, docs, and RPC messages.

A fixes real href correctness (encode display_path for left/right/pool instead of raw storage IDs) and replaces a weak ≤15-iteration smoke test with a full C(10,2)=45 pairwise run plus GetGardenRank assertions (one component, a→j). B’s CLI reshape (ingest→forum post/list/show, docs, integration command strings) is lasting interface design but heavier on renames/help churn relative to core behavior.

Side A fixes a user-visible correctness issue by generating vote URLs with `display_path()` instead of stored full URLs for left/right/pool items, matching the displayed DSL paths, and adds an exhaustive browser test that votes all 45 item pairs and verifies the resulting ranking via `GetGardenRank`. Side B mainly restructures the CLI (`forum list/show/post`), updates documentation/help text, and adjusts tests and command strings to the new interface, which is useful but is largely an API/UX reorganization rather than a core correctness improvement.

B fixes a real design/perf issue: replacing an unbounded Deque with append-only List and moving capping to read-time avoids per-vote trim writes (deleting the trim_recent_votes call in the hot apply path) while adding a schema version bump and a targeted regression test proving correctness. A is a useful UX fix (display_path in hrefs) plus a much stronger e2e test, but it's a smaller, more localized improvement compared to B's storage-layer correctness/performance change with test coverage.

A fixes real vote URL correctness (encoding display_path short forms in hrefs instead of storage URLs) and turns a loose ≤15-iteration smoke test into a full C(10,2)=45-pair flow that asserts GetGardenRank yields one component ordered a→j. B’s Deque→List/Vec change is a coherent storage simplification (write-trim removed, read-time cap, schema v4 + unit test) but is more internal plumbing with weaker product-level impact than A’s bugfix plus end-to-end ranking guarantee.

Side A makes a user-facing correctness fix by generating vote URLs from `display_path()` instead of stored URLs, keeping links consistent with the displayed DSL, and substantially strengthens coverage by exercising all 45 pairwise votes and asserting the final ranking through `GetGardenRank`. Side B mainly refactors recent-vote storage from a deque to an append-only list with query-time capping, removes trimming logic, and updates tests for that behavior, but the patch is largely an internal representation change without an equally clear project-wide functional improvement.

Side A fixes real correctness bugs (out-of-band delegate attribution instead of embedding agent tag in DSL body, erroring on insufficient sibling pool instead of silently falling back to all items) and consistently renames the route across server code and all test suites. Side B mainly improves href encoding (a smaller correctness nit) and rewrites a browser test for stronger assertions, which is valuable but narrower in scope and impact than A's fixes to core RPC/vote semantics.

A lands real behavioral fixes: WEB_BROWSER_AGENT moved to out-of-band delegate_opt (correct attribution), sibling pools with <2 items return None instead of falling back to the global item set, and dead “swap sides” UI is removed. B’s display_path href fix is worthwhile and the 45-pair ranking assertion is strong test value, but it is a narrower production change plus test hardening versus A’s multiple correctness fixes.

Side A fixes multiple production behaviors: it correctly passes delegate attribution out-of-band instead of embedding it in DSL text, prevents an incorrect fallback to all items when a sibling pool has fewer than two candidates by returning no next pair, and simplifies the public interface by renaming `/vote/compare` to `/vote` while removing the unnecessary swap button. Side B improves URL generation to use display paths and substantially strengthens browser test coverage with a full 45-pair ranking verification, but much of its patch is test code rather than changes to runtime behavior.

Side A fixes a real user-facing bug (hrefs leaking full storage URLs instead of display paths) and substantially strengthens test coverage with a complete, deterministic 45-pair ranking assertion. Side B is a vague 'fix' commit that reverts a CI workflow tweak and deletes two passing tests without replacement or justification, providing no clear lasting value.

A fixes real product behavior (vote hrefs encode display_path forms users actually see) and replaces a thin 15-iteration smoke loop with a full C(10,2)=45-pair exercise plus GetGardenRank assertions. B only bumps Node 22→24, drops an npm upgrade step, and deletes two obsolete unit tests—useful cleanup but far less lasting design/test value.

Side A fixes user-facing URL generation by using each item's display_path in vote links instead of internal storage URLs, aligning hrefs with the displayed DSL, and it substantially strengthens the browser test by exercising all 45 pairwise votes and verifying the final ranked order through the GardenRank API. Side B mainly updates the release workflow to Node 24 and removes obsolete tests, which is comparatively maintenance work without adding equivalent functional behavior or verification.

Side B fixes a real display/URL-encoding bug (hrefs now use display_path instead of raw storage path) and strengthens a browser test to exhaustively vote all 45 pairs and assert correct ranking output, adding real verification value. Side A mostly deletes a large, elaborate but unused keystroke-autocomplete parser and replaces it with a much simpler paste-and-go flow, which is a reasonable simplification but is largely destructive/refactor churn rather than a new correctness fix, and also removes a nontrivial regression test (parser_race.clj) without a clear replacement guard for the same race condition.

A replaces an unreliable ~1.8k-line keystroke graph, parser_action surface, race-prone JS, and Playwright race test with a small deterministic paste-and-go parser plus redirect—lasting design simplification and a real reliability fix. B’s display_path href correction and full 45-pair ranking assertion are precise and valuable, but narrower in scope than removing and rebuilding the broken navigation subsystem.

Side B fixes user-facing URL generation by using ItemId::display_path() instead of internal storage URLs for vote links, keeping hrefs consistent with the displayed DSL, and substantially strengthens the browser test to exercise all 45 pairwise comparisons and verify the final ranking and connectivity via RPC. Side A simplifies the navigation flow by replacing an unreliable autocomplete graph with a paste-and-go parser, but it also removes a large amount of parsing functionality and related tests in favor of a much narrower implementation.

Side B fixes a real, impactful bug (hardcoded staging/production hostnames breaking OAuth callbacks and redirects on custom hosts) by centralizing base-URL logic in a single util function and adopting HOSTNAME/window.location.origin, touching multiple real production files with clear lasting value. Side A improves test coverage and a display-path fix, which is useful but narrower in scope and mostly test churn plus a small correctness fix in one file.

A fixes vote hrefs to emit display_path forms (matching what users see) and replaces a shallow ≤15-iteration crawl with a full C(10,2)=45-pair run that asserts connected ranking a→j via GetGardenRank—lasting product correctness plus real algorithm coverage. B’s HOSTNAME/window.location.origin consolidation and staging deploy switch are useful infra fixes, but they are mostly mechanical host plumbing and ops config rather than core feature design.

Side B removes scattered hardcoded host/environment logic by introducing a shared `util/get-base-url`, updates multiple OAuth/callback and login redirect paths to use it, uses `window.location.origin` on the frontend, and adjusts deployment to staging, making the application work correctly on custom hosts. Side A fixes vote URL generation to use `display_path` instead of storage URLs and substantially strengthens the browser test by exercising all 45 pairwise votes and verifying the final ranking, but its functional impact is narrower than the cross-cutting redirect/configuration fix in Side B.

Side B fixes a real functional bug (Reddit children being imported without proper path wiring, causing incorrect tree structure) and also fixes unranked child labels to show titles instead of raw paths, with corresponding test updates verifying the fix. Side A is a solid but narrower UX fix (display_path in hrefs) plus a test rewrite, which is useful but less impactful than a genuine data-model correctness fix affecting import behavior.

B fixes lasting import/tree behavior: Reddit children attach via apply_entity_under_parent (no ensure_path intermediate segments) and ranking_panel shows real titles through child_label, with call sites and import tests updated. A’s production change is a narrower href encoding fix (display_path in vote links) plus a stronger 45-pair ranking browser test—valuable verification, but less core product impact than B’s data/UI wiring fix.

Side B fixes a functional import bug by introducing `apply_entity_under_parent` so Reddit child imports attach directly under the fetched parent instead of creating unintended `/comments/...` path structure, and updates the ranking panel to display imported titles for unranked children by passing the global tree into `ranking_panel`. Its integration tests also verify both self and children fetch flows with SSE morphs and rendered output, whereas Side A mainly changes vote URLs to use display paths and strengthens end-to-end testing of pool ranking behavior.

Side B adds a full CLI room-creation path (new CLI subcommand, RPC wiring, docs) plus a real simplification removing the unused ThreadVisibility concept and switching rooms from HashMap to HashSet, touching many files consistently. Side A is a smaller, focused fix (display_path in hrefs) with a much improved test, which is valuable but narrower in scope than B's cross-cutting feature+cleanup.

B adds a real user-facing CLI path (`room create`) and permanently simplifies the domain by dropping `ThreadVisibility`/`RoomState` so rooms are a `HashSet` of private ids, with matching RPC/reducer/docs/tests. A’s lasting substance is smaller: encode `display_path` in vote hrefs plus a stronger 45-pair ranking browser assertion, valuable but incremental versus B’s feature + model cleanup.

Side A fixes user-facing URL generation by using `display_path()` for vote and pool links instead of stored canonical URLs, keeping hrefs consistent with the UI and DSL, and strengthens coverage with an end-to-end test that exercises all 45 pairwise votes and verifies the final garden ranking through `GetGardenRank`. Side B adds a useful `room create` CLI command and simplifies room state by removing unused visibility, but much of the patch is API cleanup, documentation updates, and plumbing rather than a targeted correctness improvement backed by stronger behavioral testing.

Side B performs a substantive type-safety refactor (resolve_item returns CanonicalItemUrl, Deref newtype impls, typed pools/keys throughout rpc.rs and validate.rs), reducing stringly-typed bugs across a broad surface. Side A is a smaller, useful UI/test fix (display_path in hrefs plus a strengthened browser test) but touches far less of the codebase and has narrower long-term impact than B's type-system hardening.

A fixes real href behavior (encode display_path for left/right/pool instead of full storage URLs) and replaces a shallow 15-iteration smoke loop with a full C(10,2)=45 pairwise vote plus GetGardenRank assertions on connectivity and a→j order. B is a worthwhile CanonicalItemUrl/Deref type-threading refactor that removes String wrap/unwrap noise across RPC/validate, but it does not add user-visible correctness or stronger behavioral guarantees.

Side A fixes user-facing URL generation by using `display_path()` for vote links instead of exposing stored canonical `https://slug.social/...` IDs, aligning hrefs with the displayed DSL paths. It also substantially strengthens the browser test by exercising all 45 pairwise votes in a 10-item pool and asserting the final ranking through `GetGardenRank`, providing end-to-end verification of ranking correctness. Side B is a useful type-safety refactor (returning `CanonicalItemUrl`, propagating typed paths, and adding `Deref`), but it is largely structural and does not introduce an equally direct functional improvement or behavioral guarantee.

B fixes a real UX/architecture bug (redirect-based auth flow replaced with in-page morphing, consistent with the app's poem JS pattern) and simplifies auth.rs by reusing the shared layout function, providing lasting design value across success/error paths. A is a solid but narrower fix (correcting href encoding to use display_path) plus a much stronger test rewrite, but the core code change is smaller in scope and the test, while thorough, is not itself product functionality.

A fixes a real consistency bug (vote hrefs encoding full storage URLs instead of display_path ~/… forms users see) and replaces a weak ≤15-iteration smoke loop with a full C(10,2)=45-pair vote run plus GetGardenRank assertions on connectivity and a→j order. B’s auth fragment/morph work is solid UX design (inline error/success, drop redirects and a special layout), but it is polish on an adjacent flow rather than core ranking correctness plus lasting regression coverage.

Side B changes the authentication flow to return HTML fragments instead of redirects and extends the shared Poem JS form handler to morph returned HTML into the existing form, enabling inline success/error feedback while preserving existing empty-body POST behavior. Side A fixes vote URLs to use display paths and substantially strengthens an integration test by exercising all 45 vote pairs and asserting the final ranking, but much of its impact is in test coverage rather than runtime behavior.

Side B adds substantive new functionality (Reddit post rendering module with image/link extraction, thumbnail and full-image display, new tests and CSS) despite an unhelpful commit message, while Side A is a smaller, useful fix (display_path in hrefs) plus a test rewrite that mainly increases test coverage without new production logic. B's feature work has broader lasting impact on the rendering pipeline than A's incremental URL-encoding and test change.

B adds lasting product capability: extends EntityData with image_url/link_url, proper Reddit parsing helpers, a dedicated render module for post cards and ranked child rows, CSS, and a fixture-backed parse test. A is a valuable but narrower fix (display_path in vote hrefs) plus a stronger pool e2e assertion; it hardens existing behavior rather than expanding the core surface.

Side B adds a substantial new capability: Reddit-specific rendering for entity pages and ranking lists, extends the entity data model with image/link metadata, parses additional Reddit fields, adds styling, and includes a regression test fixture for preview extraction. Side A fixes vote URLs to use display paths and greatly expands browser test coverage by exercising all 45 vote pairs and asserting the final ranking, which improves correctness and verification but is narrower in scope than the new end-user functionality introduced in Side B.

Side B fixes a real bug (the vote-compare preview region never actually morphed with the new post card, only edge history did), improves sort semantics of vote history display, adds a fullscreen layout with cross-theme CSS, and includes a targeted new unit test plus doc updates. Side A is a smaller, useful fix (display_path in hrefs) with a much more thorough test rewrite, but its scope and impact are narrower than B's combination of bugfix + feature + layout + tests.

B delivers lasting product design: page-relative edge ratios/sort, completed post-success morph (preview card + history), a reusable chromeless layout, and unit coverage—not just fullscreen CSS. A’s display_path href fix is correct but small, and its 45-pair ranking assertion mainly strengthens a browser test rather than shipping comparable core behavior.

Side B adds durable functionality and structure to the vote-compare flow: it introduces a reusable chromeless fullscreen layout, updates successful vote submissions to morph in the new post preview, normalizes and sorts edge-history ratios relative to the displayed left/right pair, and adds unit/browser test coverage for the new behavior. Side A makes a useful correctness fix by using display paths in vote URLs and strengthens testing with an exhaustive 45-pair ranking assertion, but its production code changes are comparatively small and primarily supported by expanded tests.