c_df12ba3b70a8c9af49

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 contributes a larger architectural change. It introduces a new workspace crate (`durable`) implementing RocksDB-backed persistent collections, integrates it into the server with a disk-backed entity store for Reddit payloads, changes replay to stream the event log line-by-line to reduce startup memory, updates startup/state management, and adds extensive documentation, examples, tests, and build integration. These changes affect persistence, memory usage, and project structure across many components. Side A is also a significant contribution: it fixes the external garden index, refactors the resolver system into a dedicated module, adds GitHub import cards with rendering support, updates vote-compare rendering, styling, and tests. However, its scope is primarily a feature/UI and resolver refactor, whereas Side B introduces broader infrastructure with long-term impact on storage and replay behavior.

Commit B introduces a substantial architectural change: a new durable storage crate backed by RocksDB, integration into the server, streaming event log replay to reduce memory usage, and an entity store that moves large payloads off-heap. This impacts persistence, startup performance, and system design across multiple modules. In contrast, Commit A mainly refactors the resolver system, fixes a bug in external indexing, and adds GitHub card rendering and UI improvements. While A is sizable and user-facing, B delivers deeper infrastructure changes with broader long-term impact.

Commit B introduces a new durable storage subsystem (a full RocksDB-backed workspace crate), integrates it into the server for off-heap entity storage, and refactors event log replay to stream line-by-line—significantly improving architecture, scalability, and startup memory behavior. It spans many files, adds substantial functionality (new crate, APIs, examples, docs), and changes core persistence paths. Commit A is a solid feature/refactor (GitHub resolver modularization, rich cards, external index fix, tests, CSS), but its impact is primarily at the application/UI and resolver layer. B represents a deeper infrastructural enhancement with broader long-term 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.

A fixes a genuine bug (the external garden root listing was always empty) and cleanly refactors the GitHub resolver into a structured, tested module with real UI/test coverage, all without new heavy dependencies. B vendors an entire third-party 'durable' RocksDB crate wholesale (README, docs, LICENSE, examples, benchmarks, its own Cargo.lock) just to back a simple string->string entity cache, adding a large, mostly irrelevant dependency footprint (rocksdb/bindgen/clang) disproportionate to the actual need, even though the underlying entity_store/streaming-replay idea has some merit.

B’s streaming event-log replay and EntityStore offload of Reddit JSON out of GlobalTree into RocksDB are lasting architectural fixes for startup RAM and scale, whereas much of A is a useful bugfix (bogus https://. external roots) plus presentational GitHub card rendering/CSS after a resolver move. B’s concrete value is the wire-up (entity_store, replay API, reducer no longer holding entity_raw), not the bulk of the vendored durable examples/docs noise.

Side B introduces a substantial architectural improvement by moving large entity payloads out of in-memory structures into a RocksDB-backed `EntityStore` and changing event log startup from loading the entire log to streaming replay via `EventLog::replay`, reducing memory usage and improving scalability. Side A contains a real bug fix for the external garden index (`external_root_host_items`) and adds richer GitHub import card rendering with resolver modularization, but much of the patch is UI, rendering, and refactoring rather than a foundational runtime improvement.

Side B introduces a new RocksDB-backed `durable` storage layer, moves large JSON payloads out of memory into `EntityStore`, and replaces `load_all` with streaming `replay`, directly improving scalability and startup memory. Side A mainly restructures resolvers and adds GitHub card rendering/UI plus a bugfix, which is valuable but more feature/UI-oriented than foundational system improvements.

Side B introduces a new `durable` workspace crate with RocksDB-backed persistent collections (DurableMap/Vec), integrates an `EntityStore` to move large JSON payloads off-heap, and replaces `load_all` with streaming `replay` to reduce startup RAM—substantial architectural improvements. Side A mainly refactors the GitHub resolver into a `resolvers/` module, adds rich card rendering and CSS, and fixes the external index root logic—valuable UI and organization work but less foundational than adding durable storage and streaming log replay.

Side A fixes a real bug (external garden index always empty due to a bogus parent), introduces a substantive resolvers/ module with structured GitHub import cards, rich rendering hooks, layout CSS, and both unit and integration test coverage across multiple files. Side B is a small, focused but narrow fix (skip pinned Reddit posts) with a single test, which is useful but far more limited in scope and lasting impact.

A fixes a real empty-index bug on `/-/` via `external_root_host_items`, modularizes resolvers, and adds structured GitHub import cards with render hooks, CSS, and compare/integration tests—durable product surface. B only skips stickied/pinned Reddit children in `parse_children` plus a unit test: a correct but narrow filter with far less lasting design impact.

Side A fixes a real functional bug where the external garden index incorrectly queried a bogus `https://.` parent by introducing `external_root_host_items`, ensuring host roots are discovered even from implicit child edges, and it adds a lasting resolver architecture (`server/src/resolvers/`) with rich GitHub import-card rendering integrated into item pages and vote comparison, backed by unit and integration tests. Side B is a useful but narrow correctness improvement that skips stickied/pinned Reddit posts during subreddit import by filtering `stickied`/`pinned` entries, with a corresponding test.

Side B fixes a real bug (empty /-/ index due to a bogus 'https://.' parent), adds a substantive resolvers module with typed GithubImportCard rendering, and includes broad test/CSS coverage across surfaces, delivering concrete user-facing value. Side A improves DSL prose-link tokenization and deterministic block masking (useful correctness/robustness work), but is narrower in scope and mostly refines existing linkification rather than fixing a broken feature or adding new capability.

B fixes a real product break (/-/ external index querying bogus https://./) via external_root_host_items, and adds lasting structured GitHub import cards (schema, try_render_resolver_item_body, vote-compare/CSS/integration). A is strong core work (deterministic typed BlockMasker, prose ItemRef tokenization, braced body rules, linkify rewrite) but is more narrowly parser/linkify infrastructure versus B’s end-to-end bugfix plus feature surface.

Side A makes foundational parser and rendering improvements: it replaces random block tokens with deterministic typed tokens, adds a prose item-reference tokenizer that correctly skips code fences and trims URL punctuation/newlines, and enforces braced DSL bodies with corresponding parser and renderer updates plus extensive tests. Side B fixes the external garden root listing and adds a richer GitHub resolver/card system, but much of the patch is feature expansion and module reorganization rather than core parsing correctness.

Side B fixes a real production bug (empty /-/ external garden index due to bogus parent), refactors external_resolver into a resolvers/ module with typed GithubImportCard rendering, wires it through vote-compare and item pages, and adds integration/unit tests plus CSS. Side A adds a new URL-canonicalization graph engine with extensive tests but is a standalone/net-new feature not shown to fix any existing defect or integrate with the rest of the app in this diff, making B's change more clearly load-bearing and battle-tested.

Side A introduces a full semantic URL graph (DFA traversal, builder validation, parse/canonicalize/breadcrumbs, generic fallback) with broad, lasting design and dense unit coverage for Reddit/YouTube equivalence. Side B fixes a real empty /-/ index bug via external_root_host_items and adds structured GitHub import cards plus render hooks, but much of the diff is a module move/refactor of existing resolver code plus CSS/layout polish.

Side A introduces a new URL parsing and semantic graph infrastructure with DFA-based traversal, canonicalization, generic fallback behavior, a validated graph builder, and extensive tests covering Reddit, YouTube, encoding, breadcrumbs, and parsing. Side B contains a real bug fix for the external garden index and adds GitHub resolver card rendering plus a module refactor, but much of its patch reorganizes existing resolver code while adding a narrower feature set.

Side A fixes a real bug (empty external garden index due to bogus parent), cleanly restructures the GitHub resolver into a resolvers/ module with a proper card schema/renderer, and adds targeted unit/integration tests validating the new behavior. Side B is largely infra/deploy plumbing (Dockerfile, fly.toml, CI) plus a sizable dashboard/SSE feature for a separate constitution.py service, which is useful operationally but is less about core product correctness and mixes config, UI, and scattered test tweaks.

B ships the constitution as a running, auditable production system: Fly/Docker/CI deploy path, expanded real repo/contributor roots, resilient epoch execution, /api/status, and a tested /watch SSE progress UI—foundational lasting infrastructure. A’s /- host-index bugfix, resolvers/ card schema, and GitHub rich rendering are strong product work, but more incremental on slug.social than standing up the live ownership process itself.

Side A fixes a real functional bug by replacing the bogus `https://.` parent lookup for the external garden index with `external_root_host_items`, ensuring external roots are discovered even from implicit child edges, and adds tests for that behavior. It also introduces a reusable resolver architecture (`server/src/resolvers/`), rich GitHub import card rendering via `render_item_body_in_scope`, and integration/unit tests, whereas Side B is primarily deployment and observability infrastructure (Docker, Fly, GitHub Actions, SSE dashboard, status APIs) that improves operations but less directly changes the project's core behavior.

Side B fixes a real bug (the /-/ external garden index was always empty due to a bogus parent URL), refactors the resolver module more cleanly with structured card data and rich rendering, and adds meaningful test coverage plus CSS layout support. Side A adds a genuinely useful feature (Reddit OAuth linking, UUID-canonical identity) but is comparably scoped and mostly additive plumbing without fixing an existing defect, making B's fix-plus-feature combination slightly more impactful.

A lands a lasting identity redesign (UUID as sole principal, multi-provider OAuth link/attach semantics, private linked-provider UI, Reddit OAuth, and the pending_weights batch trust bugfix). B’s external garden index fix and GitHub card renderer are real and useful, but much of the patch is a resolver move/reformat plus presentation/CSS versus A’s core account model.

Side A introduces a durable identity model where UUIDs become the canonical account identity and OAuth providers are linkable rather than identities themselves, adds Reddit OAuth support alongside GitHub, handles account-link conflicts, and fixes projection batching so multiple OAuth link events correctly accumulate trust weight within one batch. Side B contains a real bug fix for the external garden index and improves GitHub resolver rendering with rich import cards and modularization, but those changes are more feature/UI focused than the foundational authentication and identity redesign in Side A.

Side A is a focused, verifiable change: it fixes a real bug (the /-/ external garden index always querying a bogus parent so it looked empty), adds a well-tested GitHub import-card resolver feature with unit and integration tests, and includes matching CSS across themes. Side B is a sprawling 'first pass' refactor (REST endpoints collapsed into one 1300-line RPC dispatcher, thread_id renamed/split into room_id+thread_tag, ThreadCreated→RoomCreated) that touches nearly every file; while it adds real room/capability functionality, its own commit message signals it's unfinished/exploratory, and the renames plus monolithic dispatcher trade clarity for scope in a way the fixed, tested bug/feature in A does not.

B establishes lasting platform structure: a single batch RPC surface, Ingest split into room_id + thread_tag, ScopeId::Room with separate rooms vs forum_threads, and CLI public/private scoping—core model work the whole API rides on. A is a solid, tested product fix (/-/ host roots via external_root_host_items) plus GitHub card schema/render on compare, but narrower side-feature value versus B’s architectural cut.

Side B introduces a substantial architectural shift by consolidating many separate REST endpoints into a typed RPC layer, separating validation into its own module, and changing the data model from thread-centric to room-centric (`room_id` + `thread_tag`), with corresponding reducer, CLI, event, and test updates. Side A contains a valuable functional bug fix for the external garden index (`external_root_host_items`) and adds richer GitHub import card rendering, but much of its patch is feature work and module reorganization rather than the broad infrastructure change delivered by Side B.

Side A fixes a real, well-diagnosed algorithmic bug (bipartite Markov chain causing wrong rankings) with a principled, citation-backed correction and solid regression tests, delivering focused lasting correctness value. Side B is a larger feature/refactor (external index fix, resolver reorg, GitHub cards, CSS) that is useful but more diffuse, mixes a genuine bugfix with substantial new surface area and styling churn, making its net lasting-value density lower despite greater line count.

A fixes a core Rank Centrality correctness bug (weight-sum d_max → degree-based d_max) that left star topologies bipartite and stuck at uniform scores, aligning the Markov matrix with Negahban–Oh–Shah and adding targeted Rust/Clojure regressions. B’s lasting pieces are the external-root host listing fix and GitHub card rendering, but much of the diff is a resolvers/ move, HTML/CSS presentation, and feature polish rather than foundational algorithm repair.

Side A fixes a fundamental correctness bug in the ranking algorithm by switching Rank Centrality to the canonical degree-based d_max, eliminating oscillation in star-topology graphs and producing the correct stationary distribution. It also adds focused regression tests (Rust and end-to-end fixture tests) that lock in the behavior, whereas Side B mixes a real external index fix with a large refactor, GitHub card rendering, module moves, and UI enhancements whose lasting value is broader but less foundational.

Side B fixes a genuine correctness/security bug: feed catch-up previously relied on wall-clock timestamps, which could miss or leak posts across users due to millisecond collisions or clock rollback, and adds strong multi-user private-room permission tests proving the anchor-by-ingest-position fix. Side A is a larger feature addition (GitHub import cards, resolver refactor) plus a real bug fix for the empty external garden index, but it's more feature/UI surface than a critical correctness fix, and part of the diff is churn from moving/renaming external_resolver.rs into resolvers/.

B fixes foundational feed catch-up by anchoring on durable ingest index (not wall-clock ts), so same-ms and clock-rollback posts are not skipped, and adds permission-aware multi-user private-room filtering plus room on FeedPost with strong integration tests. A’s real /- empty-index fix and GitHub card renderer matter, but much of that patch is resolver relocation/UI chrome versus B’s core correctness and leak-prevention design.

Side B fixes a correctness issue in feed catch-up by anchoring implicit feeds to durable ingest order instead of timestamps, preventing missed posts when timestamps collide or move backwards, and preserving permission-aware behavior across private-room visibility changes. It also factors the logic into a reusable rpc_feed helper, adds room metadata to feed responses, and includes comprehensive multi-user integration tests covering concurrent ingests, permission revocation, and restoration, whereas Side A mixes one real bugfix for the external index with a larger feature/refactor for GitHub import cards and UI rendering.

Side B fixes a real concurrency/correctness bug (a shared sentinel delegate binding on first vote silently blocked every other human voter) with a minimal, well-targeted change plus a multi-user regression test proving the fix. Side A adds substantial new feature surface (GitHub import cards, resolver module split, external-root fix) which is valuable but larger/noisier and mostly additive feature work rather than a critical correctness fix; B's change prevents active user-facing breakage, giving it slightly more lasting value per line changed.

B fixes a core multi-user correctness bug: shared WEB_BROWSER_AGENT/INVITE_BROWSER_AGENT caused AgentBound on first browser vote and blocked every later human; PendingSession.agent becomes Option, UI posts pass no delegate, and a two-user vote integration test locks it in. A’s /- external-root fix and GitHub card/resolvers work are real lasting value, but much of the patch is a module move plus richer import UI, which matters less than unblocking multi-user voting.

Side A fixes a real functional bug where the external garden index (`/-/`) appeared empty by introducing `external_root_host_items`, and it also adds a durable resolver architecture (`server/src/resolvers/`) with GitHub import-card storage/rendering, integration into item rendering, and accompanying tests. Side B is a valuable correctness fix—removing browser sentinel delegates so browser users no longer share a delegate and multi-user voting works correctly—but it is a narrower authentication/data-model change centered on making browser sessions use `None` delegates and updating attribution and tests.