c_77729db919ab61d62f

Commit B introduces a substantial architectural change around URL canonicalization. It adds a new URL normalization subsystem (`url_rules`), integrates it into `ItemId`, updates parsing, parent/breadcrumb logic, Reddit URL handling, projection application, state validation, and adds a new dependency plus extensive test updates. It also changes the project's canonical identifier format to full HTTPS URLs and touches many core components. By contrast, commit A is a tiny HTML tweak that changes a disabled paginator control from a `<span>` to an anchor with `href="#"`, a localized UI adjustment with minimal impact.

Commit B introduces a comprehensive URL canonicalization system with new modules, dependency additions, and widespread changes across parsing, storage, tests, and Reddit integration logic. It fundamentally alters how IDs are handled and normalized throughout the codebase. Commit A is a minor HTML tweak changing a disabled span to a link, with negligible impact in comparison.

Commit B introduces a comprehensive URL canonicalization system (new url_rules module with engine and registry), adds a new dependency, refactors ItemId semantics across the codebase to use full canonical URLs, updates parsing, parent/breadcrumb logic, Reddit/YouTube normalization, event application, and adjusts extensive tests and state handling accordingly. It meaningfully changes core identity handling and architecture. Commit A is a trivial HTML change (span to disabled anchor). Therefore B contributes vastly more.

Commit A makes a broad architectural change to URL identity handling across the project. It introduces a dedicated URL canonicalization framework (`url_rules`), adds composable normalization rules, switches canonical IDs to full HTTPS URLs, updates parsing, parent/breadcrumb logic, projection application, Reddit mapping, state handling, and touches a large number of tests to migrate storage and behavior. This is a foundational change that affects core data identity and persistence semantics throughout the codebase. Commit B is also substantial: it fixes the external garden index, refactors the GitHub resolver into a new `resolvers` module, adds structured GitHub import cards with rendering support, updates UI and CSS, and includes integration tests. However, its impact is more feature-focused and localized compared with the repository-wide identity and canonicalization overhaul in A.

Commit A is a deep, cross-cutting architectural change introducing a full URL canonicalization system (url_rules engine, registry, and integration into ItemId) and migrating the entire codebase to canonical URL identities. It modifies core data modeling, parsing, storage, and many call sites, making it foundational. Commit B is also substantial—adding a resolver framework, GitHub import cards, UI rendering, and fixing the external index—but it is more feature-oriented and layered on top of existing structures. A has broader systemic impact, while B is a large but more modular feature addition.

Side A introduces a comprehensive URL canonicalization system with a new url_rules module, restructures ItemId semantics around full canonical URLs, updates parsing, parent/breadcrumb logic, Reddit/YouTube normalization, and propagates these changes across the server, tests, and projection logic. This is a deep architectural shift affecting identity, storage, and routing. Side B adds meaningful features (external garden index fix, resolver refactor, GitHub import cards with rendering and tests), but it is more feature-scoped. Overall, Side A has broader and more foundational impact on the codebase.

Side B introduces a substantial, well-tested architectural change (a composable url_rules module for canonicalization, ItemId scheme changes to full URLs, updated call sites and tests, plus docs) that fixes real correctness issues in URL identity handling. Side A is a one-line trivial fix changing a disabled span to an anchor tag, of minor consequence.

Commit B introduces a real lasting design: ItemId becomes full canonical URLs, extracts composable url_rules (engine + per-domain registry for Reddit/YouTube normalization, breadcrumbs, parents), and updates path_types, reddit mapping, projection, and tests accordingly. Commit A is a one-line UI tweak swapping a disabled span for an a href="#" in the forum paginator with no design or bugfix impact.

Side B introduces a substantial URL canonicalization framework by extracting normalization into a new `url_rules` module, adopting canonical `https://` ItemIds, updating parsing, parent/breadcrumb logic, Reddit URL handling, event application, and adding tests for these behaviors. Side A only changes a disabled paginator control from a `<span>` to an `<a href="#">`, a minor UI tweak with far less lasting architectural impact.

Side B introduces a full URL canonicalization system (`url_rules` with parsing, normalization, and breadcrumbs) and integrates it across `ItemId`, event parsing, and Reddit handling, replacing ad-hoc string logic with a consistent design. Side A only swaps a disabled `<span>` for an `<a href="#">`, a minor UI tweak with little lasting impact.

Side B introduces a comprehensive URL canonicalization system (`server/src/url_rules/engine.rs`, `registry.rs`) and refactors `ItemId` to use canonical full HTTPS URLs, updating parent/breadcrumb logic, Reddit/Youtube normalization, and event parsing across the codebase. Side A merely changes a disabled paginator element from a `<span>` to an `<a href="#">`, a minor markup tweak with negligible architectural impact.

Side B fixes a real user-facing bug (empty /-/ external index due to querying a bogus parent), adds a coherent resolvers/ module with a typed GithubImportCard schema and rendering, plus CSS/layout and integration tests validating the fix. Side A is a substantial architectural rework of URL canonicalization (composable url_rules engine) which is well-designed but is largely a refactor/rename churn (test-string updates dominate the diff) without fixing an observed bug, making B's concrete correctness fix and shippable feature slightly more valuable.

Side A introduces a real composable URL canonicalization subsystem (url_rules engine + registry), migrates ItemId to full https URLs, and rewires parent/breadcrumb/storage paths across the core model—foundational identity design with lasting project impact. Side B fixes one broken /- index query and upgrades GitHub import presentation (structured cards, resolvers/ move, CSS), which is valuable product work but narrower and partly UI/reorg relative to A’s identity layer.

Side A makes a foundational change to the project's identity model by introducing a composable URL canonicalization subsystem (`server/src/url_rules/`), switching `ItemId` to canonical full URLs, centralizing parent/breadcrumb logic, and updating projection/event parsing so stored IDs are normalized consistently. Side B delivers a real bug fix for the external garden index and improves GitHub resolver rendering with rich cards, but most of its changes are feature/UI-oriented and a module reorganization rather than a core architectural improvement.

Side A introduces a full URL canonicalization system (`url_rules` with parsing, normalization, breadcrumbs, parent logic) and rewires `ItemId` to use it, replacing ad-hoc logic across the codebase—this is a foundational design improvement. Side B fixes an index bug (removing bogus `https://.` parent) and adds GitHub resolver rendering/cards, but these are more feature/UI-oriented and less structurally pervasive than A’s core identity model overhaul.

Side A introduces a new `url_rules` engine and refactors `ItemId` to use canonical full URLs (e.g., `https://reddit.com/...`) across parsing, storage, parents, breadcrumbs, projection, and Reddit integration—removing the old ad-hoc `canonicalize` logic and centralizing normalization. This is a foundational identity-layer redesign affecting many modules and tests. Side B adds a valuable GitHub resolver module and fixes the external garden index, but it builds on existing structures rather than reshaping core URL identity semantics.

Side B introduces a substantial architectural change: a composable url_rules engine/registry replacing ad-hoc string canonicalization, making ItemId a real full URL and enabling extensible per-domain rules (reddit, youtube, tracking-param stripping) with broad test coverage across the codebase. Side A is a smaller, valid bugfix restoring OAuth E2E test mocks (regex split, exception handling, correct HttpExchange API), which is useful but narrowly scoped to test infrastructure rather than core product design.

B introduces a lasting core design: ItemId as full canonical URLs plus a composable url_rules engine (Reddit/YouTube normalization, parents/breadcrumbs) wired through path_types, reddit mapping, projection, and tests. A only patches test doubles (regex split, getRequestBody, redirect length, null token) and minor Playwright selectors so E2E auth runs again—real but localized infrastructure fix.

Side A restores broken OAuth end-to-end authentication by fixing concrete runtime issues in the mock servers: it corrects query parsing (`str/split` regex), reads POST bodies from `getRequestBody`, avoids null crashes when parsing bearer tokens and state, wraps handlers in error handling, and updates the Playwright test helpers to use real selectors and return status instead of sleeping. Side B introduces a URL canonicalization framework and updates many call sites and tests, but this patch is largely a broad refactor with widespread mechanical changes and supporting infrastructure rather than a clearly demonstrated bugfix of comparable immediate, lasting impact.

Commit A delivers a substantive architectural change (offloading entity payloads to RocksDB via a new durable crate, plus streaming event-log replay), reducing startup RAM and adding real tests/persistence behavior, even though much of the diff is vendored lockfile/dep noise. Commit B is a large URL-canonicalization refactor (adding a rules engine and rewriting ItemId to always include scheme) which is reasonably designed but is mostly mechanical test-string updates and a schema-migration risk without corresponding data migration tooling beyond a README note, making its net lasting value comparatively smaller despite similar diff size.

A delivers lasting architecture: entity JSON moves off the in-memory tree into RocksDB via EntityStore, and event_log gains true line-at-a-time replay so startup no longer materializes the full log. B’s url_rules module and https-canonical ItemId are correct, focused design, but they mainly re-shape identity strings and call sites rather than changing capacity or persistence the way A does.

Side A introduces substantial new infrastructure: a RocksDB-backed `durable` workspace crate, an `EntityStore` that moves raw Reddit JSON off-heap, and a streaming `EventLog::replay` API that replays one line at a time to reduce startup memory, with corresponding integration into state loading and reducers. Side B mainly refactors URL canonicalization by introducing `url_rules`, switching to canonical `https://` identifiers, and updating parsing/tests, which is useful but narrower in long-term architectural impact than the persistence and replay redesign in Side A.

Side B is a substantial, well-tested architectural rework: it introduces a composable url_rules engine/registry, migrates ItemId to canonical full URLs, fixes breadcrumb/parent logic for structural path segments, and updates all call sites and tests consistently, providing lasting infrastructure value. Side A is a small, useful bugfix (skip pinned Reddit posts) with a good test, but it is narrow in scope compared to B's broad canonicalization redesign.

B replaces ad-hoc schemeless path IDs with a real full-URL ItemId model and a composable url_rules engine (Reddit/YouTube canonicalization, breadcrumbs, parent hierarchy), which is core lasting design wired through the stack. A is a correct, tested import filter for stickied/pinned posts, but it is a narrow local improvement versus B’s foundational identity/schema work.

Side B introduces a substantial URL canonicalization architecture by extracting normalization into a new `url_rules` module, converting `ItemId` to canonical HTTPS URLs, updating parsing, parent/breadcrumb logic, projection application, and Reddit mapping, with broad test coverage. Side A is a useful targeted bug fix that skips stickied/pinned Reddit posts during subreddit import and adds a regression test, but its impact is much narrower than the lasting infrastructure and consistency improvements in Side B.

Side A introduces a genuinely new, well-tested subsystem (composable url_rules engine with per-domain canonicalization, breadcrumb/parent logic, alias detection) that fixes real bugs (e.g. phantom 'comments' breadcrumbs) and is directly tied to the documented ItemId-as-canonical-URL design, with dozens of unit tests validating behavior. Side B mixes useful dead-code removal (demo counter) with a non-trivial async settlement/batching architecture and ranking cache, but adds no tests for the new concurrency-sensitive worker, making its correctness and lasting value less certain despite the performance intent.

A redesigns core identity around full canonical URLs and adds a lasting, composable url_rules engine (parent/breadcrumb hierarchy, Reddit/YouTube normalization) wired through storage, projection, and Reddit mapping. B’s lasting piece is a useful settlement worker plus ranking cache/read-lock cleanup, but much of the diff is removing demo-counter scaffolding rather than foundational model work.

Side A introduces a durable URL identity and canonicalization subsystem (`url_rules` with composable normalization, breadcrumb/parent logic, `ItemId` integration, replay parsing, and widespread migration to canonical `https://` IDs), improving how entities are identified and stored across the project. Side B makes meaningful architectural improvements by removing demo-only code and adding a settlement worker plus cached ranking computation, but its main impact is performance and cleanup, whereas Side A establishes a broader foundational data model that affects persistence, replay, parsing, and navigation.

Side B introduces a substantial, well-tested architectural improvement: a composable url_rules engine/registry replacing ad-hoc string canonicalization scattered across path_types.rs, reddit.rs, etc., with clearer per-domain rules and broad test coverage plus a documented rebuild step. Side A is a solid, more surgical fix (deterministic tokens, prose URL linkification, code-fence guard) but is narrower in scope and lower-risk; both are good, but B's redesign has longer-lasting structural value despite touching much more code including many mechanical test updates.

A adds lasting product and parser design: typed/deterministic BlockMasker, a real prose item-ref tokenizer (URLs/~/− refs, fence-aware, punctuation/newline handling), braced body rules, and garden linkify wired to that tokenizer with focused tests. B’s composable url_rules + full-URL ItemId is also foundational, but a large share of the diff is cascading test/id string rewrites and migration noise rather than net new behavior.

Side A delivers substantive parser and rendering improvements: it introduces deterministic typed block masking, a prose tokenizer that correctly recognizes item references while avoiding code fences, enforces braced DSL bodies instead of ambiguous fenced blocks, fixes URL tokenization at line boundaries, and updates HTML linkification to support raw URLs and external references with thorough tests. Side B mainly restructures URL canonicalization around a new rules engine and updates many call sites and tests to use `https://` canonical IDs, but much of the patch is migration and infrastructure churn compared with the concrete parsing and correctness fixes in Side A.

Side A is a substantive, well-tested refactor of URL canonicalization into a composable rule engine (url_rules module) that fixes real correctness issues (scheme-qualified ItemId, reddit/youtube normalization, parent/breadcrumb logic) with extensive new unit tests. Side B is largely infra/ops scaffolding (Dockerfile, fly.toml, CI) plus a dashboard UI and audit-broadcast plumbing that adds operational value but is less architecturally durable and more application-specific/generated-feeling (large CSS/JS blob, repo-list config tweaks).

A delivers lasting core design: a composable url_rules engine, scheme-full canonical ItemIds, and correct parent/breadcrumb hierarchy (e.g. skipping phantom /comments nodes) wired through identity, Reddit mapping, and projection apply. B’s deploy path, status API, epoch/OpenRouter guards, and multi-repo config are real operational value, but a large share is dashboard CSS/JS surface and infra wiring rather than durable domain structure.

Side A introduces a substantive URL canonicalization architecture by extracting normalization into composable `url_rules` modules, making `ItemId` consistently use canonical HTTPS URLs, fixing parent/breadcrumb handling, and updating projection/event parsing to canonicalize stored IDs. Side B adds valuable deployment infrastructure, a live audit dashboard, SSE progress reporting, and CI/CD, but those are primarily operational features rather than core data-model improvements; the canonical identity changes in A have broader long-term impact on correctness and consistency.

Side A introduces a genuinely new, composable url_rules engine (ParsedUrl combinators + per-domain registry) with real behavior additions (YouTube canonicalization, tracking-param stripping, alias tracking) plus tests, replacing ad-hoc string canonicalization with a more maintainable design. Side B is a large but mostly mechanical rename/refactor (CanonicalItemUrl -> ItemId enum) that changes call sites and tests extensively without adding new normalization capability, and even removes a planning doc (plan.md) that documented intended future work, reducing net lasting value relative to its churn.

Commit A adds lasting design: a composable `url_rules` engine/registry, scheme-bearing canonical ItemIds, smarter parent/breadcrumb rules, and real domain normalizers (Reddit + YouTube), not just renames. Commit B’s ItemId enum and CanonicalItemUrl removal improve type structure across reducer/RPC/HTML, but most of the diff is mechanical type propagation with similar string-backed keys and little new behavior.

Side A delivers new behavior: it introduces a composable URL canonicalization/rules engine (`server/src/url_rules`), makes full `https://` URLs the canonical identity, centralizes parsing/parent/breadcrumb logic, updates projection/event handling to canonicalize IDs at apply time, and adds tests for Reddit/YouTube normalization and breadcrumb behavior. Side B is a broad architectural refactor replacing `CanonicalItemUrl` with `ItemId` across the codebase and moving wire helpers into new modules, but most changes are type migration and call-site updates rather than adding new user-visible functionality or fixing concrete bugs.

B adds core identity/auth (OAuth, sessions, pseudonyms, trust weights) plus event projection rules and cleans up by externalizing durable; these are lasting features. A performs a URL canonicalization refactor (new url_rules crate + mechanical string updates across tests) that improves design but is primarily churn without new user-visible capability.

Side B performs the foundational integration: it introduces the url_rules engine/registry, switches ItemId to store fully-qualified canonical URLs, and updates every call site across the codebase (event_log, journal, pair, parser, projection_apply, reddit.rs, reducer, render, state) plus docs and a replay script, fixing real correctness issues (scheme-qualified IDs, parent/breadcrumb logic). Side A largely re-implements the same URL-parsing/canonicalization logic as a DFA graph with extensive tests, but it only touches files inside url_rules and isn't wired into the rest of the system, making its practical impact less certain and partly redundant with the machinery B already built.

A delivers a complete, tested semantic URL graph (DFA traversal, absorb edges, parent chains, builder validation, generic fallback) that is the lasting core design for canonicalization and breadcrumbs. B introduces the initial engine/registry and necessary ItemId→full-URL wiring, but a large share of its diff is mechanical https:// id renames and call-site churn around a simpler transform pipeline that A supersedes.

Side A introduces a substantially richer URL canonicalization architecture: a graph-based traversal engine with declarative graph builder, parsing layer, generic fallback, breadcrumb generation, context-aware canonicalization for Reddit and YouTube, and extensive validation/tests. Side B mainly integrates URL canonicalization into the wider codebase and migrates IDs to full HTTPS URLs, but much of its functional value depends on the underlying URL rules that Side A implements.

A replaces fragile string-splitting canonicalization with a properly designed, composable url_rules engine (real URL parsing via the `url` crate, per-domain rules, alias detection, YouTube/Reddit normalization) backed by thorough new unit tests and documentation — a focused, correct, lasting design improvement. B is a much larger but self-described 'first pass' refactor that mostly relocates existing REST-handler logic into one giant monolithic rpc.rs match statement, trading modularity for a batched RPC surface without clearly improving code quality, making its long-term value less certain despite the larger diff.

B delivers a lasting domain/API redesign: permission boundaries become rooms (RoomCreated, ScopeId::Room, room_id on Ingest) separate from forum thread_tag, with a unified batch RPC surface that replaces many REST handlers and scopes the CLI (public/private). A is a solid identity rewrite (full https ItemIds plus a composable url_rules engine and breadcrumb/parent fixes), but a large share of that patch is mechanical ID/string updates across tests versus B’s structural event/reducer/API changes.

Side A introduces a reusable URL canonicalization subsystem (`server/src/url_rules/`), converts `ItemId` to canonical full URLs, centralizes parsing/parent/breadcrumb logic, and updates projection and Reddit handling to consistently normalize persisted IDs. Side B is a sweeping API refactor that replaces many endpoints with a single RPC layer and room-scoped commands, but much of the patch is code movement and interface consolidation rather than new core behavior, making A's normalization design and identity fixes more foundational and durable.

Side B introduces a genuinely reusable, composable URL canonicalization engine (url_rules/engine.rs + registry.rs) replacing ad-hoc string manipulation in path_types.rs, fixing structural issues (proper scheme handling, generalizable per-domain rules, YouTube support) with real unit test coverage of edge cases like breadcrumb phantom segments. Side A adds real feature value (Reddit OAuth linking, UUID-based identity) but is more feature-bolt-on with less architectural improvement, and its projection_apply logic for pending in-batch weight reads is a minor but real fix; both are substantive, but B's refactor yields a cleaner, more maintainable foundation for id canonicalization used project-wide.

A lands a real identity-model change (UUID-only principal, multi-provider link/attach/conflict flows, private linked-provider UI) plus full Reddit OAuth with mocks, routes, and trust-weight batching—behavioral product surface, not renames. B’s new url_rules engine and https-canonical ItemIds are lasting foundation work, but much of the patch is mechanical ID-string churn across tests after the format scramble.

Side A implements a significant authentication and identity architecture change: UUID becomes the canonical identity, OAuth accounts become linkable providers, Reddit OAuth is added alongside GitHub, provider-link conflict handling is implemented, linked providers are tracked privately, and the projection logic is fixed so trust-weight updates see earlier writes in the same batch. Side B introduces a useful URL canonicalization framework and migrates IDs to full HTTPS URLs, but much of the patch is mechanical updates to tests and string literals, making its lasting impact smaller than the functional identity and authentication changes in Side A.

Both are refactors, but B fixes a real design flaw (identity rewriting scattered/duplicated across reducer and events, ambiguous @ sigil handling, agent required even for human-only ingests) with a clean split into identity.rs/canonical_path.rs, consistent wire-form contracts, and updated tests/integration scripts proving the new behavior end-to-end. A introduces a plausible composable url_rules engine but is mostly a large mechanical find-replace of test fixtures from bare hostnames to https:// URLs, with the actual new engine/registry code being sizable but less proven by broad test coverage across the whole system (CLI, api, html, bb integration tests) as B demonstrates.

A adds a real domain subsystem (`url_rules` engine/registry) and redesigns `ItemId` around full canonical URLs with parent/breadcrumb rules and multi-site normalization (Reddit/YouTube), which is lasting core design. B mostly splits existing helpers into `canonical_path`/`identity`, drops `@` from wire forms, and makes delegate optional—valuable API hygiene, but largely reorganization plus contract tightening rather than new capability.

Side A introduces a substantial URL identity architecture: a new composable `url_rules` module, canonical full-URL `ItemId`s, centralized canonicalization/parent/breadcrumb logic, replay support, and updates projection, Reddit integration, and storage parsing to use the new canonical identities. Side B is primarily a refactor separating identity and path normalization plus changing wire formats (removing `@` from stored/API identities and making delegates optional), which improves organization and API consistency but is less foundational than the new canonical URL system and normalization behavior added in Side A.

Side B introduces a genuinely new, composable URL-canonicalization subsystem (url_rules module with engine + registry, domain-specific rules for reddit/youtube, breadcrumb/parent derivation) that fixes real correctness issues (schemeless IDs, non-canonical hosts, youtube variants) and is exercised by substantial new tests. Side A is a solid internal refactor (GroupState -> ScopeVotes, deriving edges on demand) that improves clarity but is mostly mechanical renaming/restructuring of existing logic without adding new capability or fixing an external-facing bug, making B's contribution somewhat more impactful in scope though both are reasonable quality refactors.

A removes incremental edge/index caches from GroupState (ensure_item, rollback_weights, voted_pairs) in favor of ScopeVotes that keep only uuid_votes/recent_votes and rebuild edges at rank time—a lasting single-source-of-truth fix across reducer, ranking, storage, and pair logic. B adds a real url_rules engine and full-URL ItemIds, but much of the diff is mechanical https:// string churn in tests and call sites rather than equally deep design consolidation.

Side A makes a substantial architectural change by replacing cached `GroupState` with `ScopeVotes`, deriving ranking edges and connected components on demand from deduplicated votes. It updates ranking, storage, reducers, UI, and tests consistently, simplifying persisted state while preserving behavior. Side B mainly introduces URL canonicalization infrastructure and migrates many tests and IDs to `https://` forms, which is useful but much of the patch is mechanical conversion rather than a core data model improvement.