c_11ce057e37af785de5

Commit A makes a substantial architectural change to the server. It removes the temporary demo counter feature, introduces a dedicated asynchronous settlement worker that batches vote processing, separates ranking computation from cached ranking reads, warms the ranking cache at startup, changes locking from write to read on rendering paths, and updates state management and tests accordingly. These changes improve performance, concurrency, and the overall design of the application rather than just removing dead code. Commit B is also significant, adding deterministic typed block tokens, prose item-reference tokenization, support for linkifying raw URL references while avoiding code fences, stricter DSL parsing for braced item bodies, breadcrumb fixes, and extensive tests. It meaningfully improves parsing correctness and user-facing linkification. Both commits are valuable, but A has broader impact on core runtime behavior and application architecture, whereas B is primarily focused on DSL parsing and rendering correctness.

Side A introduces a substantial architectural change: removing the demo counter feature, adding an asynchronous settlement worker with batching, decoupling write/read access to shared state, and introducing cached ranking computation. This affects core request handling, persistence, and performance characteristics across the system. Side B is also significant, with improved DSL parsing, tokenization, and linkification plus strong test coverage, but it is more localized to parsing and rendering logic. Overall, A has broader system-level impact.

Side A introduces a substantial architectural change: removing the demo counter feature and adding a new asynchronous settlement worker with batching, cached ranking computation, startup cache warming, API/state refactors, and corresponding test updates. This meaningfully impacts core state management, performance, and concurrency. Side B improves DSL parsing and linkification with deterministic block masking, prose tokenization, stricter parsing rules, and solid tests—valuable but more localized to parsing/rendering. Overall, Side A delivers broader systemic impact.

Commit A introduces substantial new functionality and parser behavior across multiple modules. It adds deterministic typed block masking, prose tokenization for item references, URL and external reference handling, stricter DSL parsing rules for braced bodies versus code fences, improved linkification, breadcrumb fixes, resolver updates, and extensive automated tests covering the new behavior. These changes affect core parsing, rendering, and external item support. Commit B is primarily a UI/layout cleanup with some CSS improvements for ranking lists and removal of an extra wrapper element in the compare page. While useful, it is much smaller in scope and impact than the parser and linkification work in Commit A.

Side A introduces substantial new functionality: deterministic and typed block masking, a full prose tokenizer for item references, improved URL parsing (including punctuation trimming and newline handling), stricter DSL validation rules, and integration into HTML linkification. It also adds extensive tests and refactors multiple components to support these features. Side B is comparatively minor, mainly removing a wrapper element in a template and adding CSS refinements. The scope, complexity, and impact of A are significantly greater.

Side A introduces substantial functional changes across the DSL parser, block masking system, prose tokenization, linkification logic, external resolver behavior, and adds extensive new tests. It improves determinism, enforces stricter parsing rules, enhances URL/item reference handling, and refactors HTML link generation. Side B mainly removes a wrapper shell in one template and adjusts CSS styling for ranking lists, which is comparatively minor and largely presentational. Therefore, Side A contributed significantly more.

Side A introduces a substantial architectural improvement by moving vote persistence and ranking recomputation into a dedicated settlement worker, adding cached ranking reads (`ranked_items_cached`) so HTTP handlers can use read locks instead of recomputing under write locks. It also removes an obsolete demo counter and simplifies the UI around the real ranking workflow. Side B adds useful DSL parsing and linkification improvements (typed block masking, prose item reference tokenization, braced body enforcement, and URL linkification), but these are more feature-focused and narrower in long-term impact than the concurrency and performance redesign in Side A.

A introduces a new async settlement pipeline (mpsc worker, batching, and cached score computation) and shifts ranking reads to a cached, read-only path, improving correctness and performance under concurrency; it also removes unused demo-counter code. B adds richer DSL parsing/tokenization and linkification rules, but these are more feature-level enhancements rather than core architectural improvements.

Side B adds substantive DSL and linkification improvements: deterministic, typed BlockMasker tokens (removing random IDs), a new prose tokenizer that correctly stops raw URLs at punctuation/newlines and skips code fences, enforces braced item bodies, and updates HTML linkification to use these tokens with extensive tests. Side A mainly removes the demo counter and refactors ranking to use cached reads plus a settlement worker, which is valuable but narrower in scope than B’s parser, linking, and correctness enhancements.

B fixes concrete, verifiable bugs in URL/DSL parsing (code-fence contamination of link tokenization, missing trailing-punctuation trimming, ambiguous item-body syntax) and backs each fix with new unit tests, plus swaps a fragile random-token masker for a deterministic one. A's core change (an async settlement worker with score caching) is a reasonable architectural idea but ships with no new tests for the worker/batching/error paths, and much of the diff is just removing demo-counter scaffolding rather than adding tested, lasting functionality.

A introduces a real settlement worker (batched disk append + vote apply + ranking recompute) and a cached read path so HTTP ranking no longer needs write locks or on-the-fly score iteration, while deleting the whole demo-counter feature surface. B is solid parser/UX work (deterministic typed block masks, prose item-ref tokenization, braced bodies, garden linkify for URLs/dash refs), but it extends presentation/DSL edges rather than core vote/ranking durability.

Side A makes substantive parser and rendering improvements: it introduces deterministic typed block masking, a prose item-reference tokenizer that correctly handles raw URLs, punctuation, newlines, and code fences, enforces braced DSL item bodies instead of ambiguous fenced bodies, fixes external breadcrumb root detection, and updates linkification plus extensive tests. Side B is primarily a UI/layout cleanup and CSS styling change (removing a wrapper element and improving ranking-number presentation), with little impact on core functionality or long-term correctness.

A introduces substantive parsing and correctness improvements: deterministic block tokens replacing RNG, typed block tracking, a new prose tokenizer that avoids code fences and trims punctuation, and stricter validation requiring braced item bodies—plus integrating this into linkification. B mainly removes a wrapper div and tweaks CSS/layout, with no comparable impact on core logic or correctness.

Side A introduces a typed, deterministic BlockMasker with BlockKind tracking, adds a prose tokenizer that avoids linkifying inside code fences, enforces braced DSL item bodies with explicit parse errors, and rewrites HTML linkification to use the tokenizer—backed by extensive new tests. Side B mainly removes a wrapping section in vote_compare and tweaks CSS for ranking lists, which is largely presentational and far less architecturally significant.

Side A implements a substantive, tested feature: a typed block-masking system, deterministic tokenization, and a proper prose tokenizer that correctly linkifies item refs while respecting code fences and line boundaries, backed by many new unit tests and bugfixes (e.g., requiring braced item bodies). Side B is a mix of minor CSS tweaks (ranking-list marker styling) and a cosmetic removal of a wrapping HTML section/indentation change with no functional test coverage or clear lasting design improvement.

A adds lasting core behavior: deterministic typed block masking, prose item-ref tokenization (tilde/dash/raw URLs, newline/punctuation boundaries, code-fence exclusion), braced body enforcement, linkify/resolver updates, and tests. B only unwraps a vote-compare shell div and tweaks ranking-list number CSS—cosmetic UI polish with little structural impact.

Side A adds a large invite feature with real working mint/redeem/audit flow and end-to-end tests, but it also introduces substantial dead scaffolding — Event::InviteMinted/InviteRedeemed, ActiveInviteState, room_timeline, and an entire new timeline.rs module — none of which are ever wired into the actual RPC/reducer flow (invites are minted/redeemed purely via the separate ephemeral state.invites map), leaving confusing, unused duplicate machinery. Side B is a smaller but coherent and fully-integrated fix: it makes block masking deterministic/typed, correctly tokenizes prose item refs (fixing real link/URL-boundary/code-fence bugs), tightens DSL item-body rules, and backs every change with focused unit tests, with no orphaned code paths.

A delivers a complete invite-link feature (mint RPC, /join redemption into grants, CLI, audit, room timeline merge into ThreadItem, and an end-to-end invites test suite), which is a durable access-control capability. B is a focused but narrower DSL/linkify improvement (deterministic block kinds, braced bodies, prose tokenization of ~/ -/ https refs with fence/newline handling) that mainly refines existing garden rendering rather than adding a new product surface.

Side A implements a substantial new capability: an end-to-end invite system with invite minting, redemption during OAuth, room auditing, new RPCs/CLI commands, server routes, state management, and integration tests covering the workflow. Side B improves DSL parsing and HTML linkification by adding deterministic block masking, prose reference tokenization, URL handling, stricter braced item bodies, and tests, but these are narrower parser/UI enhancements compared with the lasting project functionality introduced in Side A.

Side B introduces a well-structured, testable URL canonicalization graph (DFA traversal, generic fallback, builder with build-time validation) plus extensive matrix/edge-case tests, giving durable infrastructure for URL normalization. Side A is also solid (deterministic block tokens, prose ref tokenizer, stricter DSL body rules) but is more narrowly scoped and partly overlaps with fixing self-inflicted regressions (e.g., requiring braces around fenced bodies that previously worked without them), whereas B adds a genuinely new, reusable subsystem with strong safety guarantees (percent-encoding, tracking-param stripping).

A delivers integrated, lasting product behavior: deterministic typed block masking, a real prose item-ref tokenizer (with newline/punctuation and code-fence rules), stricter braced-body DSL parsing, and HTML garden linkification for ~/‑/ and raw URLs wired through external_resolver and breadcrumbs. B adds a large, well-tested URL DFA/canonicalization subsystem, but it is mostly isolated greenfield scaffolding under a vague commit with less demonstrated end-to-end impact than A’s cross-layer contract and UX changes.

Side A delivers integrated parser and rendering improvements: it adds deterministic typed block masking, a prose item-reference tokenizer that correctly avoids code fences and trims URL punctuation, enforces braced DSL bodies, updates HTML linkification to support raw URLs/external references, and adjusts serialization accordingly, all backed by focused tests. Side B introduces a substantial URL canonicalization graph and parser framework with extensive tests, but it is largely new infrastructure whose lasting value depends on broader integration, whereas Side A directly fixes parsing correctness and user-visible behavior across existing code paths.

Side A is a focused, well-tested fix improving DSL/link tokenization correctness (deterministic tokens, prose URL boundaries, code-fence handling) with clear new tests validating behavior. Side B vendors a large speculative 'durable' crate (with docs, examples, benchmarks, RocksDB bindgen deps) whose core motivation—reducing startup RAM—is undermined by still reading the entire event log and calling flush_wal on every single operation, adding heavy build complexity (clang, RocksDB) for a dubious IO-bound win, though it also includes a useful minor line-by-line replay refactor mixed into the noise.

B delivers lasting architectural value by offloading Reddit entity JSON from in-memory GlobalTree into a RocksDB-backed EntityStore and replacing full event-log loads with line-at-a-time replay, directly cutting startup RAM; A is a solid but narrower UX/parser improvement (deterministic BlockMasker tokens, prose ItemRef tokenization, braced body enforcement) that mainly extends garden linkify behavior.

Side A delivers focused, lasting functionality: it adds a prose item-reference tokenizer that correctly skips code fences, trims trailing punctuation, supports raw URL references, enforces braced DSL item bodies instead of standalone code fences, and updates HTML linkification to use the tokenizer, all backed by targeted tests. Side B mixes a few meaningful runtime changes (streaming event-log replay and moving entity payloads to a RocksDB-backed store) with a very large amount of vendored crate, lockfile, documentation, examples, and generated project scaffolding, making the substantive project improvement much smaller relative to the patch size.

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 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 B ships a coherent, tested feature set (deploy pipeline, Dockerfile, fly.toml, GitHub auth for git mirroring, a live /watch dashboard with SSE audit events, and single-contributor fast-path fix for rank_commits) backed by unit tests and integration test updates, giving durable infrastructure and correctness value. Side A is a solid, well-tested parser improvement (deterministic tokens, prose URL linkification, braced-body enforcement) but is narrower in scope and mostly internal refactoring/feature polish within one module.

B delivers lasting operational value: production deploy (Docker/Fly/CI), multi-repo contributor config, emission retry, and a real audited /watch SSE progress surface with status API and tests—foundational for running the constitution itself. A is strong design (deterministic typed BlockMasker, prose ref tokenizer, braced body rules, linkify), but it is product/DSL polish plus some formatting churn, not the same system-level necessity.

Side A makes substantive parser and rendering improvements: it introduces typed deterministic block masking, a prose item-reference tokenizer that correctly handles raw URLs, punctuation, newlines, and code fences, enforces braced DSL item bodies, updates linkification accordingly, and adds focused tests for these behaviors. Side B adds valuable deployment infrastructure and a live audit dashboard (Docker, CI/CD, SSE status/UI, production config), but much of its impact is operational rather than improving the project's core parsing and data model, so its lasting contribution is somewhat smaller.

A is a focused, well-tested feature/bugfix (deterministic block tokens, proper prose URL tokenization with fence-awareness, breadcrumb root fix) that clearly improves correctness and is validated by new unit tests. B is a sprawling 'first pass' architectural rewrite (REST endpoints collapsed into one giant RPC dispatcher, Thread→Room renaming) that deletes a lot of previously tested, well-structured code and introduces a large, less type-safe generic command enum — valuable functionality-wise but explicitly unfinished/exploratory and far noisier relative to its net design benefit.

B restructures the core product model (rooms vs thread tags), event schema, reducer indexing, and consolidates the scattered REST surface into a batch RPC API with CLI/tests updated to match—foundational multi-room architecture. A is a solid but narrower win: prose item-ref tokenization, stricter braced bodies, and garden linkify for URL/dash refs, plus small breadcrumb correctness.

Side A delivers cohesive, lasting parser and rendering improvements: it introduces typed deterministic block masking, a prose item-reference tokenizer that correctly avoids code fences and trims URL punctuation, enforces braced DSL bodies, updates linkification for raw URLs/external references, and adds extensive tests covering these behaviors. Side B is a very large architectural refactor that replaces many REST endpoints with a new RPC layer and renames thread/room concepts, but much of the patch is migration and code movement rather than clearly new functionality, making its enduring value less certain than A's targeted correctness improvements.

Side B fixes real correctness bugs in the DSL/linkify layer (non-deterministic block tokens, URL over-matching into trailing punctuation, missing external/dash-ref linkification, ambiguous unbraced code-fence item bodies) and backs each with focused unit tests, yielding durable parser/rendering correctness. Side A adds a substantial new feature (Reddit OAuth linking) with reasonable design, but it's larger, more speculative in scope, and mixes in refactors/renames without the same density of targeted bug fixes and regression tests.

A lands a lasting identity redesign (UUID as sole principal, multi-provider link/attach with oauth_taken conflicts, private linked-provider UI) plus full Reddit OAuth and a real projection batch weight fix—core account infrastructure. B’s prose tokenizer, braced-body rule, and garden URL linkify are valuable UX/parser work, but narrower and partly diluted by formatting churn in html/mod.rs.

Side A delivers a substantial identity-system redesign: it makes UUIDs the canonical account identity, adds Reddit OAuth alongside GitHub, supports linking multiple providers to one account with conflict handling, exposes linked providers privately, updates routing and storage, and fixes trust-weight projection so multiple OAuth link events are applied correctly within a batch. Side B improves the DSL and HTML by tokenizing prose item references, preventing linkification inside code fences, requiring braced item bodies, and adding URL-link support, but these are narrower parsing and rendering enhancements compared with the lasting architectural and authentication capabilities introduced by Side A.