c_45dfa34511fe7817af

Side A fixes a genuine, well-diagnosed algorithmic bug (bipartite Markov chain from wrong normalization divisor) with a principled, cited fix and solid regression tests across multiple topologies. Side B is a mixed bag: a URL-path refactor (dropping a '/' separator, seemingly cosmetic/risky) bundled with unrelated YouTube URL normalization and Url-as-HashMap-key documentation tests, lacking a clear unifying rationale and touching many call sites for a stylistic route change of uncertain necessity/value.

A is a precise core bugfix: it replaces the incorrect weight-sum d_max with the paper's degree-based d_max so Rank Centrality is aperiodic and star topologies converge to the right stationary distribution (π=1/2,1/4,1/4) instead of oscillating to uniform, backed by targeted Rust and end-to-end Clojure regression fixtures. B is a large but mostly structural URLs/routing refactor (concatenated room segments, helpers, YouTube normalization) whose lasting substance is secondary to the ranking correctness fix.

Side A fixes a core correctness bug in the ranking algorithm by switching Rank Centrality to the canonical degree-based d_max, eliminating oscillation in star topologies and adding focused regression tests (Rust and end-to-end fixture tests) that verify the corrected behavior. Side B is a broad URL/routing refactor that centralizes room path handling and adds URL normalization utilities, but it is largely structural and API reshaping rather than fixing a comparably fundamental algorithmic correctness issue.

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 adds a focused, well-tested feature (pool-scoped voting) with clear intent, threading pool state through queries, hrefs, and post-success JS in a way that matches its commit message. Side B's 'url refactor' bundles two unrelated things—a debatable regression that squashes readable /r/{short}/{slug} URLs into a single ambiguous /r/{short}{slug} segment, plus an unrelated large YouTube URL-normalization module and url::Url hashing test suite—making it a messy, scope-creeping commit whose net value is unclear despite its size.

A adds a complete, user-facing capability: optional pool-scoped /vote pair picking, next-pair constrained to siblings, UI entry point, and pool threaded through post-success morph—real product behavior with targeted call-site wiring. B’s valuable core (YouTube/query URL identity normalization and room_route helpers) is lasting, but much of the diff is mechanical route/path churn collapsing /r/{short}/{slug} into one segment across handlers, tests, and fixtures, so overall lasting value is lower than A’s focused feature.

Side A delivers a complete user-facing capability: `/vote?pool=` can automatically select child-item pairs, keeps pool context through vote submission and next-pair navigation, and adds a "vote on children" entry point, with corresponding query handling and navigation updates. Side B mostly refactors room URL handling into shared helpers and adds URL normalization utilities (including YouTube canonicalization), which improves maintainability and consistency but is primarily structural compared with A's end-to-end feature addition.

Side A removes ~1800 lines of speculative, unreliable keystroke-transition-graph parser code and replaces it with a small, robust paste-and-go implementation, deleting a flaky JS race-condition workaround and a Playwright test that existed only to work around that bug — a clear net simplification and real bugfix. Side B is a mixed bag: it adds a genuinely useful YouTube/query-param URL-identity normalizer with good test coverage, but it also introduces a fragile room-route encoding (concatenating short-id+slug into one path segment, relying on a fixed-width assumption) that degrades URL readability and adds indirection without a clearly compelling justification, making its overall lasting value less clean-cut than A's decisive complexity reduction.

Commit A deletes an unreliable ~1800-line keystroke graph parser plus race-prone JS/tests and replaces it with a simple paste-and-go URL extractor that redirects to ranking—removing walk-on complexity and fixing the actual UX failure. Commit B is a solid URL/routing harden (room path encoding + YouTube/query identity normalization) but is more incremental infrastructure compared to A’s decisive simplification.

Side B introduces reusable URL infrastructure by centralizing room route encoding/decoding (`room_route_segment`/`room_id_from_route_segment`), updating routing and link generation across the application, and adding URL normalization utilities (including canonicalization for YouTube and query ordering) with focused tests. Side A mainly replaces a complex autocomplete/navigation system with a much simpler paste-and-go flow by deleting the parser graph and related UI, which simplifies maintenance but also removes functionality rather than adding broadly reusable project capabilities.

A does a genuine cross-cutting refactor: it introduces `room_route_segment`/`room_id_from_route_segment` helpers to replace ad-hoc split_once logic scattered across many files, plus a new URL-normalization module (with solid test coverage) that fixes real identity bugs like YouTube URL variants and query-order collisions. B is a smaller, useful bugfix (attribution leak, dead swap button, route rename) but touches far less surface and adds less lasting infrastructure than A's DRY refactor and normalization logic.

A lands lasting design: shared room route encode/decode (`room_route_segment` / `room_id_from_route_segment`), a simpler `/r/:room_key` surface wired through routes/nav/tests, plus real external URL identity normalization (YouTube rewrites, query sorting, case policy). B’s patches are correct but narrower—delegate attribution out-of-band, stop the bad <2-sibling fallback, drop swap, rename `/vote/compare`→`/vote`—valuable fixes without comparable structural weight.

Side A introduces a substantive URL-routing refactor by centralizing private room path encoding/decoding (`room_route_segment`/`room_id_from_route_segment`), replacing ad hoc string splitting across handlers, routes, navigation, URL builders, and tests. It also adds reusable URL normalization utilities (including canonicalization for external URLs such as YouTube links), improving long-term consistency and maintainability, whereas Side B mainly fixes vote-page behavior, removes an unnecessary UI control, renames `/vote/compare` to `/vote`, and corrects delegate handling for vote posts.

Side B untangles a real design flaw—rooms (permission boundary) were previously conflated with forum threads—introducing a proper `RoomCreated`/`RoomState` model and a unified RPC batch API that the CLI and tests are migrated onto, which is a more foundational and consequential architecture fix. Side A is a solid but narrower DRY refactor (a shared `room_route_segment` helper plus new URL/YouTube normalization) that removes duplication but also trades away human-readable `/r/{short}/{slug}` URLs for a concatenated, length-coupled segment. Both are substantial, but B addresses a deeper structural problem with broad, well-tested follow-through, giving it more lasting value despite being messier and self-described as a first pass.

B re-architects the domain and API: rooms replace thread-as-boundary (RoomCreated, room_id + thread_tag on Ingest, ScopeId::Room, ingests_by_scope_thread), collapses many REST handlers into a batched RPC surface, and updates CLI/tests accordingly—foundational, lasting structure. A is a focused URL cleanup (fixed-width /r/{short}{slug} helpers, route/handler/test updates, plus external URL/YouTube normalization) that improves consistency but builds on surface encoding rather than core model.

Side B introduces a lasting architectural change by consolidating many REST endpoints into a typed batch RPC interface (`RpcCommand`/`RpcResult`), refactoring the CLI to use it, and restructuring reducer/event models around room and thread separation (`room_id` + `thread_tag`). Side A makes a useful URL refactor—centralizing private room route encoding/decoding with `room_route_segment` and adding URL normalization helpers—but it is narrower in scope and primarily updates routing and URL handling rather than the project's core API and state model.

B introduces a coherent room-route encoding abstraction (room_route_segment/room_id_from_route_segment), consistently applies it across server routes, tests, and Clojure fixtures, and adds real URL-normalization logic (YouTube canonicalization, query sorting) with substantial unit tests, delivering concrete bugfixes/consistency improvements. A adds a new UI action/template system which is architecturally interesting but is more speculative plumbing (new form-template DSL, ui_html endpoint) without the breadth of test coverage or demonstrated end-to-end correctness that B shows across many call sites.

A adds lasting architecture: form-template hole fill, HtmlUiAction parsing, a unified POST /ui handler, and shared run_* web-post paths plus progressive new-thread UI—new capability with tests. B’s room URL collapse to /r/{short}{slug} and route churn is mostly mechanical; its real upside (room_route helpers and HTTP identity/YouTube normalization) is narrower than A’s UI command surface.

Side A adds substantial new infrastructure: a new `/ui` endpoint with `HtmlUiAction` parsing, JSON form-template substitution (`form_template.rs`), reusable web-post handlers, and UI expansion flows for thread forms, introducing a reusable browser UI command architecture. Side B is largely a refactor that centralizes room URL encoding/decoding (`room_route_segment`/`room_id_from_route_segment`) and updates routes plus some URL normalization utilities, which improves consistency but is narrower in scope and mostly restructures existing behavior.

A performs a genuine, broad correctness refactor: it introduces validated room_route_segment/room_id_from_route_segment helpers (replacing brittle ad-hoc split_once calls across handlers, nav, search, and tests) and adds a real url_normalize module with tested YouTube-link canonicalization and query-sorting logic that improves external item identity handling. B adds a self-contained dev-only sorterc tool and offline module—useful for local iteration but isolated from core routing/product logic and lower-stakes than A's cross-cutting fixes to route parsing and canonical URL identity.

A delivers a lasting core design change: tightens private-room HTTP paths to a single `/r/{short}{slug}` segment with shared `room_route` encode/decode, wires it through routers/nav/path builders/tests, and adds durable external-URL identity normalization (YouTube rewrite, query sort). B only adds a workspace-only offline CLI plus `server` helper module for local .sorter compile/JSONL lint—useful developer friction reduction, but non-runtime and easy to recreate relative to A’s product-facing URL contract.

Side A introduces a lasting URL routing redesign by centralizing private-room path encoding/decoding (`room_route_segment`/`room_id_from_route_segment`), replacing ad hoc `split_once('/')` logic across routing, link generation, navigation, tests, and constants such as `ROOM_SHORT_ID_LEN`. It also improves canonical URL handling with reusable normalization utilities (including YouTube normalization and stable external URL canonicalization), whereas Side B primarily adds an offline developer tool (`sorterc`) that reuses existing validation and ranking logic without changing the application's core behavior.

Commit A fixes a real routing/identity design issue (single opaque `/r/{short}{slug}` segment with validated round-trip helpers plus updated route wiring and tests) and adds a genuinely useful URL-identity normalization layer (query sorting, YouTube canonicalization) with substantial test coverage across multiple call sites (nav, search, write_actor, integration tests). Commit B is a clean, well-tested feature addition (RoomList RPC + CLI + isolation tests) but is narrower in scope and lower architectural impact than A's cross-cutting correctness fix.

A lands lasting core design: centralized room path encode/decode (`room_route_segment` / `room_id_from_route_segment`), a real HTTP identity normalizer (YouTube + sorted query), and wires both through routes, URL builders, and tests. B adds a useful but narrow RoomList RPC/CLI with isolation tests—solid product surface, smaller architectural footprint than A’s URL/identity layer.

Side A introduces a cross-cutting URL routing refactor by centralizing room path encoding/decoding (`room_route_segment`/`room_id_from_route_segment`), updating all server routes and link generation to use a single canonical representation, and adding URL normalization logic (including canonicalization of external URLs such as YouTube links). Although broad, these changes reduce duplicated parsing logic and establish reusable infrastructure, whereas Side B adds a useful but self-contained `RoomList` RPC/CLI feature with good authorization-aware tests but limited architectural impact.

Side A is a coherent, well-tested DSL redesign (explanation-first votes) that updates the parser, docs, and every fixture/test consistently across CLI, server, and browser tests, with a clear rationale in the message. Side B bundles a questionable, unexplained room-route change that removes a path separator (arguably reducing readability, e.g. '9ab12cdmy-room') together with a genuinely useful but narrowly-scoped YouTube URL normalization feature, making its overall value more mixed and less clearly justified.

A changes the core sorter language: votes become explanation-first (`{reason}` then comparison) with a real parser split (block-prefixed votes vs path-then-body items), docs, UI payloads, and fixtures updated to match—lasting product/DSL design. B is valuable infra (collapse `/r/{short}/{slug}` to one segment via `room_route_segment`, plus YouTube/query URL normalization) but is mostly routing/identity cleanup rather than a domain-model shift.

Side B introduces reusable infrastructure by centralizing private-room route encoding/decoding (`room_route_segment`, `room_id_from_route_segment`, `ROOM_SHORT_ID_LEN`) and updating routing, URL generation, and tests to use it consistently, while also improving URL canonicalization for external identities (including YouTube normalization and query normalization). Side A makes a sweeping DSL syntax change requiring vote explanations to precede comparisons and updates the parser, UI, documentation, and many fixtures, but much of the patch is mechanical migration to a new syntax rather than adding broadly reusable functionality.

Side A consolidates duplicated room-route parsing logic into shared, validated helpers (room_route_segment/room_id_from_route_segment) used consistently across many endpoints and tests, and adds a substantive, well-tested URL-identity normalization layer (query sorting, YouTube canonicalization) that fixes real duplicate-identity bugs in the ontology system. Side B is a valid, narrower bugfix (Reddit child import wiring and unranked-label rendering) but touches far less surface area and adds less lasting infrastructure than A's DRY refactor plus new normalization module and its 20+ regression tests.

A adds lasting shared design: fixed-width room path encoding (`room_route_segment` / `room_id_from_route_segment`), route/nav/test alignment to `/r/{short}{slug}`, and external URL identity normalization (YouTube rewrites, sorted query pairs) used by `canonicalize_item`. B is a real but localized fix—Reddit children attach via `apply_entity_under_parent` without `ensure_path` nesting, plus title-based unranked labels—valuable for that import/UI path yet narrower lasting surface than A’s core routing and identity model.

Side A introduces a durable routing abstraction (`room_route_segment`/`room_id_from_route_segment` and `ROOM_SHORT_ID_LEN`), updates all server routes and URL generation to use a single encoded room path format, and adds URL normalization utilities (including canonicalization of external URLs such as YouTube links) with accompanying tests. Side B fixes a real Reddit import bug by attaching imported children directly under the fetched parent and improves unranked child labels using stored titles, but its impact is narrower and localized compared with Side A's project-wide API and URL consistency improvements.

Side A fixes real security gaps (fail-closed vote actor resolution instead of silent anon fallback, gating mock OAuth behind an env flag, Secure cookie support, stricter open-redirect sanitization) plus adds useful nav UX, all backed by targeted unit tests. Side B is a substantial but purely cosmetic URL-format refactor (collapsing room short/slug into one path segment) bundled with an unrelated, large speculative URL-identity normalization module and many exploratory tests documenting url::Url hashing behavior, which adds bulk without clear necessity or lasting security/correctness value.

A delivers lasting security/correctness: fail-closed vote actors (no anon fallback), production mock-OAuth gating, Secure cookies, and tighter return-to sanitization, plus session-aware nav—core integrity for voting. B’s room-path consolidation and YouTube/query URL normalization are real design wins and better DRY, but a large share is mechanical route/shape churn across handlers and tests, so it trails on necessity per line.

Side A delivers substantive security and correctness improvements: voting changes from fail-open anonymous fallback to fail-closed authenticated sessions, cookies gain conditional Secure handling, OAuth mock login is gated by an environment flag, open-redirect sanitization is strengthened, and these behaviors are covered by new tests. Side B is largely a URL/path refactor that centralizes room route encoding and adds URL normalization utilities, but most changes are mechanical rewrites of routing and link generation with comparatively less impact on core correctness and security.

B implements a real, self-contained feature: a background Reddit fetch worker with OAuth token handling, rate-limit/backoff logic, JSON parsing, and unit tests, wired cleanly into AppState—genuine new capability with lasting value. A is a URL-refactor that centralizes room-route encoding (good) but changes the public room URL format from '/r/{short}/{slug}' to '/r/{short}{slug}' (ambiguous, harder to read) and bundles in a large, seemingly unrelated speculative youtube-normalization/url-identity-test module that adds significant surface area without clear necessity for the stated 'url refactor' goal.

A lands durable core design: centralized room path encoding (`room_route_segment` / fixed-width short id), route and link call sites rewritten to one segment, plus real external URL identity normalization (YouTube rewrites, sorted query pairs) with tests—replacing scattered `split_once('/')` URL building. B is a solid vertical feature (Reddit broker, OAuth, rate-limit/dedup worker, parsers) that replaces a stub, but it is product-specific integration plus a scratch `todo` file, so it adds less lasting cross-cutting value than A’s URL/types foundation.

Side A performs a broad but coherent refactor that centralizes room URL encoding/decoding into shared helpers (`room_route_segment`, `room_id_from_route_segment`, `ROOM_SHORT_ID_LEN`), updates routing and link generation consistently across the server, and adds URL normalization logic with tests, reducing duplicated parsing and making URL handling more maintainable. Side B adds a substantial Reddit background fetch pipeline with OAuth, rate limiting, and parsing, but it is a new feature with placeholders still remaining (for example the TODO file and no rendering changes), making its long-term project impact less certain than A's foundational cleanup and normalization.

A consolidates duplicated room-id/slug splitting logic into a single `room_route_segment`/`room_id_from_route_segment` API (used consistently across UI, API, and tests) and adds a well-tested external-URL normalization module (YouTube canonicalization, query sorting) that improves identity correctness for garden items—substantial, tested infrastructure work. B is a narrower but solid correctness fix (rejecting invalid vote ratios) with good test coverage, but it's much smaller in scope and impact compared to A's broader refactor and new normalization capability.

A lands lasting shared design: fixed-width `/r/{short}{slug}` encoding (`room_route_segment`/`room_id_from_route_segment`), route/handler consolidation, and external identity normalization (YouTube rewrite, sorted query pairs, case-preserving dash paths) with broad call-site and test updates. B is a correct but narrow domain guard—reject 0-sided and >100 vote ratios in DSL, UI POST, and reducer, plus regression tests—valuable integrity work that does not match A’s reusable URL architecture impact.

Side A introduces a substantial, cross-cutting URL and routing refactor: it centralizes room route encoding/decoding with new `room_route_segment`/`room_id_from_route_segment` helpers, updates server routing and URL generation to a unified `/r/{room_key}` format, and adds URL normalization infrastructure (including canonicalization improvements and tests). Side B is a focused validation change that enforces vote ratio bounds across the parser, UI, and reducer with appropriate regression tests, but its impact is narrower than the architectural routing and URL normalization work in Side A.

B is a cohesive architectural refactor: it moves path canonicalization into slug-types with strongly-typed GardenItemUrl/ForumThreadUrl/TildeOntologyPath newtypes, replacing scattered string-based helpers across the whole API surface with correct-by-construction types, improving long-term maintainability. A mixes a legitimate room-URL refactor (dropping the slash between short/slug) with a large speculative addition of YouTube-specific URL normalization and extensive url::Url identity documentation tests that are tangential to the stated 'url refactor' goal, diluting its focus and adding untested-in-practice heuristic logic.

A adds lasting product/design substance: room URLs become a single validated `/r/{short}{slug}` segment via `room_route`, plus real external identity work (`url_normalize`, YouTube rewrites, query sorting, dash path case rules) wired through canonicalize and call sites/tests. B is valuable but mainly a move of existing canonicalization/path helpers into `slug-types` with GardenItemUrl/ForumThreadUrl newtypes and re-exports—structural centralization and API typing more than new behavior.

Side A delivers a functional URL routing redesign by introducing shared `room_route_segment`/`room_id_from_route_segment` helpers, updating all server routes and handlers to use the new single-segment `/r/{room_key}` format, synchronizing ID generation via `ROOM_SHORT_ID_LEN`, and adding URL normalization logic (including YouTube canonicalization and query normalization) with tests. Side B is primarily an architectural refactor that centralizes existing path and URL helper types into `slug_types::paths` and replaces string helpers with typed wrappers across the API, improving organization and type safety but largely preserving behavior.

Side A fixes a real concurrency bug (shared sentinel delegate blocking multi-user votes) with a minimal, well-targeted change plus a direct regression test proving the fix. Side B is a large URL-encoding refactor (dropping the '/' between room short-id and slug) that changes external URL identity/canonicalization behavior broadly, touches many call sites and tests, and bundles in unrelated YouTube URL normalization logic, increasing risk and surface area without a clearly motivated bug being fixed.

A fixes a real multi-user failure: shared WEB_BROWSER_AGENT sentinels bound on first browser vote and blocked later humans, replaced by Option<agent>/None delegates with a focused regression test for two users voting. B mainly renames room HTTP paths (/r/short/slug → /r/{short}{slug}), centralizes that encoding, and adds URL identity helpers—useful structure, but largely route churn and niceties versus A’s correctness fix.

Side A fixes a concrete correctness bug by removing shared browser sentinel delegates, changing pending sessions to carry an optional agent, ensuring browser actions use no delegate, and adding an integration test proving two different browser users can both vote without hitting the shared `AgentBound` failure. Side B is primarily a broad URL/route refactor and normalization effort (new room route encoding, URL helpers, and canonicalization), which may improve consistency but is largely structural compared with A's targeted functional bug fix backed by regression tests.

Commit A fixes a real production bug (Reddit blocking OAuth-required requests) with a targeted, well-tested retry/refresh mechanism and clear error surfacing. Commit B is a large URL-encoding refactor mixed with an unrelated YouTube-normalization feature; it changes room URLs to a less readable format (short+slug concatenated without separator) and touches many call sites/tests for cosmetic reasons, increasing churn risk without a clear necessity or bug motivation.

B delivers lasting platform design: centralized room path encoding (`room_route_segment` / fixed-width short id), route and href call-sites updated consistently, plus durable external URL identity normalization (YouTube shapes, sorted query pairs) with real tests. A is a strong, necessary production bugfix (require OAuth when creds exist, AuthRejected + forced refresh, no www.reddit.com fallback, fly.toml base URL), but it is narrower and confined to the Reddit worker path.

Side A fixes a concrete production reliability issue by requiring OAuth when credentials exist, adding token refresh-and-retry on 401/403 responses, improving error propagation instead of silently falling back, and adding targeted tests for error truncation. Side B is a broad URL/routing refactor that centralizes room path handling and adds URL normalization utilities, but much of the patch is mechanical call-site updates and route rewiring rather than addressing a specific correctness or availability problem.

Side A is a substantial, coherent refactor that introduces a shared room-route encoding module, fixes real URL-consistency bugs, and adds meaningful new normalization logic (YouTube URL canonicalization, query sorting) with extensive new tests, touching many call sites consistently. Side B is a small, correct bugfix (moving a zero-ratio guard earlier to avoid ghost items) which is valuable but narrow in scope and lasting impact compared to A's broader architectural improvement.

A delivers lasting design: centralized room path encoding (`room_route_segment` / single `/r/:room_key` segment), shared `ROOM_SHORT_ID_LEN`, and external URL identity normalization (YouTube canonicalization, query sorting, case policy) wired through routes, HTML, and types. B is a precise, high-value correctness fix (zero-ratio votes no longer leave ghost items or voted_pairs), but it is a small localized guard move versus A’s foundational URL/routing model.

Side A introduces lasting infrastructure by centralizing private-room route encoding/decoding (`room_route_segment`/`room_id_from_route_segment`), updating all routing and URL generation to use it, and adding URL normalization utilities (including canonicalization improvements and tests). Side B is a good targeted bug fix that correctly moves the zero-ratio guard before `ensure_item` and `voted_pairs.insert`, preventing ghost items and stale voted pairs, but its scope and long-term architectural impact are much smaller.

Side A removes a small demo feature and adds a real, non-trivial improvement (async settlement worker + cached ranking scores) that fixes a legitimate concurrency/performance concern, but is scoped narrowly. Side B is a broader, more substantial refactor introducing shared, tested room-route encoding logic (room_route_segment/room_id_from_route_segment) that fixes duplicated/error-prone split_once logic across many call sites, plus adds URL normalization (YouTube canonicalization, query sorting) with extensive test coverage, providing more consistent, reusable, and better-tested infrastructure across the codebase.

Commit A removes the throwaway demo-counter path and replaces synchronous vote apply+log with a batched SettlementClient worker plus ranked_items_cached / warm_ranking_cache, so HTTP reads take read locks only and ranking is computed off the request path—a lasting concurrency and core-domain design. Commit B mainly pulls room short+slug into one path segment, centralizes room_route helpers, and adds YouTube/query URL normalization; useful but largely routing/identity polish versus A’s architectural write-path redesign.

Side A makes a substantial architectural improvement by introducing a settlement worker that batches vote persistence and ranking recomputation, adds cached ranking reads (`ranked_items_cached`), warms the cache at startup, and switches HTTP rendering from write locks to read locks. It also removes the temporary demo counter and related event/UI code, whereas Side B is primarily a URL refactor that centralizes private-room route encoding/decoding and adds URL normalization helpers, which is useful but narrower in long-term impact.