c_48fcbcde8f8871f223

Side A performs a substantive architectural refactor of the ranking data model (replacing cached GroupState with derived-on-demand ScopeVotes), removing stale cached invariants and simplifying storage/reducer logic while preserving/updating test coverage across many files. Side B is pure test-infrastructure deduplication (moving duplicated bb helper functions into shared modules) which improves maintainability but has no functional or architectural impact on the actual product.

Commit A redesigns core ranking state (GroupState → ScopeVotes), dropping cached edges/indexes and rebuilding weights/components only at rank time across reducer, ranking, storage, and UI paths—a lasting correctness and simplicity win. Commit B only extracts duplicated babashka test helpers (HTTP, mock OAuth, asserts, cargo env) into shared modules with no production behavior change.

Side A fundamentally redesigns ranking storage by replacing cached `GroupState` edge/index data with a minimal `ScopeVotes` model and rebuilding edges, item indexes, connected components, and rankings on demand. This touches ranking, persistence, reducers, UI, and tests to preserve behavior while simplifying state and eliminating duplicated cached data, whereas Side B mainly consolidates duplicated integration-test helpers into shared utilities (`test.common`/`test.oauth`) without changing core project behavior.

Side A meaningfully deduplicates substantial test infrastructure (mock OAuth server, HTTP helpers, pass/fail harness, env builders) across three test files into shared modules, reducing maintenance burden with no behavior loss. Side B is a small, cosmetic UI tweak (removing a toggle button and simplifying placeholder text) with minimal lasting architectural value.

A consolidates duplicated test harness, HTTP/OAuth mocks, cargo build, and server-env helpers into common.bb/oauth.bb and rewires auth/grants/integration to use them, a lasting DRY improvement across the suite. B only trims a public new-thread compose toggle and tweaks labels/placeholders in forum.rs—cosmetic UI churn with little structural impact.

Side A consolidates duplicated test infrastructure into shared helpers (`test.common` and `test.oauth`), introducing reusable functions like `run-cargo-build-release!`, `slug-server-env`, `complete-registration!`, and configurable mock OAuth behavior while updating multiple test suites to use them. This reduces duplication, centralizes maintenance, and also standardizes HTTP timeouts and multi-user OAuth testing; Side B is primarily a UI cleanup that removes the form toggle and tweaks placeholders/button text without adding comparable lasting functionality.

Side A changes the durable storage schema (Deque -> List) with a real design rationale (avoiding a costly truncate-on-write, moving the cap to read-time), removes now-dead code paths, bumps schema version, and adds a targeted test validating the new capping behavior—this is substantive production logic. Side B is a pure test-suite refactor (deduplicating HTTP/OAuth helpers across bb test scripts) which improves maintainability but has no runtime/product impact.

Commit A redesigns core projection storage (Deque→List, trim-on-write→cap-on-read, schema bump, reducer/apply path cleanup) and adds a regression test, which is lasting production behavior. Commit B only consolidates duplicated Babashka test helpers/OAuth fixtures without changing product semantics, so it is useful hygiene but lower lasting value.

Side A changes the project's storage design by replacing the durable recent-vote deque with an append-only list, removing per-apply trimming, moving the cap to query time, bumping the schema version, and adding a regression test that verifies only the newest 200 votes are loaded. Side B is a useful refactoring of the integration test infrastructure (shared HTTP/OAuth helpers, common build/env functions, and reduced duplication), but it primarily improves test maintainability rather than changing core project behavior.

Side B removes substantial duplicated OAuth/HTTP/test-harness code across four test files by consolidating into shared test.common and test.oauth modules, reducing maintenance burden and duplication risk with no behavior change. Side A is a reasonable UI refinement (grouped CLI panel, JS-safety assert) but is smaller in scope and purely cosmetic/feature-polish rather than structural improvement.

B removes large duplicated blocks (HTTP clients, mock Google OAuth, assert/pass-fail harness, server env, cargo build) from auth.bb/grants.bb/integration.bb into shared test.common and test.oauth (with complete-registration! and multi-user mock), lasting maintainability win. A improves production cli_panel UX (grouped cmds, row click-to-copy) plus JS-safety asserts and CSS, but is narrower polish versus B's cross-suite foundation.

Side A changes the HTML API from a single command to a list, consolidates multiple CLI hints into one panel, adds click-to-copy rows, and introduces runtime assertions preventing unsafe characters from being embedded in single-quoted JavaScript, improving both usability and correctness. Side B is a valuable refactor that centralizes duplicated test utilities (OAuth helpers, build helpers, assertions, shared server environment) and adds request timeouts, but it primarily reduces maintenance overhead in the test suite rather than changing core project behavior.

Side A eliminates substantial duplicated HTTP/OAuth/test-harness code across four test files by consolidating it into shared common.bb/oauth.bb helpers, reducing maintenance burden and duplication risk with no behavior loss. Side B is a small, localized UI tweak (moving a delete button) with modest CSS/markup changes that fixes a cosmetic layout issue but has narrower lasting impact on the codebase.

Commit A consolidates duplicated test harness, HTTP/OAuth mocks, registration helpers, cargo build, and server env into shared modules (common.bb/oauth.bb), shrinking auth/grants/integration and improving maintainability. Commit B only relocates the delete control into post_header_meta with flex CSS tweaks—presentational churn with little lasting design impact.

Side A consolidates duplicated test infrastructure into shared utilities by introducing reusable helpers in `test.common` and `test.oauth` (shared assertions, server environment creation, cargo build wrapper, OAuth registration flow, configurable mock Google server, and common HTTP behavior with timeouts), then updates multiple test suites to use them. This reduces duplication and centralizes maintenance across the integration tests, whereas Side B is primarily a UI layout refactor that moves the delete button into the metadata component and adjusts CSS flexbox styling without changing core functionality.

Side A replaces an ad-hoc rule-combinator URL engine with a structured semantic graph (DFA + generic fallback) that is architecturally more principled and directly affects production canonicalization logic used by the app, though it deletes test coverage without replacement. Side B is valuable but purely test-infrastructure deduplication (DRYing shared HTTP/oauth helpers across bb test files), which reduces duplication but has no runtime/user-facing impact and carries lower risk/lower lasting design value than a core domain model rewrite.

Side A replaces the production URL canonicalization stack (deleting the ad-hoc engine primitives and host-specific normalizers in favor of a graph/DFA-based API and updated registry/breadcrumbs), which is core lasting domain design. Side B only DRYs Babashka integration tests by moving assert/HTTP/OAuth helpers into common/oauth without changing product behavior.

Side A replaces the URL canonicalization architecture, removing the old rule-combinator engine in favor of a semantic graph/parser split and routing all public APIs (`canonicalize_raw`, breadcrumbs, parent lookup) through the new graph, which is a substantive design change affecting core behavior. Side B mainly consolidates duplicated integration-test utilities into shared helpers (`test.common`/`test.oauth`), adds HTTP timeouts, and refactors test code for reuse, improving maintainability but leaving production functionality largely unchanged.

Side A meaningfully deduplicates substantial copy-pasted HTTP/oauth/harness code across four test files into shared modules (test.common, test.oauth), reducing maintenance burden and improving correctness consistency (timeouts, multi-user mock). Side B is a small, well-justified dead-code removal with an updated test, which is valuable but narrower in scope and lasting impact than A's broad de-duplication.

A extracts duplicated HTTP clients, mock Google OAuth, assert/ANSI harness, cargo-build, and server-env helpers into test.common/test.oauth and rewires auth/grants/integration to use them, which is lasting test design. B only deletes a few lines of already-dead zero-ratio guard in apply_vote and adjusts one unit test—correct hygiene, but far smaller lasting impact.

Side A consolidates duplicated test infrastructure into shared utilities by introducing reusable helpers such as `run-cargo-build-release!`, `slug-server-env`, shared test assertions, configurable OAuth mock behavior, and `complete-registration!`, then updates multiple integration test suites to use them. This reduces maintenance burden and centralizes behavior across the test codebase, whereas Side B only removes a redundant zero-ratio guard in `apply_vote` and adjusts a single test to match the revised semantics.

Side A fixes a real production bug (a NameError crash in the GitHub OAuth callback) by defining the missing GITHUB_API_BASE_URL, directly improving correctness and reliability. Side B is a substantial but purely test-infrastructure refactor—deduplicating helper functions across test files—which improves maintainability but has no production impact and carries more risk of subtle regressions in test behavior.

A is a precise production bugfix that defines the missing GITHUB_API_BASE_URL (with default and rstrip) so the GitHub OAuth callback no longer raises NameError. B is a pure test-suite refactor that extracts duplicated helpers (assert/ANSI, HTTP clients, mock Google, cargo build, server env, registration) into common.bb/oauth.bb without changing product behavior or fixing runtime issues.

Side A fixes a runtime bug by defining `GITHUB_API_BASE_URL` with a default (`https://api.github.com`) and normalizing it via `rstrip("/")`, directly preventing a NameError during the GitHub OAuth callback when the environment variable is absent. Side B is largely a refactoring of test code, extracting shared helpers (`test.common`/`test.oauth`) and reducing duplication, which improves maintainability but does not materially change production behavior.

Side A is a clean, self-contained refactor that removes ~200 lines of duplicated HTTP/OAuth/test-harness boilerplate across four test files into shared `test.common`/`test.oauth` helpers, improving maintainability without touching production code. Side B improves the dev fixture script (cargo-watch, persistent data dir) but bundles in an unrelated and unexplained removal of room heading/breadcrumb markup in `server/src/html/forum.rs`, which looks like an accidental regression to production HTML mixed into a 'dev script' commit.

A consolidates duplicated HTTP/OAuth helpers, assert/ANSI harness, cargo-build, and server-env setup out of auth/grants/integration into shared common/oauth modules (including multi-user mock Google and complete-registration!), which is lasting test architecture across the suite. B improves one local fixture workflow (cargo-watch, persistent fixture-data/, preferred port 8080) plus a small room_page HTML trim—valuable DX, but narrower and less foundational than A’s dedup.

Side A extracts duplicated test infrastructure into shared utilities (`test.common` and `test.oauth`), introducing reusable helpers such as `run-cargo-build-release!`, `slug-server-env`, `complete-registration!`, shared assertions, configurable mock OAuth users, and consistent HTTP timeouts while updating multiple test suites to use them. Side B mainly improves the local development fixture workflow (cargo-watch, persistent fixture data, preferred port) and removes a small piece of room-page UI, which is useful but has a narrower, less foundational impact on the project's long-term maintainability.

Side A is a real, tested refactor that de-duplicates substantial shared test logic (HTTP helpers, mock OAuth, server env, harness counters) across auth.bb, grants.bb, integration.bb, and oauth.bb, reducing duplication and improving maintainability with no behavior change. Side B is almost entirely a speculative planning document (plan.md) plus a thin, unused-by-callers RouteContext wrapper stub that doesn't migrate any call sites, representing scaffolding/intent rather than delivered value.

A finishes a real maintainability win: it deletes large duplicated copies of HTTP/OAuth/assert/build helpers from auth.bb/grants.bb/integration.bb and centralizes them in test.common and test.oauth (including multi-user mock Google, complete-registration!, slug-server-env, cargo build helper). B mainly adds a forward-looking plan.md plus a thin RouteContext wrapper around ThreadNav with no call-site migration of ItemId yet, so most lasting substance is still unfinished scaffolding.

Side A performs a substantial refactor that consolidates duplicated test infrastructure into shared utilities (`test.common` and `test.oauth`), adds reusable helpers such as `run-cargo-build-release!`, `slug-server-env`, `complete-registration!`, and parameterized mock Google behavior, and updates multiple integration test suites to use them. Side B mainly adds a planning document and introduces a thin `RouteContext` wrapper re-export without migrating call sites, so it provides architectural intent but little immediate functional value.

Side B performs substantial, correct deduplication of duplicated HTTP/OAuth helpers and pass/fail harness code across four test files into test/common.bb and test/oauth.bb, reducing maintenance burden and bug-fix surface (e.g. consistent timeouts, unified mock-google logic). Side A is a small, useful config simplification (tests.edn glob) but is a single one-line-pattern change with lower overall impact and risk (e.g. auto-picking up unintended namespaces) compared to B's broader, well-executed refactor.

B removes large stretches of duplicated HTTP client, mock-Google OAuth, assert/ANSI harness, cargo-build, and server-env code from auth/grants/integration into shared test.common and test.oauth (including complete-registration! and parameterized start-mock-google), which is lasting test-infrastructure design. A’s single tests.edn auto-discovery suite is a clean, useful config fix so new namespaces run without edits, but it is a much smaller change in scope and depth than B’s consolidation.

Side B extracts substantial duplicated test infrastructure into shared utilities (`test.common` and `test.oauth`), adding reusable helpers such as `run-cargo-build-release!`, `slug-server-env`, `complete-registration!`, configurable mock Google OAuth, and centralized assertion/output logic while updating multiple test suites to use them. Side A improves Kaocha configuration by replacing manually enumerated test namespaces with a single auto-discovered suite, which reduces maintenance, but its impact is confined to test discovery rather than broadly improving the test architecture.

B makes an actual product/UX fix: it removes a redundant, duplicated toolbar+action path and unifies home page rendering with room pages, deleting dead code (ExpandNewThreadForm variant, dispatch handler, and its test), which is a real simplification of production behavior. A is pure test-infrastructure deduplication (moving shared HTTP/OAuth helpers into common/oauth modules) which is useful but lower-stakes churn with no behavioral change to the shipped product.

B permanently simplifies core product UI by SSR-ing #new-thread-ui-slot on home (matching rooms), deleting the ExpandNewThreadForm action/handler, toolbar morph, and its unit test—reducing real code surface. A only DRY-refactors duplicated test helpers (assert/pass-fail, HTTP clients, mock Google, server env) into common.bb/oauth.bb with no product behavior change.

Side A substantially refactors the test infrastructure by extracting duplicated HTTP/OAuth helpers, test assertions, server environment construction, and cargo build logic into shared modules (`test.common` and `test.oauth`), then updates multiple integration test suites to use them. It also adds reusable capabilities such as configurable mock Google users, registration helpers, and standardized HTTP timeouts, reducing duplication and making future test maintenance easier, whereas Side B mainly simplifies one UI flow by removing the `ExpandNewThreadForm` action and server-rendering the existing compose slot on the home page.

Side B fixes a real production bug — a tokio RwLock deadlock in room grant/create RPC handling caused by holding a read guard across nested read/write calls — and adds a regression test plus timeouts to prevent hangs, delivering concrete correctness value. Side A is a pure test-code refactor (deduplicating shared helpers into test.common/test.oauth) that improves maintainability but touches no production logic and provides no new functional guarantees.

B fixes a real production deadlock in `rpc.rs` by scoping `RwLock` read guards so they drop before nested `read`/`write` on RoomCreate/RoomGrant, plus a regression test and server log-pipe deadlock avoidance in `start-server`. A only deduplicates Babashka test helpers (assert/ANSI, cargo build, mock Google, registration flow) with no product correctness impact.

Side B fixes a substantive concurrency bug in the RPC handler by ensuring Tokio RwLock read guards are dropped before nested read/write operations, preventing deadlocks during RoomCreate and RoomGrant. It also adds a regression test for private room creation and improves test reliability with HTTP timeouts and optional server log redirection, whereas Side A is primarily a refactoring that centralizes shared test helpers and reduces duplication without materially changing project behavior.

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 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.

Side A meaningfully reduces duplication across four test files by extracting shared HTTP/mock-OAuth/assertion helpers into common.bb and oauth.bb, improving maintainability without changing behavior. Side B is a small, focused bugfix to sibling grouping logic with a new test, valuable but narrower in scope and impact compared to A's broader cross-file consolidation.

B changes real product behavior for sibling nav (each unranked item becomes its own group, matching component separation) and locks it in with a focused unit test, whereas A only deduplicates test helpers (assert/ANSI, cargo build, server env, mock OAuth) across bb suites without altering shipped design.

Side B changes application behavior by altering sibling navigation so each unranked sibling is rendered as its own navigation group instead of combining all unranked items into one group, and adds a focused regression test verifying the new grouping. Side A is primarily a refactor that consolidates duplicated test helpers into shared utilities and updates call sites, improving maintainability but leaving project functionality essentially unchanged.

Side B adds a real user-facing feature (connectivity/topology display) with new logic, formatting, and dedicated unit tests, providing tangible product value. Side A is a pure test-refactor consolidating duplicated helper code across bb test files, which improves maintainability but has zero functional or user-facing impact.

A removes large duplicated copies of HTTP helpers, mock Google OAuth, assert/ANSI harness, cargo build, and server env from auth/grants/integration into shared common.bb and oauth.bb (plus complete-registration! and unified timeouts), which is lasting test design that prevents drift. B only formats already-available ConnectivityStats into pair CLI output with two unit tests—useful UX, but thinner than the cross-suite consolidation.