c_939729b4d9a6890f46

Side A is a self-contained, well-tested feature: it adds a dedicated render/reddit module with image/link extraction, thumbnail rendering in lists, and a fixture-backed unit test, all wired cleanly through existing code paths. Side B's diff pulls in large Cargo.lock/dependency churn (rand, urlencoding, zerocopy) and references new modules (pair.rs, html/vote.rs) that aren't shown in the patch at all, making the change appear incomplete and harder to verify as a coherent, lasting contribution.

B adds the core pairwise vote/compare loop (vote route and CTA, post-vote `next` navigation, ratio slider JS, and `$form:i32` typed template holes with tests), which is central lasting product behavior versus A’s Reddit-only presentation layer. A still delivers real value—EntityData `image_url`/`link_url`, parse helpers, a clean `render::reddit` split, fixtures/tests, and list/detail thumbnails—but that is domain polish on top of browsing, not the sorter’s primary interaction path; B’s Cargo.lock churn does not change the ordering.

Side A adds a substantial Reddit-specific rendering layer: it extends `EntityData` with `image_url`/`link_url`, extracts those fields during Reddit parsing, introduces reusable `render::reddit` components for entity pages and ranking rows, integrates them into existing HTML, and adds parsing tests plus a fixture. Side B mainly prepares infrastructure for a voting flow (typed form holes, redirect support, route wiring, CSS/JS, dependencies), but the core voting implementation is absent from the patch, making its lasting functional value much smaller than A's completed feature.

Side A adds substantive new functionality (typed form holes for numeric fields, vote-page routing/redirect logic, new dependencies wired in) accompanied by unit tests validating the new behavior, giving it broader lasting impact. Side B is a focused but narrower UI refactor (merging multiple cli_panel calls into one bordered panel with hover-to-copy and a JS-safety assert) that improves polish but touches less core logic and lacks tests.

A adds real product capability: typed $form:i32 substitution with tests, RecordVote next-navigation, vote CTAs/route wiring, and the compare-page CSS/JS slider behavior. B only refactors the existing cli_panel into a grouped hover-to-copy widget plus safety asserts—useful UX polish, but narrower and less foundational than A’s feature and form-template work.

Side A adds substantive application behavior: typed `{"$form:i32":...}` template substitution with tests, a new `next` navigation field for vote handling, vote-page routing/UI integration, and client-side support for vote sliders and redirects after recording a vote. Side B mainly refactors the CLI helper into a grouped, clickable panel with CSS updates and a defensive assertion that command strings are safe for embedding in single-quoted JavaScript, which is a useful UI improvement but has a narrower long-term impact.

Side A is a small, self-contained, clearly correct improvement to test infrastructure that removes brittle manual suite enumeration and is documented well. Side B's diff, despite touching more files, includes churn (Cargo.lock dependency bumps), an uninformative 'fix' message, and references a new `html::vote` module (`pub mod vote;`, `vote::vote_page`, `vote::vote_href`) whose actual file contents are absent from the diff, suggesting an incomplete/inconsistent commit that would not build on its own.

B delivers substantial product value: typed $form:i32 holes, RecordVote next-navigation, a /vote compare flow (route, CSS, slider JS, item-page CTA), and supporting deps/tests. A only rewrites tests.edn to a single auto-discovered suite—useful hygiene, but config-only and far smaller lasting impact.

Side A replaces manually enumerated Kaocha test suites with a single auto-discovered `:all` suite using `^test\..+`, eliminating ongoing maintenance and ensuring new `test.*` namespaces are automatically executed in both local runs and CI. Side B adds many dependencies and introduces vote-related functionality, but the visible changes are broad and partly infrastructural, while much of the patch is lockfile churn without enough context to assess the lasting value of the new feature.

Side A shows a genuine architectural improvement: it removes the ad-hoc, hardcoded per-domain combinator engine (engine.rs, with special-cased reddit/youtube logic) in favor of a documented generic graph/DFA approach with a fallback for unknown sites, generalizing URL canonicalization beyond two hardcoded domains. Side B bundles plumbing (new deps, typed form holes, a vote CTA link, CSS/JS for a slider) but its core new logic (vote.rs, pair.rs) isn't visible in the diff, making it hard to verify the actual 'fix' beyond UI wiring and dependency additions.

A replaces the ad-hoc ParsedUrl combinator engine and per-host normalize paths with a graph-based canonicalization API (registry rewired to graph/parse, docs and module layout updated)—core lasting design for ItemId identity. B adds real vote UX wiring (typed $form:i32 holes, next redirect, route/CSS/JS), but it is mostly product-surface and dependency churn versus A’s deeper domain redesign.

Side B introduces concrete functionality: typed form substitution for `{"$form:i32": ...}` with tests, support for a `next` redirect after recording votes, routing and UI plumbing for a voting flow, and corresponding client-side behavior. Side A mainly replaces the URL canonicalization implementation with references to new `graph`/`parse` modules while deleting the old engine from the shown patch, making it primarily a structural refactor in the visible changes rather than a clearly demonstrated functional improvement.

Side A introduces a real feature (a vote page/redirect flow, typed form-hole substitution for i32 fields, new dependencies wired correctly, JS slider logic, CSS) with accompanying tests, delivering substantial new functionality. Side B is a small, well-reasoned cleanup removing dead code and adjusting a test's assertions, which is valid but far more limited in scope and lasting impact.

A ships a real vote-compare flow (route, HTML/CSS/JS, post-vote navigation via `next`, `$form:i32` substitution with tests) that extends product capability. B only deletes a dead zero-ratio early-return already enforced elsewhere and adjusts one test—correct hygiene, but negligible lasting design impact.

Side A introduces substantive functionality and infrastructure: typed form-template substitution for i32 fields with tests, a new `next` navigation flow after recording votes, routing/hooks for a voting UI, and supporting client-side behavior and dependencies. Side B only removes a redundant zero-ratio guard from `apply_vote` and updates the corresponding test expectations, which is a small cleanup compared with A's broader, lasting feature and correctness improvements.

B adds genuinely new, tested functionality (typed `$form:i32` template holes with round-trip tests, a post-vote redirect via `next`, and wiring for a new `/vote` route with supporting CSS/JS), which extends the project's real capability. A is a more narrow internal refactor (Deque→Vec for recent_votes) that removes write-time capping (`trim_recent_votes`) in favor of read-time capping, a plausible simplification but one that trades bounded storage growth for simplicity, with less clear net benefit despite the added test.

A is a focused core design change: recent_votes moves from capped Deque/VecDeque with write-time trim to append-only List/Vec with query-time cap, drops apply-path parent tracking, bumps schema, and adds a concrete load-cap test. B adds useful vote UX wiring (form :i32 holes, next redirect, slider/CSS, route hooks) but is diluted by Cargo.lock noise and leaves the declared vote/pair modules out of the patch, so less durable substance per line.

Side A makes a substantive storage-model redesign by replacing the durable recent-vote deque with an append-only list, removing post-commit trimming, updating schema versioning, capping history at query time, and adding a focused regression test to verify only the newest 200 votes are loaded. Side B mostly adds UI features (vote page plumbing, typed form holes, navigation, CSS/JS, and dependencies), but despite its size it contains comparatively less core architectural value than A's persistence and data-loading changes.

Side A is a focused, well-documented bugfix (skip pinned Reddit posts) with a clear commit message and a dedicated unit test proving correctness. Side B, despite its size, is a sprawling, undocumented ('fix') mix of unrelated changes (Cargo.lock/dep additions, form_template typed holes, ui_action changes) that references a new `html::vote` module without including its source file, suggesting an incomplete or non-compiling commit.

B ships core voting product work: typed `$form:i32` template holes with tests, a `/vote` flow wired through actions/UI (including post-vote `next` navigation), item-page vote CTA, and supporting slider JS/CSS. A is a correct, tested filter to skip stickied/pinned Reddit children, but it is a narrow import tweak versus B’s broader lasting feature surface.

Side A implements a focused behavioral bug fix by skipping stickied/pinned Reddit posts during subreddit import, adds a dedicated helper checking both `stickied` and `pinned` flags, updates documentation, and includes a regression test verifying only normal posts are imported. Side B is a large feature/dependency change (new routing, UI behavior, form typing, CSS, JS, and lockfile updates), but much of the patch is infrastructure and generated dependency churn rather than a clearly demonstrated correctness improvement.

Commit B introduces substantive new functionality (a new /vote route and page, typed form holes for i32 parsing with tests, JS slider wiring, and CSS for a real feature) despite the vague commit message, while A adds a modest CLI display helper with tests but no new capability beyond formatting existing stats. B's changes touch more of the actual product surface (routing, templating, UI) with lasting design implications, whereas A is a small, self-contained convenience feature.

B delivers a substantial product feature: typed $form:i32 substitution, record-vote next navigation, a /vote compare flow with slider JS/CSS, and item-page CTAs—core voting UX wiring—whereas A only formats already-existing ConnectivityStats into CLI pair output plus two unit tests. B’s design and surface-area expand lasting capability; A is a small, correct display convenience.

Side B introduces substantive new behavior across the server: typed form-template substitution for integer fields (`$form:i32`) with tests, a new `next` navigation flow after recording votes, routing and UI hooks for a vote page, and supporting client-side slider logic and styling. Side A is a useful CLI enhancement that formats and displays existing connectivity statistics with good test coverage, but it mainly exposes existing data rather than adding comparable new functionality.

Side A is a coherent, self-contained bugfix: it replaces a silently wrong fallback (unwrap_or(0)) with an explicit invariant check, fixes the actual 0-based vs 1-based indexing bug, updates docs, and adds concrete regression tests verifying the fix. Side B's diff references new modules (crate::html::vote, crate::pair) and routes that are never defined in the shown patch, making it appear incomplete/non-compiling as presented, and mixes unrelated dependency additions (rand, urlencoding) and generated Cargo.lock churn with the actual feature work.

B ships a real user-facing vote-compare flow (route, CTA, slider JS/CSS, post-vote `next` navigation) plus reusable form infrastructure (`$form:i32` holes and tests), whereas A only tightens rank-history indexing from optional 1-based `unwrap_or(0)` to required 0-based `expect` with matching docs/tests. B’s design surface and lasting product value outweigh A’s focused correctness cleanup.

Side B adds substantive new infrastructure: typed form-template substitution (`$form:i32`) with tests, a `next` navigation flow after recording votes, new routing/hooks for a vote page, and supporting UI behavior (slider initialization and redirect handling). Side A mainly tightens an invariant by replacing `unwrap_or(0)` with `expect(...)`, updates documentation/tests to enforce 0-based thread indices, and always renders the post link; these are useful correctness and clarity improvements but are narrower in lasting 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.

Side B performs a substantive, consistent refactor centralizing path/URL logic into a shared slug-types crate with new correct-by-construction newtypes (GardenItemUrl, ForumThreadUrl, TildeOntologyPath), reducing duplication and improving type safety across API responses, with tests migrated intact. Side A adds a real feature (typed form holes, vote redirect, vote page wiring) but bundles unrelated Cargo.lock dependency churn and CSS/JS additions with less architectural cohesion, making its net value more mixed.

Side A delivers lasting product capability: typed `$form:i32` holes, vote navigation via `next`, item-page CTAs, compare UI CSS/JS slider, and routing/deps to make child voting usable. Side B is a worthwhile but behavior-preserving move of path canonicalization into slug-types newtypes (GardenItemUrl/ForumThreadUrl), improving structure without new user-facing behavior.

Side B performs a broad architectural refactor by moving canonical path normalization and URL construction into shared `types::paths` newtypes (`GardenItemUrl`, `ForumThreadUrl`, `TildeOntologyPath`) and updates API/RPC types and call sites to use them instead of ad hoc string helpers. Side A adds useful user-facing voting functionality (typed form substitution, vote navigation, slider support, and a new vote route), but much of the visible patch is UI/CSS and dependency additions, whereas B centralizes path identity and reduces duplication across the codebase with a more durable design improvement.

Side B is a genuine refactor that consolidates duplicated web_post.rs logic into ui_html.rs, removes now-dead /post routes, introduces a cleaner WebSession abstraction, and updates tests/fixtures accordingly—reducing code duplication and clarifying the dispatch path. Side A adds a real feature (vote page, typed form holes) but is messier: it bundles unrelated dependency additions (rand, urlencoding, zerocopy chain) into Cargo.lock, references an undefined vote module in the diff, and mixes CSS/JS additions with backend logic without clear architectural improvement.

A adds lasting product capability (child vote CTA, /vote flow, preference slider JS/CSS) plus reusable typed `$form:i32` substitution and a `next` redirect on record_vote, with tests. B is a worthwhile consolidation—folding web_post into POST /ui, WebSession, and __rpc__ forms—but mostly relocates existing ingest/check/redact behavior rather than net-new design or fixes.

Side B performs a substantial architectural refactor by consolidating web posting, checking, and redaction into the unified `/ui` RPC flow, introducing shared `WebSession` resolution, removing the duplicated `web_post.rs` implementation, and updating forms, routes, and tests accordingly. Side A adds useful functionality such as typed `i32` form holes, vote navigation, and UI support, but much of the patch is dependency updates and incremental feature work rather than the broad simplification and maintenance improvement delivered by Side B.

Side A ships a working feature (vote page redirect, typed form holes, slider UI, CSS/JS) with tests exercising new behavior, adding real user-facing value. Side B is a solid cleanup removing legacy projection code and simplifying epoch/commit views, which is valuable but more narrowly a refactor/removal rather than new lasting capability; both are reasonable but A's net new functionality edges out B's cleanup.

B removes dual-path legacy GitDiscovery/Emission projection from epoch and commit pages, making Evidence envelopes the sole source of truth and tightening Emission required fields—lasting schema integrity over compatibility shims. A adds real product surface (typed $form:i32 holes, vote CTA/nav/slider, deps/routes) but is partly wiring/UI and a vaguer “fix,” so it trails B’s architectural permanence.

Side A introduces substantive application functionality: typed form-template substitution for integer fields with tests, a new post-vote navigation flow via the `next` field, UI support for a vote slider, and wiring for a new `/vote` page with related dependencies and styling. Side B mainly removes legacy GitDiscovery projection paths so pages rely only on Evidence envelopes, simplifying code and updating tests, but it is largely a cleanup/schema migration rather than adding enduring user-facing capability.

Side A is a small, focused, well-tested correctness fix (min-max gradient normalization) with clear rationale and updated unit tests exercising the new logic. Side B is a sprawling, vaguely-labeled 'fix' commit that mixes unrelated concerns (Cargo.lock/dependency additions, typed form holes, a new vote redirect flow, CSS/JS additions) referencing a `html::vote` module whose implementation isn't even included in the diff, making it hard to verify correctness or review in isolation.

B adds the vote-compare flow (route, page CTA, slider UI/JS, typed $form:i32 holes, next navigation, CSS), which is core product capability with tests; lockfile/deps are supporting noise but the feature is lasting. A is a precise, well-tested visualization fix (score min–max vs list ordinal) but only refines rank-row colors within an existing list.

Side A makes a focused behavioral improvement by changing rank row coloring from list-position-based to score-based min–max normalization within each group, adds a dedicated `score_gradient_t` helper, and includes targeted tests for score mapping, ties, and styling behavior. Side B mostly introduces infrastructure and dependencies for a voting feature (new crates, routing, UI hooks, CSS, typed form holes, redirect support), but much of the core functionality is absent from the patch, making it a broader yet less self-contained contribution.

Side A is a focused, well-explained fix that replaces awkward redirect-based auth flow with in-place HTML fragment responses, consolidates layout code, and adds matching CSS — a clear, self-contained improvement. Side B, despite being labeled 'fix', bundles unrelated concerns (new dependencies, Cargo.lock churn, a new vote-compare feature, typed form-hole parsing, JS slider logic) into one vague commit, making it harder to evaluate as a coherent, necessary change even though it includes some useful tests.

B adds lasting product surface: typed $form:i32 template holes with tests, RecordVote next-navigation, a /vote route and vote CTA, plus the compare-page CSS/slider wiring that make voting usable. A is a focused auth UX win (fragment responses + poem innerHTML morph, shared layout), but it stays scoped to signup feedback and does not expand core sorter behavior the way B does.

Side A implements a coherent authentication UX improvement: the auth endpoint now returns HTML fragments instead of redirects, the shared form layout is refactored into reusable fragments, the client-side Poem JS morphs form contents when a non-empty response is returned, and matching success styling is added. Side B mixes dependency additions, UI scaffolding, typed form-template support, and CSS for a voting feature, but much of the visible functionality depends on code not present in the patch (such as the new vote module), making its standalone lasting contribution less substantial.

Side A fixes a real type-mismatch bug (form holes only supported strings, but RecordVote requires integer ratios) via a generalized `$form:i32` mechanism with solid test coverage, and adds a functional next-redirect for the vote flow. Side B is a smaller, valuable cleanup (deduplicating entity markup and fixing an ID-collision selector bug for side-by-side entity cards), but it's more incremental refactoring versus A's necessary correctness fix and added capability.

A lands the vote feature end-to-end: $form:i32 template holes with tests, RecordVote next navigation, /vote routing, slider JS, and the bulk of vote-compare CSS/UX. B is a solid follow-on DRY/refactor (data-entity-section selectors, reuse entity_section in vote cards, drop duplicate markup/CSS) but mainly reshapes display plumbing rather than adding comparable product capability.

Side A adds substantive functionality across the application: typed form-template substitution for integer fields with tests, support for a new `next` navigation flow after recording votes, new routing and dependencies for a voting page, and UI/CSS/JS changes to support vote comparison. Side B is primarily a refactoring that reuses the existing `entity_section` component in the vote UI and switches DOM updates from a global `#entity-section` ID to per-item selectors, improving component reuse but with a much narrower lasting impact.

Side B introduces a real feature extension (typed $form:i32 holes, a new /vote page/route, redirect-after-vote support) with accompanying unit tests, representing genuine new functionality and a more general templating mechanism. Side A is a UI polish commit (vote counts on garden icons, unpin button behavior) that is useful but narrower in scope and mostly cosmetic/test-adjustment work, with less structural or reusable value than B's typed-hole and routing additions.

B lands lasting core design: typed `$form:i32` holes, RecordVote `next` navigation, vote route/CTA, and the compare slider/UI plumbing that the product builds on. A is valuable polish (HUD unpin vs false permalink, edge vote counts, regression tests) but refinements on existing garden-pin behavior rather than new foundational capability.

Side A delivers concrete product improvements: it adds pairwise vote counts to the garden UI with supporting logic and tests, changes the pinned-item HUD from a misleading permalink into a functional unpin action via POST /ui, updates CSS, and adds browser coverage for the new behavior. Side B mainly lays groundwork (new dependencies, typed form-hole substitution, routing/hooks, CSS/JS scaffolding) with only small visible behavior changes, and much of the apparent functionality depends on code not present in the patch.

Side A adds real product functionality (typed form holes for i32, a vote-compare feature with new route/module, UI slider, redirect handling) with supporting tests, delivering lasting user-facing value. Side B is pure test-suite refactoring (deduplicating HTTP/OAuth helpers across bb test files) which improves maintainability but adds no product capability.

Commit A ships lasting product value: typed $form:i32 holes, RecordVote next-navigation, a /vote compare flow (route, CSS, slider JS, CTA on item pages), and supporting deps/tests. Commit B only deduplicates bb test helpers (assert harness, slug-server-env, mock Google, registration) into common/oauth with no product behavior change.

Side A adds functional behavior across the application: typed form-template substitution for `i32` fields with tests, a new `next` navigation flow after recording votes, routing and UI hooks for a vote page, and supporting client-side slider logic and styling. Side B primarily refactors test infrastructure by consolidating duplicated OAuth, build, environment, and assertion helpers into shared utilities, improving maintainability but leaving project behavior essentially unchanged.