c_f10e7b043e68066414

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 is a substantive code refactor of the URL canonicalization engine—removing the old combinator-based engine.rs and rewiring registry.rs to a new graph/parse-based architecture, with documentation updated to match—representing real, functional lasting change to core logic. Side B is purely documentation/plan-file alignment (removing @ syntax from prose docs) with no code changes, which is useful for coordination but has less durable engineering value than an actual module refactor.

Side A replaces the composable ParsedUrl/engine URL normalizer with a graph-based canonicalization API (registry rewrite, engine removal, hierarchy/breadcrumbs via graph), which is lasting core identity logic; Side B only aligns prose/docs (DSL.txt, GUIDE.sorter, plan.md) on wire identity without @—useful consistency but no runtime behavior.

Side A restructures the URL canonicalization implementation by replacing the old rule engine with a graph- and parser-based architecture (`graph`/`parse`), simplifying the public registry API to delegate canonicalization and breadcrumb logic, and updating module organization and tests. Side B only updates documentation to reflect identity and API conventions, improving clarity but not changing project behavior or implementation.

A is a small, clearly-explained config fix that removes real maintenance friction (new test files no longer need manual registration) and is low-risk and self-contained. B is a large refactor with a vague message ('url stuff'), deletes the old engine and its inline tests but the patch shown never introduces the new graph.rs/parse.rs modules it depends on, leaving the actual replacement logic unverifiable and the commit's completeness in doubt.

B replaces the hand-rolled URL combinator stack (engine.rs + per-host normalize_* in registry) with a semantic graph/DFA design that becomes the lasting ItemId canonicalization core, including hierarchy/breadcrumbs. A only shrinks tests.edn to one auto ns-pattern suite—useful maintenance hygiene, but far smaller and less foundational than the URL rewrite.

Side B replaces the URL canonicalization architecture by removing the old rule engine, introducing a graph- and parser-based implementation, updating the public registry API to use it, and reorganizing tests into a dedicated module. In contrast, Side A is a useful maintenance improvement that simplifies Kaocha configuration by auto-discovering all `test.*` namespaces, but it changes only test discovery behavior rather than core project functionality.

Side B is a substantial architectural rework of URL canonicalization, replacing a combinator-based engine with a semantic graph/DFA approach and adding new parse/graph modules with updated docs and tests, representing meaningful design evolution in core logic. Side A adds a useful but small CLI feature (connectivity stats display) with modest tests, which is real but narrower in scope and impact compared to B's structural refactor of a core subsystem.

B replaces the ad-hoc URL normalizer stack (engine primitives + per-host registry logic and tests) with a graph/DFA-based canonicalization architecture and public API thin layer—foundational ItemId behavior. A only formats and prints already-available ConnectivityStats in the CLI plus two unit tests, a useful but shallow presentation change.

Side A adds a user-facing feature by exposing existing connectivity statistics in the CLI, including a dedicated formatter that handles density, pluralization, and connection status, and backs it with focused unit tests. Side B is primarily a refactoring that swaps the URL canonicalization implementation over to new modules and removes the old engine from this patch, but without the new module implementations shown its lasting functional value cannot be verified from the diff.

A is a purely mechanical cleanup that removes a leftover duplicate forum.rs to fix module-resolution ambiguity — necessary but trivial housekeeping with no design change. B finalizes a real architectural shift in URL canonicalization, replacing the ad-hoc per-domain rule engine (engine.rs with hardcoded reddit/youtube functions) with a more general graph/DFA-based resolver (graph.rs/parse.rs) plus updated docs, which is a more substantive and lasting improvement to core logic even though some test consolidation obscures full visibility of the new implementation.

B replaces the old composable ParsedUrl/engine normalizers and domain_key match arms with a graph-based canonicalization API (registry thin wrapper over graph/parse, docs and tests re-homed), which is lasting core ItemId design. A mostly deletes the leftover monolithic forum.rs and redistributes the same forum HTML into forum/* modules plus a small timeago import fix—necessary structure cleanup, but little new behavior or design.

Side A resolves a real module-structure issue by removing the duplicate `server/src/html/forum.rs`, adding `forum/mod.rs`, and making `forum/` the single module root while preserving behavior through extracted modules like `feed.rs`, `views.rs`, and `thread_morph.rs`. Side B replaces the URL canonicalization engine with a new graph-based architecture and updates the registry API, but the visible patch largely swaps implementations and removes in-file tests without showing the new core logic, making its lasting functional impact less directly evident from the diff.

Side A completes a meaningful architectural migration of URL canonicalization from ad-hoc per-domain functions to a more principled graph/DFA-based design, deleting ~190 lines of bespoke engine code and updating the public registry API and docs accordingly, which is more consequential for future maintainability. Side B is a valid but very small dead-code removal (a redundant zero-ratio guard) with a matching test update, useful but narrow in scope compared to A's structural rework.

A replaces the ad-hoc ParsedUrl combinator engine with a semantic graph-based URL canonicalization design (new graph/parse modules, slimmed registry API, updated docs)—a lasting architectural change to core ItemId identity. B only deletes a dead zero-ratio early-return and adjusts one test comment/assertion; useful hygiene but negligible lasting design impact.

Side A replaces the URL canonicalization architecture from ad hoc normalization functions in `engine.rs` with a graph-based API (`graph`/`parse`) and updates the public registry to delegate canonicalization and breadcrumb generation through that abstraction, along with documentation and test module reorganization. Side B only removes a redundant zero-ratio guard in `apply_vote` and adjusts the corresponding test expectations, which is a small cleanup with limited long-term impact.

Side A fixes concrete, verifiable bugs (regex split arg, wrong stream for reading POST body, wrong sendResponseHeaders length, missing null-check on token/state, added error handling) that directly restore broken E2E auth tests, with a clear commit message explaining the fix. Side B is a vague 'url stuff' commit that deletes a working engine.rs and its test suite while referencing new graph.rs/parse.rs modules that aren't shown in the diff, leaving the actual replacement logic and whether functionality/tests were preserved unverifiable from the patch itself.

B replaces the ad-hoc ParsedUrl combinator stack (engine.rs + per-host normalize_* in registry) with a lasting semantic-graph design for ItemId canonicalization and breadcrumbs—core production identity logic—while A only repairs test doubles (regex split on '=', getRequestBody, 302 length, nil token/state) and Playwright helpers so E2E auth runs again. Test mock fixes are real and necessary, but they do not outlast B’s redesign of the URL rules subsystem.

Side A fixes concrete regressions in the OAuth test infrastructure by correcting query parsing (`str/split` regex), reading POST bodies from `getRequestBody`, handling null tokens/state safely, fixing redirect responses, wrapping handlers to avoid crashes, and updating Playwright test interactions to use real selectors. Side B mostly restructures the URL canonicalization module by replacing the old engine with new graph/parse modules and updating documentation, but the patch shown primarily removes code and redirects APIs without demonstrating the substantive replacement implementation.

Side A shows a genuine architectural improvement: it removes the ad-hoc, hardcoded per-domain combinator engine (engine.rs, with special-cased reddit/youtube logic) in favor of a documented generic graph/DFA approach with a fallback for unknown sites, generalizing URL canonicalization beyond two hardcoded domains. Side B bundles plumbing (new deps, typed form holes, a vote CTA link, CSS/JS for a slider) but its core new logic (vote.rs, pair.rs) isn't visible in the diff, making it hard to verify the actual 'fix' beyond UI wiring and dependency additions.

A replaces the ad-hoc ParsedUrl combinator engine and per-host normalize paths with a graph-based canonicalization API (registry rewired to graph/parse, docs and module layout updated)—core lasting design for ItemId identity. B adds real vote UX wiring (typed $form:i32 holes, next redirect, route/CSS/JS), but it is mostly product-surface and dependency churn versus A’s deeper domain redesign.

Side B introduces concrete functionality: typed form substitution for `{"$form:i32": ...}` with tests, support for a `next` redirect after recording votes, routing and UI plumbing for a voting flow, and corresponding client-side behavior. Side A mainly replaces the URL canonicalization implementation with references to new `graph`/`parse` modules while deleting the old engine from the shown patch, making it primarily a structural refactor in the visible changes rather than a clearly demonstrated functional improvement.

Side A is a coherent, working refactor that replaces a combinator-based URL engine with a cleaner graph-based canonicalization approach, updates docs, and preserves test coverage via registry_tests. Side B's 'init seed' dump adds huge files (forms.rs, ranking.rs) that literally contain leftover shell prompts and 'cat' commands baked into the file content, meaning those files as committed are broken/non-compiling, making it low-quality, unreviewed noise despite its size.

A delivers a focused architectural refactor of URL canonicalization (deleting the ad-hoc engine primitives in favor of a semantic DFA/graph design, with registry updates and docs), which is lasting core design. B is a noisy bulk seed dump of prototypes, notes, and large files (parser/reducer/ranking/vote) polluted by terminal paste artifacts and non-code .tdsl ideation, so most of its volume does not land as clean lasting value.

Side A replaces the URL canonicalization implementation with a new graph-based architecture by removing the old `engine` layer, routing the public API through `graph`/`parse`, and simplifying `registry.rs` to use semantic graph resolution and shared breadcrumb logic. Side B adds a very large mix of prototype code, notes, and even terminal-capture artifacts (for example `forms.rs` and `ranking.rs` include shell prompts), making it a broad initial dump rather than a focused, maintainable project improvement.

Side A is a focused, well-documented fix that removes duplicate UI logic (ExpandNewThreadForm) and unifies the home page's compose slot with the room page pattern, including removal of the now-obsolete test — a clear, verifiable improvement in code clarity and correctness. Side B's diff deletes the old URL engine and tests but references new modules (graph.rs, parse.rs, registry_tests.rs) that are not shown in the patch, making the actual substance of the replacement unverifiable and the vague commit message ('url stuff') further undermines confidence in its completeness and intent.

B replaces the ad-hoc ParsedUrl combinators and per-host normalize paths with a lasting graph/DFA-based canonicalization design (and thins registry to that API), which underpins ItemId identity project-wide. A is a correct, focused UX cleanup (SSR #new-thread-ui-slot on home and delete ExpandNewThreadForm + toolbar), but it only simplifies one compose flow rather than core URL architecture.

Side B replaces the URL canonicalization implementation with a new graph- and parser-based architecture, rewires the public registry API to use it, and reorganizes the module structure, representing a foundational redesign of a core subsystem. Side A is a targeted UI simplification that removes the `ExpandNewThreadForm` action and server-renders the collapsed compose/login hint on the home page, which reduces duplication but has a narrower, feature-specific impact.

Commit B replaces an ad-hoc rule-combinator engine with a more principled semantic graph/DFA architecture for URL canonicalization, a substantive design change with lasting structural impact (even though the diff removes tests, it references new modules graph.rs/parse.rs/registry_tests.rs implying continued coverage). Commit A is a smaller correctness/clarity fix (converting a silent fallback to an explicit panic with better invariants and doc clarifications, plus added test assertions), which is valuable but narrower in scope than B's architectural overhaul.

B replaces ad-hoc URL combinators (engine.rs + per-host normalize paths) with a graph/DFA-based canonicalization API wired through registry, which is core identity infrastructure lasting across the product. A is a correct but narrow fix: rank-history thread_post_index becomes strictly 0-based with expect() and tests, removing optional 1-based/unwrap_or(0) mismatch—valuable polish, not system-level design.

Side A fixes the thread post index semantics by making rank history consistently use the 0-based URL index, replacing silent `unwrap_or(0)` fallbacks with `expect(...)` to catch broken invariants, updating documentation, removing conditional rendering, and adding integration tests that verify the behavior. Side B is primarily a large refactor of the URL canonicalization subsystem (moving logic into new graph/parse modules and deleting the old engine) but the shown patch mostly rewires interfaces and removes in-file tests without exposing the new implementation, making its lasting functional value less evident from the diff.

Commit A fixes a real correctness/performance issue (unbounded Deque growth, extra write-amplifying trim step) by switching to an append-only List with query-time capping, and adds a test verifying the cap behavior. Commit B is a large architectural rewrite (deleting engine.rs, introducing graph/parse modules) but the diff shown deletes the old implementation and tests without showing the new graph/parse modules' content, making it impossible to verify the new design's correctness or completeness from this patch alone.

B replaces the ad-hoc composable normalizer pipeline (engine.rs + host switch) with a graph/DFA-based URL identity and hierarchy model, which is core lasting design for ItemId canonicalization across the project. A is a real but narrower storage/reducer change (Deque→List, trim-on-write→cap-on-read, schema 4 + test) on recent_votes only, so less project-wide leverage than B’s identity-layer rewrite.

Side A makes a substantive storage-model change by replacing the durable deque with an append-only list, removing post-commit trimming, updating schema versioning, and capping recent votes at load time with a regression test verifying only the newest 200 entries are returned. Side B is largely a refactor of the URL canonicalization module structure (moving from an engine to graph/parse modules and updating registry calls) plus documentation changes; while it may improve organization, the shown patch primarily rewires interfaces rather than demonstrating a clear new behavioral improvement.

Side A replaces an ad-hoc, per-domain if/else URL normalizer with a cleaner, more principled graph-based parser (DFA + generic fallback), improving the actual product's core canonicalization logic while preserving test coverage intent. Side B is mostly internal admin/debug page cleanup (removing legacy projection code paths and adjusting tests/docs), which is useful maintenance but lower-impact and more narrowly scoped to internal tooling.

Side A replaces ad-hoc URL combinators (engine.rs ParsedUrl pipeline and per-domain normalize_* functions) with a graph/DFA-based canonicalization API wired through registry (graph(), resolve_canonical, breadcrumbs), which is lasting core domain design. Side B is valuable cleanup—dropping _legacy_commit_row/_legacy_observation and GitDiscovery projections so epoch/commit pages use Evidence only—but it mainly removes compatibility paths and tightens Emission fields rather than adding new capability.

Side B makes a substantive architectural cleanup by removing legacy GitDiscovery projection paths, requiring evidence metadata in `Emission`, simplifying epoch/commit endpoints to use Evidence envelopes only, and updating tests to enforce the new model. Side A is primarily a refactor that replaces the old URL engine with new graph/parse modules and updates documentation and tests, but the patch shown mostly removes the previous implementation while delegating behavior elsewhere, making its lasting functional impact less directly evident.

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

B delivers concrete, verifiable improvements: it fixes scan to avoid a full reducer replay (real perf win), surfaces actual DSL parse error text instead of a vague reason, adds a genuinely new capable feature (compile --ingest for single-event replay), and ships a matching test plus README docs. A's diff mostly deletes the old engine.rs and rewires registry.rs to a 'graph' module that isn't shown in this patch (graph.rs/parse.rs), so its net effect and correctness can't be fully assessed from what's presented, and it drops the existing test suite without showing replacements inline.

A replaces ad-hoc URL normalize helpers (engine.rs) with a semantic graph/DFA-based canonicalization path and thins registry to that model—core ItemId identity design that the rest of the system depends on. B is strong, complete tooling (fast parse-only scan, richer parse_error surfaces, compile --ingest) but remains peripheral offline/CLI DX versus lasting domain structure.

Side B adds substantive functionality and usability: it redesigns log scanning into a fast parse-only pass, exposes detailed DSL parse errors, introduces `compile --ingest` to replay state up to a specific event, extends CLI options, and adds tests and documentation for these behaviors. Side A is primarily a refactor that removes the old URL engine and redirects the registry to new `graph`/`parse` modules, but the actual implementation of those new modules is absent from the patch, so the visible lasting value is limited compared with B's concrete feature and tooling improvements.

B is a small, targeted bugfix that defines the missing GITHUB_API_BASE_URL to prevent a NameError in the OAuth callback, a real correctness fix. A is a large refactor replacing a working rule-based URL engine with a new graph/DFA architecture but deletes all existing tests without adding new coverage in the diff, making its correctness and lasting value harder to verify despite its scope.

Side A replaces the ad-hoc ParsedUrl combinator engine with a graph/DFA-based canonicalization API (registry rewrite, module split, docs), which is lasting core design for ItemId identity. Side B only adds a missing GITHUB_API_BASE_URL default—a real but tiny localized crash fix with far less system impact.

Side B fixes a concrete runtime bug by defining `GITHUB_API_BASE_URL` with a sensible default, preventing a `NameError` in the GitHub OAuth callback when the environment variable is absent. Side A largely replaces the URL normalization architecture by deleting `engine.rs` and redirecting `registry.rs` to new `graph`/`parse` modules, but the substantive implementation is not present in the shown patch, making the demonstrated lasting value less certain than the explicit bug fix.

Side A performs a substantive architectural refactor of URL canonicalization, replacing an ad-hoc per-domain function engine with a more general DFA/graph-based approach, while preserving/adapting existing tests to validate correctness. Side B is a small, focused UI bugfix (splitting unranked siblings into separate groups) with a single new test, which is real but much smaller in scope and lasting impact.

A replaces the ad-hoc ParsedUrl combinator stack (engine.rs + host-specific normalize_* paths) with a graph/DFA-based canonicalization API, which is a lasting redesign of core ItemId URL identity. B only changes sibling nav grouping so each unranked item is its own group, plus one regression test—useful but localized UI behavior versus foundational URL rules.

Side A replaces the previous ad hoc URL normalization pipeline with a new graph-based canonicalization API (`graph`/`parse`), rewires `canonicalize_raw`, breadcrumbs, and parent resolution to use it, and updates the module structure and documentation to reflect the new semantic model. Side B is a focused UI behavior fix that changes sibling navigation so each unranked sibling becomes its own group and adds a regression test, but its impact is limited compared with the architectural replacement in the URL handling code.