c_2722a31958255e8a78

B is a focused, self-contained algorithmic improvement to pair selection with clear rationale and new targeted tests validating the new tie-break logic, directly improving ranking quality. A is a large, sprawling URL-scheme refactor that collapses room routes from `/r/{short}/{slug}` to `/r/{short}{slug}` (arguably a regression in URL readability) plus unrelated YouTube normalization and hashing-contract tests, touching many files/tests for what is largely a cosmetic/format change with mixed value.

B improves core ranking behavior in `pair.rs` with clearer bridge sub-priorities (merge established → attach isolate → isolate pairs) and adjacent rank-zip refinement once the pool is connected, backed by targeted tests. A is largely a wide route/URL-scheme rename (`/r/{short}/{slug}` → `/r/{short}{slug}`) plus helpers; its real design add (YouTube/query identity normalization) is useful but secondary to mechanical path churn across server, tests, and fixtures.

Side A introduces a durable URL-routing refactor by centralizing room path encoding/decoding (`room_route_segment`/`room_id_from_route_segment`), updating all route handlers and URL builders to use a single `{short}{slug}` segment, replacing duplicated string-splitting logic, and adding URL normalization utilities and tests for canonical external identities. Side B meaningfully improves vote-pair selection by adding more nuanced bridge priorities and rank-based refinement with supporting tests, but its impact is confined to one subsystem, whereas Side A establishes shared infrastructure used across routing, link generation, canonicalization, and tests.

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 B refines a core algorithm (pair selection for ranking) with clear rationale, careful priority tie-breaking logic, and new targeted tests, improving the actual ranking quality feature of the app. Side A rips out a large, working (if complex) keystroke-autocomplete parser graph and replaces it with a much simpler paste-and-go textarea, which is a legitimate simplification but net removes substantial functionality (live autocomplete, guides, scrolling suggestions) and deletes a dedicated race-condition browser test without replacing that coverage, making it more of a regression/simplification than a strict improvement.

A replaces an unreliable ~1.8k-line keystroke graph (plus parser_action, race-guard JS, and the Playwright parser_race test) with a small, correct paste-and-go URL parser and redirect—removing lasting complexity and fixing real navigation. B is a solid, focused improvement to pair ranking priorities with good tests, but it refines existing selection logic rather than removing a broken subsystem.

Side B makes a targeted algorithmic improvement to pair selection by introducing component-aware bridge priorities and rank-based refinement order, then backs it with focused tests covering attachment, spanning-tree completion, and adjacent-rank selection. Side A removes a large autocomplete/parser graph in favor of a much simpler paste-and-go flow, which simplifies the codebase but also drops substantial functionality (autocomplete, incremental parsing, race handling) while replacing it with basic URL extraction and redirect behavior.

B implements a genuine algorithmic improvement to pair selection (spanning-tree bridging then rank-zip refinement) with clear rationale and thorough new tests validating the logic. A is a large, useful feature (per-room theme cookies + private-room URL prefixing) but is mostly plumbing/threading extra parameters through many call sites, which is real but more mechanical/lower-risk value than B's core-algorithm correctness improvement.

B tightens core ranking behavior with clear bridge/attach/isolate priorities and rank-adjacent zip refinement, backed by targeted tests—lasting product logic rather than surface work. A’s value is real (cookie/SSR themes and private-room wire URLs) but much of the diff is mechanical layout/signature plumbing across many pages, so it is broader yet less concentrated lasting design than B’s pair-selection change.

Side B makes a substantive algorithmic improvement to vote pair selection by introducing component-aware bridge priorities, rank-adjacent refinement once the graph is connected, and corresponding tests that validate the new behavior. Side A adds useful theme persistence across pages and login plus room-aware URL helpers, but much of the patch is broad plumbing to thread theme state through handlers, whereas Side B changes a core ranking heuristic with lasting impact on system behavior.

Side A is a large mechanical rename (CanonicalItemUrl -> ItemId) that reorganizes types but adds little new behavior, and it deletes a large planning doc that itself documents the refactor's incompleteness (e.g. leaving CanonicalItemUrl references, opaque fallback hacks). Side B implements a concrete, well-tested algorithmic improvement (component-aware pair selection with established/isolate sub-priorities and rank-zip refinement) that directly improves product behavior and is validated with new targeted unit tests, making it more durable, self-contained value.

A lands the durable ItemId design (new item_id/item_wire modules, removal of CanonicalItemUrl, and reducer/ranking/RPC/HTML keyed on structured identity), which reshapes the project’s core data model. B is a high-quality, well-tested improvement to pair selection heuristics in pair.rs, but its impact is confined to one algorithm versus A’s foundational type migration.

Side A performs a substantial architectural migration from string-based `CanonicalItemUrl` keys to a structural `ItemId` type across the reducer, ranking, routing, RPC, HTML, and tests, while extracting shared normalization into `item_wire.rs`. This establishes a stronger identity model and cleaner APIs (for example `RouteContext`/`garden_item_href` and typed map keys) that affects core project design, whereas Side B is a targeted improvement to pair-selection heuristics and adds tests for better vote scheduling but is confined to one subsystem.

Side B is a focused, well-tested algorithmic refinement to pair selection (established-component merging, isolate attachment, and rank-zip refinement) that improves a core ranking heuristic with clear new unit tests. Side A is a broader but more diffuse refactor mixing UI morphing, a new vote-compare page, ItemId normalization changes, and test infra shuffling, which adds real functionality but is riskier/noisier and less singularly focused than B's targeted improvement to existing logic.

A introduces the full vote-compare feature surface (new vote.rs UI, morph-after-vote path replacing next-URL redirects, ItemId::from_storage normalization used in votes/Reddit import, JsBuilder morph helper, CSS, and integration/e2e tests) plus the initial pair.rs bridge-aware selector. B only refines suggest_next_pair_in_pool with bridge sub-priorities and adjacent-rank zip ordering on that existing module—valuable ranking logic, but incremental on A’s foundation.

Side A delivers multiple lasting functional improvements across the project: it adds a dedicated pairwise voting UI with incremental DOM morphing after votes, introduces robust pair resolution and bridge-aware pair selection, and fixes identifier normalization by adding ItemId::from_storage and using it throughout vote processing and Reddit import to avoid inconsistent IDs. Side B is a focused refinement of the existing pair-selection heuristic—adding better tie-breaking for attaching isolates and adjacent-rank refinement with tests—but it builds on infrastructure introduced by Side A rather than providing comparable new functionality or cross-cutting bug fixes.

Side B implements a substantive, well-tested algorithmic improvement to pair selection (established-component merging, isolate attachment, rank-adjacency zipping) with several new unit tests validating the logic. Side A mostly removes an unrelated demo-counter feature and adds a settlement-worker/caching refactor, which is reasonable plumbing but is dwarfed by dead demo-code removal churn and lacks the depth of new behavior or test coverage seen in B.

A lands lasting architecture: a settlement worker that batches vote append/apply, warms and serves a ranking cache, and turns ranking/UI paths to read locks—plus full removal of the demo-counter event/UI surface. B only refines pair-suggestion heuristics (bridge sub-priorities and adjacent-rank zip) with good tests; valuable product logic, but narrower than A’s design and concurrency changes.

Side A introduces a substantial architectural improvement by moving vote persistence and ranking recomputation into a dedicated settlement worker, adding cached ranking reads (`ranked_items_cached`), warming the cache at startup, and switching HTTP paths from write locks to read locks. It also removes obsolete demo-counter code and event types, simplifying the application, whereas Side B improves the pair-selection heuristic with more nuanced bridge and rank-based prioritization plus tests, but its impact is limited to recommendation quality rather than core system architecture and performance.

Commit B delivers a substantial, real feature (GitHub OAuth login, session management, pseudonym claiming, identity event sourcing) plus a meaningful infra change (extracting durable into its own repo/dependency), backed by new integration tests and mock OAuth harness. Commit A is a smaller, well-scoped algorithmic refinement to pair-selection heuristics with good unit tests, but it's narrower in scope and impact compared to the auth system and repo restructuring in B.

B adds foundational multi-user auth (GitHub OAuth, sessions, pseudonym claims, identity event projection, and vote gating) plus integration tests, which the product needs for accountable votes. A is a strong but narrower improvement: better bridge/isolate priority and rank-zip pair selection in pair.rs with focused unit tests. Much of B’s diff is relocating durable out of tree (deletion noise), so A still earns solid weight, but auth is the larger lasting capability.

Side A makes a focused, lasting improvement to pair selection by introducing structured bridge/within-component prioritization, preferring attachment to established components, adding rank-aware 'zip' refinement once the pool is connected, and backing the behavior with targeted tests. Side B includes substantial functionality (GitHub OAuth, sessions, identity events) but the visible patch is dominated by moving the in-tree durable crate to an external Git dependency and large code deletion, making much of the apparent size repository reorganization rather than durable project logic.

Commit B is a substantial architectural migration (REST endpoints to a unified RPC batch API, introducing room-scoped state, rewriting reducer/thread indexing, CLI restructuring, and updating extensive integration/grant tests) that changes the project's core API surface and permission model. Commit A is a well-scoped, tested algorithmic refinement to pair-selection heuristics in one file, valuable but far narrower in scope and impact than B's system-wide restructuring.

B lands a foundational redesign: rooms as the permission/scope boundary separate from forum thread tags, a unified batch RPC surface replacing many REST handlers, and matching reducer/event/CLI/test updates—structure the project keeps building on. A is a precise, well-tested pair-priority improvement (attach isolates before isolate–isolate, then zip adjacent ranks) but is incremental product logic on an existing mechanism, so it carries less lasting architectural weight than B despite B’s larger mechanical migration surface.

Side B performs a substantial architectural migration: it replaces many individual REST endpoints with a unified RPC API, refactors the CLI to use it, introduces room-scoped operations and room/thread separation in events and the reducer, and updates tests and data structures throughout to support the new model. Side A is a well-targeted improvement to pair selection heuristics—adding smarter bridge prioritization, rank-based refinement ordering, and corresponding tests—but its impact is confined to one algorithm, whereas Side B establishes a broader, lasting platform redesign.

Side A makes a precise, well-tested improvement to the core ranking/pair-selection algorithm used in production voting flow, adding clear sub-priority logic and multiple targeted tests validating the new behavior. Side B adds a useful but peripheral dev-only tool (new crate, CLI, docs) that reuses existing server logic without touching core algorithms, providing convenience rather than fixing or improving the product's central logic.

A improves core pair-suggestion logic (bridge sub-priorities and rank-zip refinement) that every vote UX depends on, with concrete tests for attach-over-isolate and adjacent-rank ordering. B adds useful but peripheral offline dev tooling (sorterc + offline.rs) that does not change product ranking behavior.

Side A improves the project's core pair-selection algorithm by introducing structured bridge and within-component prioritization, preferring attachment of isolates to established components and rank-adjacent refinement once the pool is connected, with multiple targeted tests covering the new behavior. Side B adds a valuable offline developer tool (`sorterc`) for compiling `.sorter` files and scanning JSONL logs, but it primarily enhances development workflow rather than changing the application's core ranking behavior.

Side B adds a complete, end-to-end feature (RPC command, CLI subcommand, response type, and a real integration test proving per-user isolation) that delivers concrete, testable functionality. Side A is a more intricate refinement of an internal heuristic with good unit tests, but it's a narrower, single-file tweak to an existing algorithm rather than new user-facing capability, making B's contribution more broadly useful and durable.

A redesigns core pair selection with lasting structure (established-component bridges before isolate pairs, then rank-gap/zip_index within a fully connected pool) plus targeted unit tests for attach and 1v2-before-2v3 behavior. B adds a useful RoomList vertical slice (RPC filter on grants, CLI, isolation integration tests), but it is straightforward grant membership plumbing rather than deeper ranking design.

Side A changes the core pair-selection algorithm by introducing structured priority keys, preferring attachment of unranked items to established components, and refining comparisons using rank-adjacent 'zip' ordering once the graph is connected, with multiple targeted tests covering the new behavior. Side B adds a useful RoomList RPC, CLI command, response type, and integration tests, but it is primarily a new convenience feature rather than an improvement to the project's central ranking logic.

Side A refines a core ranking algorithm with clear, well-justified tie-breaking logic and backs the change with multiple targeted unit tests verifying the new behavior (attach-before-isolate, zip ordering). Side B adds a useful pool-voting feature across several files but introduces no new tests for the added endpoint/behavior and has more surface area for subtle bugs (e.g., untested pool validation, dedupe assumptions), making it riskier and less rigorously verified than A's focused algorithmic fix.

A upgrades the core pair-selection algorithm (bridge sub-priorities for spanning-tree growth, then zip-order adjacent rank refinement with established-component tracking) and locks it in with targeted tests—ongoing quality of every suggested vote. B adds real product surface (pool query param, children button, threading pool through vote UI/JS), but it is largely parameter plumbing over the existing suggest_next_pair_in_pool path rather than deeper ranking design.

Side A makes a substantive change to the core pair-selection algorithm by introducing component-aware bridge priorities, rank-based refinement ('zip' ordering) once a pool is connected, and adds targeted tests covering the new behavior. Side B mainly wires an existing capability into the UI and routing by adding pool-scoped `/vote` navigation and context propagation; while useful, it is largely integration work built on the underlying pair-selection logic rather than improving that logic itself.

Side B is a focused, well-tested algorithmic improvement to pair selection with clear tie-break logic and multiple new unit tests validating the new behavior, entirely within the core ranking domain. Side A is a large sprawling feature (Reddit entity import refactor) that touches many files, adds env-var complexity and a bash/clojure integration test, but is noisier and less self-contained, making its lasting design value harder to assess despite covering more surface area.

A lands lasting architecture: full Reddit payloads as EntityImported events with entity_raw + derived views, explicit fetch UI (no auto-fetch on browse), configurable API bases, and an end-to-end mock import test. B improves pair selection (attach isolates before isolate–isolate, then zip adjacent ranks) with solid unit tests, but it refines one ranking heuristic rather than the data/import model.

Side A introduces substantial new functionality and architectural improvements: it replaces automatic Reddit fetching with explicit user-triggered imports, persists full upstream payloads as replayable EntityImported events, stores raw entity data alongside derived views, adds configurable API/OAuth endpoints, dotenv loading, and corresponding integration/tests. Side B meaningfully improves the vote-pair selection heuristic by prioritizing component attachment and adjacent-rank refinement with good test coverage, but its impact is limited to algorithmic scheduling within an existing feature rather than adding durable infrastructure and persistence capabilities.

Side B fixes a real production bug (cloud IPs falling back to public Reddit API and getting blocked) with proper OAuth retry-on-401/403 logic, better error surfacing, and a config fix in fly.toml — a concrete operational reliability improvement. Side A is a thoughtful refinement of pair-selection heuristics with good test coverage, but it's an internal algorithm tweak with more speculative long-term value compared to B's fix for an actively broken production path.

A upgrades core ranking behavior with a real design change: established-first bridge merges, then isolate attach, then zip-adjacent rank refinement once the pool is one component, backed by targeted tests. B is a valuable production fix (force OAuth when creds exist, refresh on 401/403, pin base URL) but is integration/ops hardening rather than lasting product algorithm value.

Side B fixes a concrete production reliability issue by requiring OAuth when credentials are configured, adding automatic token refresh/retry on 401/403, returning structured auth-rejection outcomes instead of failing generically, and improving error handling with focused diagnostics. Side A meaningfully refines the pair-selection heuristic (component attachment priorities and rank-adjacent refinement with tests), but it is primarily an algorithmic preference change, whereas Side B prevents fetch failures caused by Reddit's API behavior and hardens a critical integration.

Side B is a substantial, correct architectural refactor (separating canonical_path/identity concerns, making delegate optional, standardizing wire identity to strip @ ambiguity) that touches many call sites consistently and is validated by updated integration tests, providing lasting clarity to a previously conflated events module. Side A is a well-tested but narrower heuristic tweak to pair-selection sub-priorities in one file, useful but of smaller architectural scope and impact than B's identity/API correctness overhaul.

A adds real pairing logic (established-component bridges before isolate–isolate, then rank-adjacent zip once connected) plus targeted tests in pair.rs, improving core ranking behavior. B mostly splits/moves canonicalize helpers, strips @ from wire/storage, and propagates optional naked delegates across many call sites—valuable API hygiene, but more contract/refactor churn than new lasting capability.

Side B makes a broad architectural improvement by separating canonical path handling from identity parsing, introducing dedicated `canonical_path.rs` and `identity.rs`, removing identity rewriting from the reducer, enforcing strict stored-form identities without `@` at API boundaries, and updating APIs, HTML, types, and tests consistently. Side A meaningfully improves pair selection with new bridge and rank-refinement heuristics plus targeted tests, but its impact is confined to one algorithm, whereas Side B establishes cleaner long-term boundaries and data handling across the project.

Side B implements a substantial, real feature: a background Reddit fetch worker with OAuth, rate-limit/backoff handling, JSON parsing for posts/subreddits, URL mapping, and wiring into AppState/HTML routes, backed by several unit tests—this is genuine, functional lasting capability. Side A is a well-tested refinement to an already-existing pair-selection heuristic, which is useful but more incremental/tuning-focused than a new capability.

B replaces a Reddit fetch stub with a lasting broker/worker (OAuth, rate-limit backoff, dedup/TTL, JSON mapping/parsing, browse/ensure_path hooks), which is foundational product capability. A meaningfully improves core pair selection (attach-isolate before isolate-isolate, then rank-adjacent zip) with solid tests, but it refines an existing path rather than delivering a new end-to-end subsystem.

Side B implements a substantial new capability: an asynchronous Reddit import pipeline with a background worker, request deduplication, OAuth support, rate-limit handling, JSON parsing into entity data, integration into application state and page loading, plus tests for URL mapping and parsing. Side A improves pair-selection heuristics with better bridge prioritization and rank-based refinement ordering backed by tests, but it is a targeted algorithm refinement rather than a broad new feature.

B fixes a real correctness bug (ghost items and falsely-marked voted pairs from zero-ratio votes) with a minimal, precise change and updates the test to verify the actual fixed behavior. A adds substantial heuristic complexity to pair selection with speculative tie-break priorities and several new tests, but it's tuning/heuristic refinement rather than fixing a concrete defect, and its correctness/value is harder to verify as clearly beneficial.

A upgrades core pair-selection with lasting design (established-component attach before isolate pairs; rank-centrality zip once connected) plus several targeted tests, shaping how rankings grow day-to-day. B is a real correctness fix (move zero-ratio return before ensure_item/voted_pairs) but a narrow edge-case guard with small scope versus A’s behavioral impact.

Side A substantially refines the pair-selection algorithm by introducing structured component layout tracking, prioritizing attachment of unranked items to established components, and adding rank-aware 'zip' refinement once the pool is connected, with multiple new tests covering the behavior. Side B fixes a real correctness bug by moving the zero-ratio early return before item registration and voted-pair insertion, preventing ghost state, but it is a narrowly scoped fix compared with A's broader, lasting improvement to core ranking behavior.

Side A meaningfully improves the core pairwise-comparison algorithm (the product's central ranking mechanism), adding principled sub-priorities for merging established components before isolates and zipping adjacent ranks, backed by targeted new tests validating each scenario. Side B fixes a real but narrower validation gap (zero/over-100 ratios) consistently across DSL, HTTP handler, and reducer with good test coverage, but it's an edge-case guard rather than a design improvement to core functionality.

A redesigns core pair selection with lasting ranking-hub behavior: bridge sub-priorities (merge established → attach isolate → isolate pair) and rank-adjacent zip refinement once the pool is connected, backed by targeted unit tests. B is valuable multi-layer input validation (reject 0 and >100 ratios in DSL, UI, and reducer) but is a narrower correctness guard than A’s algorithm change to the main voting loop.

Side B enforces consistent vote-ratio validation across the DSL parser, UI handler, and reducer, preventing invalid zero-sided votes from creating graph inconsistencies and adding comprehensive regression and integration tests. Side A improves pair-selection heuristics by prioritizing attachment to established components and rank-adjacent refinement, but those are algorithmic refinements rather than the broad correctness and input-validation guarantees introduced by Side B.

B fixes a real correctness bug (timestamp-based feed cutoffs failing under same-millisecond posts and clock rollback) and closes a permission-leak edge case for private rooms, backed by substantial integration tests exercising these exact scenarios. A refines pair-selection heuristics for a ranking algorithm with good test coverage, but it's an optimization/tuning change rather than a bugfix, and its value is more speculative/UX-quality than correctness-critical.

B fixes real correctness and permission bugs by anchoring catch-up to durable ingest index (not timestamps), so concurrent/same-ms and clock-rollback posts are not missed, and private-room visibility/revocation cannot leak or skip content; it also adds room on FeedPost and solid multi-user integration tests. A is a solid ranking heuristic refinement (attach-isolate before isolate-isolate, then zip adjacent ranks) with unit tests, but it optimizes pair suggestion quality rather than closing feed reliability/security gaps.

Side B fixes a correctness issue in feed catch-up by anchoring implicit pagination to durable ingest order instead of timestamps, preserving behavior across same-millisecond posts and clock rollback, while also enforcing permission-aware visibility and exposing room metadata. It refactors duplicated feed-building into a shared helper and adds comprehensive integration tests for multi-user, private-room, and permission-revocation scenarios, whereas Side A mainly improves pair-selection heuristics and ordering for ranking refinement with supporting tests.