c_ca72f0995396151294

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

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

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

Side A is a self-contained, verifiable improvement: it consolidates multiple copy buttons into one panel, adds a real safety invariant (assert_cli_panel_cmd_js_single_quote_safe) preventing broken/unsafe inline JS, and consistently updates all call sites plus both theme CSS files. Side B deletes a working combinator-based engine.rs and its test suite but references new `graph`/`parse` modules that aren't shown being created in this diff, making the change impossible to verify for correctness or completeness, and the terse 'url stuff' message signals low care despite touching core canonicalization logic.

B replaces ad-hoc per-domain combinators (engine.rs + large registry normalize path) with a graph/DFA-based URL canonicalization and hierarchy model, which is core ItemId identity infrastructure. A is a solid but peripheral UX polish: multi-command cli_panel grouping, click-to-copy rows, CSS, and JS string safety asserts—real value, but not foundational like B’s redesign.

Side A makes a concrete, user-visible improvement by redesigning `cli_panel` to support grouped commands, click-to-copy rows, and adding assertions that prevent unsafe characters from being embedded in the generated single-quoted JavaScript, while updating all call sites and CSS accordingly. Side B mostly reorganizes the URL canonicalization subsystem by replacing the old engine with new modules and updating registry calls, but the shown patch is largely a refactor/deletion without enough visible new behavior to outweigh A's clear functional and defensive improvements.

Side A ships a working, self-contained feature (grouped cli_panel UI with hover-to-copy, JS-injection safety assert, CSS updates) that compiles and improves real user-facing behavior across multiple call sites. Side B is almost entirely a large planning markdown document plus an unused/unwired RouteContext scaffold that duplicates ThreadNav without migrating any call sites, providing no concrete functional or architectural change yet.

A ships a complete, used feature: cli_panel becomes multi-command with row click-to-copy, JS single-quote safety asserts, call-site updates, and theme CSS—real UX and correctness in production paths. B mostly adds an ephemeral plan.md plus a thin RouteContext wrapper over ThreadNav with no call-site migration or ItemId work, so little lasting behavior landed.

Side A delivers a functional improvement by redesigning `cli_panel` to support multiple commands in one component, adding click-to-copy rows, updating all call sites, and introducing runtime assertions that prevent unsafe characters from breaking the inline single-quoted JavaScript. Side B primarily adds a planning document and a new `RouteContext` wrapper module that is re-exported but not yet integrated into behavior, so its immediate lasting impact on the project is much smaller.

Side A implements substantive functional changes: a full-bleed chromeless layout for the vote-compare view, correct ratio-oriented sorting of edge history votes with tests, and morphing of the new post preview card via richer server-side context (ingest, thread_tag, post_index), all backed by new unit tests and a browser test update. Side B is a moderate UI refactor (grouping cli_panel calls into a single bordered panel with click-to-copy and a JS-safety assertion) that is useful but narrower in scope and lower-risk/lower-impact than A's feature and correctness work.

A delivers substantive vote-compare product work: fullscreen chromeless layout, left/right-aligned ratio history with strength sorting, post-success card morph, tests, and multi-theme CSS. B is a solid but narrower cli_panel UX refactor (grouped rows, click-to-copy, JS-safety asserts) with mostly call-site and styling updates.

Side A delivers substantive functionality: it adds a dedicated fullscreen layout for the vote-compare page, updates the post-success flow to morph in the newly created vote preview, normalizes and sorts vote history by the displayed left/right ordering, and adds regression tests covering the new behavior. Side B is primarily a UI refactor of the CLI panel (grouping multiple commands, click-to-copy rows, and assertions for JS-safe strings) with corresponding CSS and call-site updates, which improves usability but has a narrower, less foundational impact.

Side A fixes real bugs that were breaking E2E auth tests (wrong str/split arg types, incorrect InputStream/RequestBody API usage, nil state handling, missing error handling causing crashes), restoring test suite functionality. Side B is a UI refactor consolidating multiple cli_panel calls into one, which is a reasonable improvement but is feature polish rather than a correctness fix, and introduces a slightly awkward assert-based safety check instead of proper escaping.

A restores broken E2E auth by fixing real mock failures (str/split on "=" vs #"=", slurp of getRequestBody vs getInputStream, 302 body length, nil-safe token/state, handler try/catch) plus selector/async test reads. B only regroups the cosmetic cli_panel UI (multi-cmd, row click-to-copy, CSS, JS-quote asserts)—nice polish, not unblocking core test/infra correctness.

Side A fixes concrete failures in the OAuth end-to-end test infrastructure by correcting query parsing (`str/split` with regex), reading POST bodies from `getRequestBody`, handling null tokens/states safely, adjusting redirects, wrapping mock handlers with error handling, and improving Playwright DOM polling so authentication flows work again. Side B is primarily a UI enhancement that refactors `cli_panel` to support grouped clickable commands with styling and adds assertions for JS-safe command strings, which is useful but less foundational than restoring broken authentication tests.

B fixes a real correctness issue (the old copy-button used naive quote-escaping that could break embedded JS on backslashes) by replacing it with an explicit safety assertion, and consolidates multiple CLI panels into one clearer, hover-to-copy component across several pages and both themes. A is a smaller, well-tested but narrower feature that just wires an existing ConnectivityStats struct into CLI output.

A surfaces existing connectivity stats (density, components, comparisons-to-connect) in the pair CLI with tests, giving voters lasting decision-critical graph topology. B is solid UI polish (grouped multi-cmd panel, click-to-copy, JS-safety asserts) but mainly presentation refactor across HTML/CSS call sites rather than new core product information.

Side A adds new user-visible functionality by surfacing graph connectivity statistics (density, connected components, and comparisons needed to connect the graph) in CLI pair output, along with focused tests that verify the formatting for connected and disconnected cases. Side B improves the HTML CLI panel by grouping multiple commands, making rows clickable to copy, and adding assertions to prevent unsafe JS string embedding, but it is primarily a UI/refactoring enhancement rather than exposing new project state or behavior.

Commit A fixes a real correctness bug: the previous code silently mapped a missing post lookup to index 0 (which is also a valid index for the first post), making the UI guard `if index > 0` meaningless and the link route (0-based) inconsistent with the displayed 1-based index; A aligns the indexing with the actual /t/tag/N route, replaces the silent fallback with an explicit invariant check, and adds tests asserting correct indices. Commit B is a reasonable UI refactor (grouping CLI hints, hover-to-copy, JS-safety assert) but is mostly cosmetic/feature polish without fixing an underlying correctness issue.

A fixes real contract/indexing bugs: rank-history thread_post_index becomes required 0-based (matching /t/tag/N), drops unwrap_or(0) masking and 1-based off-by-one link logic, and locks that in with type docs plus integration asserts. B is worthwhile CLI UX (grouped panels, row click-to-copy, JS quote asserts, CSS), but it is largely presentation polish versus A’s lasting correctness and API consistency.

Side A fixes the semantics of `thread_post_index` by making rank history consistently use the existing 0-based URL index, replacing silent `unwrap_or(0)` fallbacks with `expect(...)` to enforce the invariant, updating documentation, removing incorrect conditional rendering, and adding integration tests that verify the behavior. Side B is primarily a UI enhancement that refactors the CLI panel to support multiple commands with click-to-copy and adds assertions for JS-safe strings, which is useful but less fundamental than correcting and validating core data behavior.

Side A improves a real UI feature (consolidated cli_panel with hover-copy) and adds a genuine safety assertion against JS-injection via unescaped single quotes, while updating call sites and two theme CSS files consistently. Side B is a small, plausible dead-code cleanup in the reducer with a test update, but it's a minor, low-impact correctness tweak rather than a substantive feature or bugfix. Both are reasonable, but A delivers more lasting functional and UX value.

A redesigns cli_panel into a multi-command grouped UI with click-to-copy rows, JS single-quote safety asserts, call-site updates, and theme CSS—lasting UX and correctness across pages. B only deletes a redundant zero-ratio early-return already enforced upstream and adjusts one test, a correct but tiny dead-code cleanup.

Side A redesigns the shared `cli_panel` component to support multiple commands in a single panel, adds click-to-copy rows, updates all call sites to the new API, and introduces assertions preventing unsafe characters from being embedded in single-quoted JavaScript literals. Side B mainly removes a now-redundant zero-ratio early return and adjusts a test to reflect existing behavior, which is a smaller cleanup with narrower long-term impact.

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.

Commit A removes a genuinely redundant code path (ExpandNewThreadForm action, its dispatch handler, and test) and unifies public-home rendering with the same SSR pattern used elsewhere, reducing action surface and eliminating a duplicated UI flow — a real simplification with lasting design value. Commit B is a solid UX/CSS refactor of cli_panel (grouping commands, hover-copy, JS-safety assert) but is more of a polish/consistency change across call sites without removing any structural redundancy or fixing a design flaw.

A removes an entire UI action (ExpandNewThreadForm), its handler, tests, and a redundant home toolbar in favor of SSR’ing #new-thread-ui-slot like room pages—real consistency and less surface area. B improves cli_panel (multi-command grouping, click-to-copy rows, JS safety asserts) but is peripheral UX polish rather than a lasting structural fix.

Side A removes the dedicated `ExpandNewThreadForm` HTML UI action and its server dispatch/tests, instead rendering the collapsed compose or login hint directly in the SSR `#new-thread-ui-slot` on the home page. This eliminates duplicated flow and unnecessary client/server interaction, simplifying the architecture. Side B improves the CLI panel by supporting grouped commands, click-to-copy rows, and adding assertions for JS-safe embedded strings, but these are primarily UX and component enhancements rather than removing a redundant subsystem.

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 B fixes a real logic bug (unranked siblings were incorrectly lumped into one group instead of separated), and backs it with a new regression test verifying the corrected grouping behavior. Side A is a UI/CSS refactor (merging multiple copy buttons into one panel) with a defensive assert, which is useful but more cosmetic and lower-stakes than correcting sibling-grouping semantics.

A redesigns cli_panel into a multi-command grouped control with click-to-copy rows, JS single-quote safety asserts, call-site updates, and theme CSS—concrete lasting UX and hardening used across pages. B only splits unranked siblings into one-group-each (plus a unit test), a narrow nav semantic tweak with less project-wide impact.

Side A refactors the shared `cli_panel` into a reusable multi-command component, updates all call sites, adds click-to-copy rows, and introduces assertions preventing unsafe characters from being embedded in single-quoted JavaScript, improving both functionality and robustness. Side B makes a focused behavioral fix by splitting each unranked sibling into its own navigation group and adds a regression test, but its impact is narrower than the cross-cutting UI/API improvement in Side A.

Side B fixes a real performance bug (scan no longer does full replay with rank centrality on every ingest), surfaces actual parse error details instead of a vague reason, and adds a genuinely useful new capability (compile --ingest for targeted replay debugging), backed by a new test. Side A is a UI refactor (grouping multiple cli_panel calls into one bordered panel) that's reasonable but purely cosmetic/organizational with no functional bugfix or capability gain of comparable weight.

B fixes a real performance bottleneck (scan no longer full-replays every ingest through rank centrality), adds compile --ingest for targeted log replay, surfaces full DSL parse errors, and ships tests plus docs—lasting tooling value. A is solid UI polish (grouped click-to-copy CLI rows and JS-safety asserts) but is mostly presentation and call-site churn without comparable core capability.

Side B adds substantial offline tooling improvements: it refactors log replay, makes `scan` a fast parse-only pass, surfaces detailed `parse_error` information, and introduces `compile --ingest` to replay prior state and compile a single event from a log, with corresponding CLI, API, and test updates. Side A mainly improves the HTML CLI panel UX by grouping commands, enabling click-to-copy, and adding assertions that command strings are safe for embedding in single-quoted JavaScript, which is useful but has a narrower, presentation-focused impact.

A is a pure mechanical fix removing an accidental duplicate file with no behavioral change beyond deduplication, useful but trivial housekeeping. B delivers an actual UX/feature improvement (grouped cli_panel API change across call sites, CSS updates, and a real safety assertion guarding against JS-injection via unescaped single quotes), representing more genuine design and correctness work.

B changes real product behavior: multi-command grouped CLI panels, click-to-copy rows, safety asserts for JS string embedding, and matching CSS across themes. A mostly deletes the leftover monolithic forum.rs and wires that same code into forum/ modules—valuable structure cleanup and ambiguity fix, but largely relocating existing logic rather than adding lasting capability.

Side A removes the duplicate monolithic `server/src/html/forum.rs`, introduces `forum/mod.rs`, and makes the split `forum/*` modules the single module root, eliminating ambiguous module resolution and reducing long-term maintenance risk without changing behavior. Side B improves the CLI panel by supporting grouped commands, click-to-copy rows, and adding assertions to prevent unsafe single-quoted JS embedding, but this is primarily a UI enhancement rather than a foundational structural fix.

Side B fixes a real deadlock bug (nested RwLock read guards held across await points causing self-deadlock in RoomCreate/RoomGrant), adds a regression test for room creation, and hardens test infra with HTTP timeouts and safer log redirection to avoid pipe-buffer deadlocks. Side A is a UI refactor (grouping cli_panel rows, hover-to-copy) with real but lower-stakes value, and includes a safety assert but no functional bugfix of comparable impact.

B fixes a real tokio RwLock reentrancy deadlock in RoomCreate/RoomGrant by dropping the read guard before nested lock acquires, and backs it with an integration test plus test-harness changes (log redirection, HTTP timeouts) that prevent related hangs. A only refactors the CLI hint UI into a multi-command hover-to-copy panel with CSS and assert guards—useful polish, but not a lasting correctness fix like B.

Side B fixes a substantive concurrency bug by ensuring `tokio::sync::RwLock` read guards are dropped before later `read().await`/`write().await` calls in RPC handlers, preventing deadlocks, and adds an integration test covering private room creation. Side A mainly refactors the HTML CLI panel into a grouped, click-to-copy UI with CSS updates and adds assertions that CLI strings are safe for single-quoted JavaScript, which improves usability but has less lasting impact than the correctness fix.

Side B refactors cli_panel into a single reusable multi-row component with hover/copy UX, adds a defensive assertion preventing broken JS from unescaped quotes, and updates CSS consistently across two themes — a genuine, multi-file feature/bugfix improvement. Side A is a useful but very small config simplification (tests.edn) that reduces duplication but has minimal code surface and no behavioral guarantees beyond auto-discovery.

B redesigns a shared UI primitive (cli_panel) to accept grouped commands, makes each row click-to-copy, and adds JS single-quote safety asserts, with coordinated call-site and theme updates—lasting product behavior. A only collapses hand-enumerated kaocha ns lists into one ^test\\..+ suite in tests.edn; useful auto-discovery hygiene, but a small config change without comparable runtime or UX impact.

Side A replaces manually enumerated Kaocha test suites with a single auto-discovered `^test\..+` suite, eliminating ongoing maintenance and ensuring new test namespaces run automatically without editing `tests.edn`. Side B improves the CLI panel UI by grouping commands, adding click-to-copy rows, and asserting JavaScript-safe command strings, but those are primarily usability and presentation enhancements rather than a project-wide maintenance improvement.

Side A is a minimal, precise fix that defines the missing GITHUB_API_BASE_URL to resolve an actual runtime NameError crash in OAuth callback, delivering clear correctness value. Side B is a larger UI refactor (grouped CLI panel with hover-to-copy) that is reasonable but purely cosmetic/feature polish with more surface area for regressions and no critical bug being fixed.

A is a precise production bugfix: it defines the missing GITHUB_API_BASE_URL so OAuth callback code no longer raises NameError. B is a larger but non-critical UX refactor (multi-cmd cli_panel, click-to-copy, CSS, call-site churn) that improves polish without fixing broken behavior.

Side B refactors the CLI panel to support multiple commands in a single component, updates all call sites, adds hover-to-copy behavior, and introduces assertions preventing JavaScript-breaking characters from being embedded in the generated onclick handler, improving both usability and robustness. Side A is a valuable but narrowly scoped bug fix that defines `GITHUB_API_BASE_URL` with a default value to prevent a `NameError` when the OAuth callback references it.

A delivers a focused, working feature improvement (grouped CLI panel, hover-to-copy, JS-injection safety assert) with corresponding CSS updates in both themes, and is self-contained. B's dev-script improvement (cargo-watch, persistent fixture dir) has real value for local dev, but it bundles in an unrelated and unexplained removal of room header markup (title, room id, garden link) in forum.rs, which looks like an accidental regression riding along with an otherwise tooling-only commit.

A lands a lasting user-facing design: multi-command cli_panel with row click-to-copy, JS single-quote safety asserts, and dual-theme CSS, consolidating three separate panels on room pages. B improves local DX (cargo-watch, persistent fixture-data, preferred port) plus a small room_page markup trim, valuable for iteration but not shipped product surface.

Side B substantially improves the developer workflow by replacing the release-build fixture with a persistent `cargo watch`-based environment, adding preferred-port selection, reusable seeded data (`fixture-data/`), summary rebasing, and longer health waits, making iterative development faster and more reliable. Side A improves the CLI panel UI by grouping commands, enabling click-to-copy rows, and adding assertions to prevent unsafe JavaScript embedding, but those changes are primarily presentation and defensive checks rather than a broader workflow improvement.

Side A delivers a coherent, self-contained UX/code improvement (grouped CLI panel, single border, hover-to-copy) plus a genuine correctness fix (JS-safe-quote assertion preventing broken onclick handlers), all with a clean diff. Side B is a large mechanical refactor (splitting forum.rs into files) that mostly moves code verbatim, reintroduces some duplicated inline JSON templating instead of reusing helper functions (arguably a slight regression), and bundles an unrelated sampling script, making its net lasting value less clear-cut despite its size.

A ships a real product improvement: multi-command CLI panels with row click-to-copy, shared border/layout, theme CSS, and hard asserts that commands stay single-quote JS-safe—changing behavior call sites (e.g. room page three panels → one). B is mostly a forum.rs file split (nav/ingest/access/etc.) plus thin RPC inlining and an unrelated macOS sample-fixture script, so it is maintainability churn rather than lasting feature or bugfix value.

Side A delivers a functional UI improvement by redesigning `cli_panel` to support multiple commands in one panel, making each command directly clickable-to-copy, and adding assertions that prevent unsafe characters from being embedded in single-quoted JavaScript literals. Side B is largely a structural refactor that splits forum code into new files and inlines some helper calls, with an added macOS profiling script, but the shown changes introduce little new project behavior compared with A's concrete usability and safety improvements.

Side A refactors cli_panel into a single grouped, hover-to-copy UI with an explicit safety assertion against JS-breaking characters, fixing a real bug (unescaped single quotes breaking onclick) and improving UX/CSS across themes and call sites. Side B adds a single randomized unit test for existing ranking logic, which is useful but narrower in scope and doesn't change or fix any production behavior.

A redesigns production cli_panel to accept multiple cmds in one bordered panel, makes each row click-to-copy (dropping a separate copy control), and adds JS single-quote safety asserts, with call-site and theme CSS updates across forum/garden/search. B only adds one property test for rank centrality on a 25-edge spanning tree and does not change ranking behavior or other production code.

Side A redesigns the reusable `cli_panel` to support multiple commands in a single panel, simplifies several call sites, adds click-to-copy rows, and introduces explicit assertions preventing unsafe characters from being embedded into single-quoted JavaScript, improving both functionality and robustness. Side B adds a useful regression test for the ranking algorithm, but it does not change production behavior or fix a bug by itself.