c_c6beb77e8e716123aa

Side A implements a complete, testable Reddit fetch worker (OAuth token handling, rate-limit/backoff logic, URL mapping, JSON parsing for posts/subreddits, and unit tests) that is real, functioning capability wired into AppState and routes. Side B is a smaller, valuable refactor—fixing duplicate `#entity-section` ids via a per-item selector and deduplicating vote-compare card rendering—but it's a cleanup/bugfix on top of existing UI rather than new lasting functionality.

A implements a full Reddit fetch pipeline (broker worker, OAuth, rate-limit/backoff, URL mapping, JSON parsers, tree updates, and browse/ensure wiring)—core lasting product capability. B mainly refactors UI targeting (id→data-entity-section) and reuses entity_section on the vote page with CSS cleanup; useful DRY/SSE polish but much smaller lasting design impact.

Side A replaces a Reddit import placeholder with a working background fetch system, including request queuing, OAuth support, rate-limit handling, caching/deduplication, JSON parsing, integration into application state, and automatic fetch triggering when Reddit items are viewed or added. Side B is primarily a UI refactor that introduces per-item entity-section selectors for DOM morphing and reuses the existing entity component in the vote page, improving maintainability but adding far less core functionality.

Side A refactors the actual application: it fixes duplicate-id morph targets by switching to per-item data-attribute selectors, unifies vote-compare rendering with the shared entity_section component (reducing duplication and inconsistency), and cleans up corresponding CSS—real, functional improvements to the codebase. Side B merely adds deployment config/docs for an unrelated third-party tool (Open WebUI on Fly.io), which is useful ops tooling but not a code improvement to the project itself and carries less lasting architectural value.

A hardens core UI architecture: entity sections move from a single #entity-section id to per-item data-entity-section selectors with a shared helper, unwind duplicate vote-compare markup into entity_section, and drop dead CSS—enabling multi-entity morphs. B only adds peripheral Fly.io deploy config/docs for Open WebUI, which does not change the product’s lasting design or behavior.

Side A makes a functional architectural improvement by replacing the hard-coded `#entity-section` target with per-entity `data-entity-section` selectors and reusing the shared `entity_section` component in the voting UI, enabling correct SSE/Idiomorph updates for multiple entities and reducing duplicated rendering logic. Side B only adds deployment documentation and a Fly.io configuration for Open WebUI, which is useful operational guidance but does not change the project's runtime behavior or core design.

Side A introduces a genuinely new architecture (GlobalTree/NodeState hierarchical model, canonical ItemId URL parsing/normalization, breadcrumb navigation) with accompanying unit tests, replacing the flat scope-based ranking system — a substantial, lasting design shift that the codebase clearly builds on later (fetch/render modules in B depend on this tree). Side B is a smaller, useful cleanup (fixing duplicate-id morph targets, deduplicating vote-card rendering by reusing entity_section) but is narrower in scope and fixes a bug introduced by prior work rather than establishing new capability, and even contains a stray formatting glitch in the match arm indentation.

A replaces flat scope maps with a hierarchical GlobalTree/ItemId model, path canonicalization, journaled votes, breadcrumbs, and event replay—foundational design the app still sits on. B only switches entity morph targets to data-attribute selectors and reuses entity_section in vote cards (plus CSS cleanup), a useful but local UI DRY fix with far less lasting structural impact.

Side A introduces a substantial architectural shift from flat subreddit-scoped rankings to a hierarchical ItemId-based tree, adding GlobalTree/NodeState, canonical URL parsing, breadcrumb navigation, journaled vote handling, and compatibility for replaying legacy events. Side B is mainly a UI refactor that reuses the existing entity section for vote comparison and switches DOM morph targets to item-specific selectors, which improves maintainability but is much narrower in lasting impact.

Side B fixes a real correctness bug (duplicate `id="entity-section"` when multiple entities render, e.g. vote-compare page) by switching to per-item data-attribute selectors, and meaningfully deduplicates markup by reusing entity_section in vote_compare_item_card plus cleans up now-redundant CSS. Side A is almost entirely a planning document (plan.md) with a thin, largely unused RouteContext wrapper that doesn't change any actual behavior yet — it's scaffolding/notes rather than a functional improvement.

B fixes real multi-entity UI/SSE behavior by replacing a single global `#entity-section` id with per-item `data-entity-section` selectors and consolidates vote-compare cards onto the shared `entity_section` path (with matching CSS cleanup). A mostly adds a temporary `plan.md` plus a thin `RouteContext` newtype still keyed on `CanonicalItemUrl`, so less lasting shipped design than B's concrete morph/target and DRY fix.

Side B makes a functional refactor that introduces per-item `data-entity-section` selectors and updates SSE/Idiomorph morph targets to use them, removing reliance on duplicate global IDs and reusing the shared `entity_section` component in the voting UI. Side A primarily adds a planning document plus a thin `RouteContext` wrapper around `ThreadNav` with no migration of existing call sites, so it contributes architectural intent more than implemented behavior.

Side B fixes a real correctness issue (duplicate `id="entity-section"/"entity-panel"` elements when multiple entities render on one page, e.g. vote compare) by switching to per-item `data-entity-section` selectors, and it meaningfully deduplicates code by reusing `entity_section` in vote.rs instead of a near-duplicate markup/CSS implementation. Side A is a clean but more superficial UI refactor (grouping cli_panel rows, adding a JS-safety assert) that improves one small widget without addressing any underlying bug or duplication.

B replaces a single global #entity-section/#entity-panel identity with per-item data-entity-section selectors and routes SSE morphs through that helper, then reuses entity_section on the vote compare UI instead of a large duplicated card path—fix structural multi-entity update support and lasting DRY. A is solid UX (grouped CLI rows, click-to-copy, JS-safety asserts) but is localized polish on hint panels rather than a core rendering/update correctness fix.

Side B refactors entity rendering around reusable `entity_section`/`entity_panel` components, replaces duplicate `id` attributes with per-item `data-entity-section` selectors, and updates SSE morphing to target the correct entity via `entity_section_selector`, which is a structural correctness improvement. Side A improves the CLI panel UI by grouping commands, adding click-to-copy rows, and asserting JS-safe command strings, but those changes are primarily presentation and defensive checks rather than a broader architectural fix.

Side A fixes a real bug (duplicate hardcoded #entity-section ids breaking morph targeting when multiple entities render) by introducing per-item selectors, and it deduplicates vote-card rendering by reusing entity_section instead of a separate ad-hoc markup path, trimming CSS accordingly. Side B is a valid but minor dead-code removal with a supporting test update, offering less lasting architectural benefit despite being clean and correct.

A replaces a single global #entity-section/#entity-panel id with per-item data-entity-section selectors and a shared entity_section_selector, then reuses entity_section in the vote compare UI and drops the duplicated vote-compare markup/CSS—real lasting UI structure. B only deletes a dead zero-ratio early-return in apply_vote and adjusts one test, a correct but tiny cleanup already covered by parser/handler guarantees.

Side A makes a functional design improvement by replacing a global `#entity-section` target with per-item `data-entity-section` selectors and a shared `entity_section_selector`, allowing SSE/Idiomorph updates to address the correct entity section. It also refactors vote comparison to reuse the common `entity_section` rendering, eliminating duplicated UI code and aligning styling, whereas Side B mainly removes a now-redundant guard and updates tests to reflect existing behavior around zero-weight edges.

Side B is a substantial architectural refactor that removes cached, incrementally-mutated edge/index state (GroupState) in favor of a minimal ScopeVotes struct that derives rankings on demand, eliminating a whole class of rollback/mutation bugs and simplifying storage schema, with corresponding test updates across many files. Side A is a smaller, more superficial change (selector renaming, reusing entity_section markup in vote compare cards, CSS pruning) that improves consistency but has much lower architectural impact, and even introduces a stray formatting artifact in a match arm.

B redesigns core ranking state: GroupState’s cached indexes/edges/rollback become ScopeVotes (uuid_votes + recent_votes only), with edges and components derived on demand across reducer, ranking, storage, and pair logic—a lasting architectural simplification. A is useful UI cleanup (data-entity-section selectors, vote cards reusing entity_section, CSS trim) but is surface-level compared with B’s domain-model change.

Side B performs a substantial architectural refactor by replacing cached `GroupState` with `ScopeVotes`, deriving ranking edges and connected components on demand from deduplicated votes, and updating ranking, pairing, storage, replay, and tests accordingly. Side A mainly improves HTML reuse and correctness for multiple entity sections by replacing a fixed `#entity-section` target with per-item selectors and reusing `entity_section` in the vote UI, which is useful but much narrower in long-term impact.

Side B fixes a real security vulnerability (XSS via unsanitized Reddit selftext_html) using ammonia, with tests verifying script/attribute stripping while preserving benign markup—a durable, necessary fix. Side A is a speculative refactor (selector-based morphing, reusing entity_section in vote compare) that removes working vote-compare-specific markup/CSS and introduces a stray malformed match-arm pipe, with unclear net benefit and no tests.

B fixes a real XSS hole by sanitizing untrusted Reddit body_html with ammonia before PreEscaped render, plus a small sanitize module and tests—lasting security value. A is useful UI design (data-entity-section selectors, vote cards reusing entity_section, CSS cleanup) but is mostly structural reuse, not a correctness fix of comparable weight.

Side B fixes a significant security issue by sanitizing untrusted Reddit `body_html` with the `ammonia` crate before passing it to `maud::PreEscaped`, preventing script and event-handler injection, and adds focused tests for the sanitizer. Side A mainly refactors entity rendering to use per-item `data-entity-section` selectors for SSE/Idiomorph updates and reuses the entity component in the vote UI, which improves structure but is less critical and lasting than closing an XSS risk.

B is a substantive refactor that unifies vote-compare card rendering with the entity-section component and fixes duplicate-id bugs (multiple elements sharing `#entity-section`/`#entity-panel`) by introducing per-item selectors, reducing code duplication and CSS. A is a small, useful test-config change but is narrowly scoped to CI/test discovery convenience with no functional code impact; B's changes affect real runtime rendering correctness across multiple files.

B replaces a single global #entity-section id with per-item data-entity-section selectors and reuses entity_section in the vote compare UI, removing duplicated markup/CSS and enabling correct multi-entity morphing. A only simplifies tests.edn ns-patterns so new suites auto-discover—useful hygiene, but far less lasting product design impact than B’s unified entity rendering.

Side B makes a functional architectural improvement by introducing per-entity selectors (`data-entity-section` plus `entity_section_selector`) so SSE/Idiomorph updates target the correct entity instead of a single global `#entity-section`, and it reuses the shared `entity_section` renderer in the voting UI to eliminate duplicated rendering logic. Side A improves test maintainability by replacing manually enumerated Kaocha suites with automatic `^test\..+` discovery, which reduces future configuration work, but its impact is narrower than the UI update and code reuse changes in Side B.

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 is a self-contained, verifiable improvement: it fixes a real correctness issue (duplicate '#entity-section' ids breaking Idiomorph morphs when multiple entity sections coexist, e.g. on the vote-compare page) by switching to per-item data-attribute selectors, and it removes ~35 lines of duplicated markup in vote.rs by reusing the shared entity_section renderer. Side A deletes the old engine.rs and rewires registry.rs to call new `graph`/`parse` modules and an external test file, but those new modules and tests aren't shown in the diff, so the actual replacement logic (and whether it preserves correctness/tests) can't be verified from the patch itself.

A replaces ad-hoc per-host normals in engine/registry with a graph-based canonicalization API (parse + DFA graph, thin public registry, docs), which is core ItemId identity infrastructure. B is a solid but narrower UI fix: data-entity-section selectors instead of a single #entity-section id, reuse of entity_section on the vote page, and related CSS cleanup—valuable local composition, not foundational domain logic.

Side B makes a concrete functional improvement by replacing the global `#entity-section` target with per-item `data-entity-section` selectors, allowing SSE/Idiomorph updates to address the correct entity block, and it reuses the shared `entity_section` rendering in the voting UI instead of duplicating markup. Side A is primarily a large architectural refactor of the URL canonicalization layer (replacing `engine` with `graph`/`parse` and updating the API), but the shown patch mostly removes code and redirects to new modules whose implementation is not included, making its lasting functional benefit less directly demonstrated by the diff.

Side A fixes a real correctness bug (duplicate `#entity-section`/`#entity-panel` IDs breaking SSE morph targeting when multiple entity sections appear on a page, e.g. vote comparison) by switching to per-item data-attribute selectors, and also deduplicates ~80 lines of markup/CSS by reusing entity_section in the vote card. Side B is a minimal one-line env-var fix for an OAuth NameError, which is a valid but narrow and trivial fix with little lasting design impact.

A replaces singleton #entity-section/#entity-panel IDs with per-item data-entity-section selectors and reuses entity_section in the vote compare UI (with matching CSS cleanup), a lasting multi-target morph/design fix. B only adds a missing GITHUB_API_BASE_URL default—correct and necessary, but a four-line config patch with far less structural impact.

Side A replaces the hard-coded `#entity-section` target with a per-item `data-entity-section` selector via a shared `entity_section_selector()` helper, updates all SSE morph calls to use it, and reuses the same `entity_section` rendering in the voting UI, eliminating duplicated markup and avoiding reliance on duplicate IDs. Side B is a small but useful bug fix that defines `GITHUB_API_BASE_URL` with a default to prevent a NameError when the environment variable is absent, but its scope is much narrower.

Side B fixes a real concurrency bug where a non-reentrant RwLock read guard was held across nested locking calls, which could deadlock the RPC handler, and adds a regression test plus test-harness reliability fixes (timeouts, avoiding pipe-buffer deadlocks) that improve project robustness. Side A also fixes a legitimate bug (duplicate `#entity-section` ids breaking multi-item morph targets) and reduces duplication in vote card rendering, but it's more localized UI plumbing versus B's server-correctness and test-infra fix.

B fixes a real Tokio RwLock deadlock by scoping reduced-state read guards in RoomCreate/RoomGrant so locks drop before nested awaits, and backs it with a room-create integration test plus test harness fixes (log-file pipes, HTTP timeouts). A mainly refactors entity morph targets from fixed #entity-section IDs to data-entity-section selectors and reuses entity_section in the vote UI—valuable DRY/cleanup, but not a correctness fix of B’s weight.

Side B fixes a substantive concurrency bug by ensuring `tokio::sync::RwLock` read guards are dropped before later `read().await`/`write().await` calls, preventing self-deadlocks in `RoomCreate` and `RoomGrant`, and adds an integration test covering room creation. Side A is a useful UI refactor that replaces a hard-coded `#entity-section` target with per-item selectors and reuses `entity_section` rendering in the vote view, but it is primarily structural and less critical than eliminating a deadlock in core RPC handling.

Side B substantially deduplicates a large amount of copy-pasted HTTP/OAuth/test-harness boilerplate across four test files into shared helpers in test.common and test.oauth, reducing maintenance burden without changing behavior—clear lasting value with low risk. Side A refactors entity-panel selectors to be per-item and reuses entity_section in vote comparisons, which is a reasonable improvement but also introduces a stray syntax artifact (`| FetchJobResult::SkippedDuplicate`) and removes some vote-compare-specific styling/markup, making it a slightly riskier and more speculative change.

A ships a lasting production design fix: entity sections become per-ItemId data-attribute morph targets (no shared #entity-section/#entity-panel IDs), fetch streams use entity_section_selector, and vote-compare reuses entity_section instead of a parallel card/CSS path. B only consolidates duplicated Babashka test helpers (assert/ANSI, cargo build, server env, mock Google/HTTP) into common/oauth—valuable maintainability, but no product behavior or architecture change.

Side A makes a functional UI architecture improvement by replacing the global `#entity-section` target with per-item `data-entity-section` selectors via `entity_section_selector`, updating all SSE morph calls accordingly, which enables correct updates for multiple entity sections and reuses `entity_section` in the voting UI. Side B is a worthwhile refactoring that centralizes duplicated test helpers, OAuth utilities, build logic, and test harness code, but it primarily improves test maintainability rather than changing core application behavior.

Side A fixes a real correctness bug (duplicate `#entity-section`/`#entity-panel` IDs breaking morph targeting when multiple entity cards appear on the same page, e.g. vote compare) by switching to a per-item data-attribute selector, and it deduplicates significant logic by making vote_compare_item_card reuse entity_section instead of a parallel hand-rolled renderer. Side B is a smaller, well-tested UI tweak that changes sibling grouping semantics but has narrower impact and no bug being fixed.

A replaces single global #entity-section/#entity-panel IDs with per-item data-entity-section selectors and reuses entity_section in the vote compare UI, deleting duplicated markup/CSS—a lasting morph/SSE design fix. B only splits unranked siblings into singleton nav groups plus a unit test, a narrower UX tweak under #130.

Side A fixes a structural UI issue by replacing the hard-coded `#entity-section` target with per-item `data-entity-section` selectors, adds a reusable selector helper, and reuses the same `entity_section` component in the voting UI, reducing duplication and enabling correct morph/SSE updates for multiple entities. Side B changes sibling navigation so each unranked sibling becomes its own group and adds a focused test, but its impact is limited to one navigation behavior compared with A's broader architectural improvement and component reuse.