c_5e9a63e9d2769fe0a6

Side B performs a substantial, coherent refactor that moves path/URL logic into a shared slug-types crate with type-safe newtypes (GardenItemUrl, ForumThreadUrl, TildeOntologyPath), reducing duplication and making the wire format correct-by-construction across server modules and RPC responses, backed by preserved/expanded tests. Side A is a smaller dev-tooling improvement (fixture persistence via cargo-watch) plus an unrelated, undocumented removal of room page headers, offering less durable architectural value than B's cross-cutting type-safety refactor.

B centralizes path canonicalization and wire URL construction into slug-types (GardenItemUrl, ForumThreadUrl, TildeOntologyPath), typing API/RPC fields and removing ad-hoc string helpers—lasting core design. A mainly improves local fixture DX (cargo-watch, persistent fixture-data/, preferred port 8080) plus a small room-page HTML cleanup, valuable for iteration but not structural.

Side B performs a substantial architectural refactor by moving canonical path normalization and URL construction into a shared `slug_types::paths` module, replacing ad hoc string helpers with strongly typed `GardenItemUrl`, `ForumThreadUrl`, and related types across the API and shared data structures. Side A mainly improves the local development workflow by switching the fixture runner to `cargo watch` with persistent fixture data and preferred ports, which is useful but primarily affects developer iteration rather than the project's long-term design.

B is a small, focused correctness fix (enforcing valid vote ratio bounds across DSL parser, UI handler, and reducer) with targeted regression tests and a real behavioral improvement preventing degenerate/invalid votes. A is a large mechanical refactor moving code into a new types module with newtypes wrapping strings, which improves type-safety/organization but is mostly churn (renames, re-exports, moved tests) without fixing any bug or changing runtime behavior, and risks regressions across many call sites for marginal clarity gains.

B enforces a real ranking invariant (both ratio sides ≥ 1 and ≤ 100) in the DSL parser, UI POST path, and reducer (dropping zero-side votes instead of normalizing 0:0→1:1), with unit and integration regression tests. A mostly relocates existing canonicalize/path helpers into slug-types and wraps API strings in GardenItemUrl/ForumThreadUrl/TildeOntologyPath—useful structure, but largely mechanical re-export and call-site rewiring without fixing domain behavior. A precise multi-layer correctness fix outlasts diffuse type centralization alone.

Side A performs a substantial architectural refactor by moving canonicalization, path identity, and room-aware URL generation into shared `slug_types::paths` newtypes (`GardenItemUrl`, `ForumThreadUrl`, `TildeOntologyPath`) and updating API/RPC types to use those abstractions instead of ad hoc string helpers. Side B is a valuable correctness fix that consistently enforces vote ratio bounds (both sides 1–100) across the parser, UI, reducer, and tests, but its scope is a targeted validation improvement rather than a foundational API and type-system redesign.

Side B performs a substantive, consistent refactor centralizing path/URL logic into a shared slug-types crate with new correct-by-construction newtypes (GardenItemUrl, ForumThreadUrl, TildeOntologyPath), reducing duplication and improving type safety across API responses, with tests migrated intact. Side A adds a real feature (typed form holes, vote redirect, vote page wiring) but bundles unrelated Cargo.lock dependency churn and CSS/JS additions with less architectural cohesion, making its net value more mixed.

Side A delivers lasting product capability: typed `$form:i32` holes, vote navigation via `next`, item-page CTAs, compare UI CSS/JS slider, and routing/deps to make child voting usable. Side B is a worthwhile but behavior-preserving move of path canonicalization into slug-types newtypes (GardenItemUrl/ForumThreadUrl), improving structure without new user-facing behavior.

Side B performs a broad architectural refactor by moving canonical path normalization and URL construction into shared `types::paths` newtypes (`GardenItemUrl`, `ForumThreadUrl`, `TildeOntologyPath`) and updates API/RPC types and call sites to use them instead of ad hoc string helpers. Side A adds useful user-facing voting functionality (typed form substitution, vote navigation, slider support, and a new vote route), but much of the visible patch is UI/CSS and dependency additions, whereas B centralizes path identity and reduces duplication across the codebase with a more durable design improvement.

B is a substantial, well-tested refactor that moves path/URL logic into a shared slug-types crate with correct-by-construction newtypes (GardenItemUrl, ForumThreadUrl, TildeOntologyPath), reducing string-formatting duplication and improving type safety across server and DTOs, while preserving existing test coverage. A is a smaller, focused change (Deque->Vec plus dropping an eager trim in favor of a query-time cap) that is reasonable and adds a targeted test, but is narrower in scope and impact compared to B's broader architectural improvement.

A changes core projection storage from a write-capped Deque to an append-only List/Vec with query-time capping, drops the separate post-batch trim_recent_votes path, and bumps schema with a focused regression test—this is a lasting durability/design fix. B mainly relocates existing canonicalization helpers into slug-types and wraps API strings in GardenItemUrl/ForumThreadUrl newtypes, which improves consistency but is largely organizational move/rename churn rather than new behavior.

Side B centralizes path normalization, canonicalization, and room-aware URL generation into a shared `slug_types::paths` module, replacing duplicated string helpers with strongly typed `GardenItemUrl`, `ForumThreadUrl`, and related types across server and API code. This is a broad architectural improvement that reduces duplication and makes path handling consistent across serialization and validation, whereas Side A is a more localized storage refactor from `Deque` to append-only `List` with read-time capping and accompanying tests.

B is a genuine refactor that centralizes canonicalization/href logic into a shared slug-types crate with correct-by-construction newtypes, updates dozens of call sites consistently, and adds preserved/expanded tests—net positive architectural cleanup. A deletes a large, over-engineered but working keystroke-autocomplete graph in favor of a much simpler paste-and-go textarea, which is a reasonable simplification but net removes functionality (live suggestions, tab-complete) and its own test suite/Playwright race test without replacing that coverage, making it more of a regression/simplification than a durable improvement.

A replaces an unreliable ~1.8k-line keystroke graph parser (plus parser_action, racey frontend, and Playwright race test) with a small, tested paste-and-go URL parser and redirect that permanently fixes the UX by design. B is a solid centralization of path canonicalization into slug-types with GardenItemUrl/ForumThreadUrl newtypes, but it mostly relocates existing helpers and tightens types rather than changing product behavior.

Side B consolidates canonical path normalization and URL construction into shared `slug_types::paths` newtypes (`GardenItemUrl`, `ForumThreadUrl`, `TildeOntologyPath`) and updates API/RPC types to use them, eliminating duplicated string-building logic across the server. Side A replaces a complex autocomplete parser with a much simpler paste-and-go flow and removes substantial UI, JS, and parser infrastructure; while it likely improves reliability, it is primarily a feature simplification rather than a foundational architectural improvement.

Side A performs a genuine architectural consolidation—moving path canonicalization/URL construction into a shared slug-types crate with correct-by-construction newtypes (GardenItemUrl, ForumThreadUrl, TildeOntologyPath), replacing scattered string-formatting helpers with typed APIs across server and RPC code, which reduces duplication and future URL-shape bugs. Side B adds a useful but auxiliary dev-only CLI tool (sorterc) for offline DSL compiling/linting, which is valuable tooling but doesn't touch core correctness or design of the production system. Both are solid, but A's refactor has broader lasting impact on the codebase's core type safety and maintainability.

A centralizes path canonicalization and room-aware href construction into shared slug-types newtypes (GardenItemUrl, ForumThreadUrl, TildeOntologyPath) and threads them through API/RPC response types, replacing ad-hoc string helpers with lasting domain structure. B adds a useful but peripheral workspace-only sorterc binary for offline DSL compile/JSONL lint that mostly wraps existing server logic. Core path-identity typing in the shared schema outweighs a dev-only tooling surface.

Side A consolidates canonicalization, path normalization, and room-aware URL generation into a shared `types::paths` module, replacing scattered string helpers with strongly typed `GardenItemUrl`, `ForumThreadUrl`, and `TildeOntologyPath` throughout RPCs and API types. This removes duplicated logic, makes wire formats correct-by-construction across many interfaces, and centralizes core path semantics, whereas Side B adds a useful developer-only offline compiler/linter (`sorterc`) without changing the project's core runtime design.

B performs a substantial, coherent refactor centralizing path/URL logic into a shared `slug-types` crate with strongly-typed newtypes (GardenItemUrl, ForumThreadUrl, TildeOntologyPath), improving correctness-by-construction and reducing duplicated string-formatting logic across server and RPC code, while preserving existing tests. A fixes a real bug (Reddit children not linked via ensure_path, causing unranked labels to show raw ids) with a small targeted change plus test coverage, which is valuable but narrower in scope and reach than B's broader architectural improvement that touches many call sites and eliminates fragile string-based path handling project-wide.

A fixes real import behavior by replacing link_child/ensure_path with apply_entity_under_parent so Reddit listings attach under the subreddit without pulling /comments/ path segments, and makes unranked children show entity titles via child_label plus tighter SSE/children integration tests. B mostly relocates existing canonicalization and URL helpers into slug-types (GardenItemUrl/ForumThreadUrl re-exports) with call-site renames—useful structure, but little new lasting behavior versus A’s functional tree and UI correctness fixes.

Side A fixes functional behavior: it changes Reddit children imports to use a dedicated `apply_entity_under_parent` path so subreddit listings no longer create unwanted `/comments/...` hierarchy, updates the ranking panel to display imported child titles instead of raw IDs by consulting the global tree, and adds integration tests covering SSE updates and children fetches. Side B is primarily a large refactor that centralizes path and URL types into `slug-types` and updates many call sites, improving organization and type safety but with little direct user-visible functionality.

Side A is a focused, well-tested refactor that consolidates path/URL logic into a shared types crate with correct-by-construction newtypes, removing duplicated string-based helpers while preserving behavior (tests carried over and passing). Side B is a much larger, riskier architectural rewrite (scope→fractal-tree, settlement→journal, subreddit-only parser→generic ItemId) that touches many core modules with less certainty of correctness and a vague commit message ('reconfigure'), making it harder to trust as durable, reviewed value versus A's clear, incremental centralization.

B replaces flat string scopes with a real hierarchical domain model (ItemId parent/breadcrumbs, GlobalTree/NodeState, journaled NodeEnsured, tree-scoped votes and UI), which changes how rankings and navigation work permanently. A is a strong hygiene refactor—moving canonicalize_* and CanonicalItemUrl into slug-types and wrapping wire hrefs as GardenItemUrl/ForumThreadUrl—but it mostly relocates and type-wraps existing URL rules without introducing comparable new behavior.

Side A performs a substantial architectural consolidation by moving canonical path normalization and URL construction into a shared `types::paths` module, replacing ad hoc string helpers with typed wrappers (`GardenItemUrl`, `ForumThreadUrl`, `TildeOntologyPath`) throughout the server and API models. This centralizes path identity, reduces duplication, and makes RPC/serialization use correct-by-construction types, whereas Side B is a broad reconfiguration introducing a new tree/journal architecture and UI changes but also many placeholders (e.g. stubbed Reddit fetch), renames, and incomplete infrastructure whose lasting value is less clearly realized in the patch itself.

B is a cohesive architectural refactor: it moves path canonicalization into slug-types with strongly-typed GardenItemUrl/ForumThreadUrl/TildeOntologyPath newtypes, replacing scattered string-based helpers across the whole API surface with correct-by-construction types, improving long-term maintainability. A mixes a legitimate room-URL refactor (dropping the slash between short/slug) with a large speculative addition of YouTube-specific URL normalization and extensive url::Url identity documentation tests that are tangential to the stated 'url refactor' goal, diluting its focus and adding untested-in-practice heuristic logic.

A adds lasting product/design substance: room URLs become a single validated `/r/{short}{slug}` segment via `room_route`, plus real external identity work (`url_normalize`, YouTube rewrites, query sorting, dash path case rules) wired through canonicalize and call sites/tests. B is valuable but mainly a move of existing canonicalization/path helpers into `slug-types` with GardenItemUrl/ForumThreadUrl newtypes and re-exports—structural centralization and API typing more than new behavior.

Side A delivers a functional URL routing redesign by introducing shared `room_route_segment`/`room_id_from_route_segment` helpers, updating all server routes and handlers to use the new single-segment `/r/{room_key}` format, synchronizing ID generation via `ROOM_SHORT_ID_LEN`, and adding URL normalization logic (including YouTube canonicalization and query normalization) with tests. Side B is primarily an architectural refactor that centralizes existing path and URL helper types into `slug_types::paths` and replaces string helpers with typed wrappers across the API, improving organization and type safety but largely preserving behavior.

Side A implements a real, working feature (a background Reddit fetch worker with OAuth, rate-limit handling, caching, and JSON parsing, wired into the tree/state) with its own tests, delivering concrete new functionality. Side B is a substantial but purely mechanical refactor moving path/URL types from server into a shared types crate, preserving identical behavior without adding new capability, so its value is organizational rather than functional, and it duplicates rather than improves logic (mostly copy-paste plus type wrapping).

A replaces a stub with a full Reddit import path: background broker/worker, OAuth, rate-limit/backoff/dedup, JSON parsing into EntityData, browse/ensure_path hooks, and focused tests—real lasting product capability. B centralizes existing path canonicalization and wire URL helpers into slug-types (GardenItemUrl/ForumThreadUrl) for clearer typed APIs, but is mostly relocate/wrap refactor without new behavior.

Side A adds substantial new functionality: a background Reddit import system with OAuth support, rate-limit/backoff handling, request deduplication, JSON parsing into project entities, integration into application state, and automatic fetch triggering when Reddit items are browsed or added. Side B is a useful architectural refactor that centralizes path and URL types into `slug-types` and updates API consumers to use those newtypes, but it largely preserves existing behavior rather than adding new capabilities.

B is a substantive, type-safe refactor that moves scattered string-based URL/canonicalization logic into a shared slug-types crate with correct-by-construction newtypes (GardenItemUrl, ForumThreadUrl, TildeOntologyPath), reducing duplication and improving safety across many call sites while preserving test coverage. A is a smaller, well-scoped feature addition (pool-scoped voting) that adds real user value but touches less surface area and is more incremental/local in impact than B's foundational cleanup.

A adds a real end-to-end product capability (pool-scoped /vote, child-pair selection, pool-preserving next navigation, and the item-page entry point) with focused wiring through query, UI action, and success morph. B is largely a relocate-and-retype of existing path/URL helpers into slug-types plus call-site churn; valuable consolidation, but mostly mechanical with little new behavior versus A’s lasting feature surface.

Side A adds a substantive user-facing capability: `/vote?pool=` can automatically select child-item pairs, keeps pool context through vote submission and next-pair navigation, and exposes the feature via a new "vote on children" UI link. Side B is a broad architectural refactor that centralizes path and URL types into `slug_types::paths` and updates many call sites, improving consistency and type safety, but it mostly reorganizes existing behavior rather than adding new functionality.

B is a small, precise real bugfix: it moves the zero-ratio guard before ensure_item/voted_pairs.insert, eliminating ghost items and incorrectly-marked-voted pairs, with an updated test proving the corrected behavior. A is a large refactor centralizing path/URL logic into slug-types, which is a reasonable architectural cleanup but is mostly code relocation with no new bug fixes, and duplicates/rewires existing tests rather than fixing a defect; its value is real but more about maintainability than correctness, and its size is due to churn rather than necessity.

B fixes a real reducer correctness bug by rejecting zero-ratio votes before ensure_item/voted_pairs.insert, preventing ghost items and false voted-pair marks, with a matching test update. A is a useful but largely mechanical centralization/move of path helpers into slug-types plus API newtype wiring—lasting structure without changing broken core behavior.

Side A consolidates canonicalization, URL generation, and path newtypes into a shared `slug_types::paths` module, replaces ad hoc string helpers with strongly typed `GardenItemUrl`, `ForumThreadUrl`, and `TildeOntologyPath`, and updates API types to use those abstractions across the codebase. Side B fixes a real correctness bug by moving the zero-ratio guard before `ensure_item` and `voted_pairs.insert`, preventing ghost items and false voted pairs, but its impact is narrower than the architectural cleanup and type-safety improvements introduced by Side A.

Side A is a focused, coherent refactor that centralizes path/URL logic into a well-tested types module, preserving behavior (tests moved and passing) while reducing duplication and improving type safety across the codebase. Side B delivers real feature value (room UI wiring, session cookies, web posting) but also includes an unrelated, unpolished 'plan2.md' architecture essay committed to the repo, which is noise/spectacle rather than working code, slightly diluting the commit's substance despite the legitimate routing/auth additions.

B restores lasting product capability: HttpOnly session cookies, /login|/logout, ACL-gated /r/{short}/{slug} room index and thread/post/expand routes, compose forms, and POST /post that reuses rpc_post_with_bearer—making private rooms usable in the browser. A is a solid but secondary refactor that moves canonicalize_* / CanonicalItemUrl into slug-types and swaps string helpers for GardenItemUrl/ForumThreadUrl newtypes without adding behavior.

Side A performs a substantial architectural refactor by moving canonicalization, path parsing, and room-aware URL generation into a shared `types::paths` module, replacing ad hoc string helpers with strongly typed `GardenItemUrl`, `ForumThreadUrl`, and `TildeOntologyPath` throughout the API and shared types. This centralizes path semantics, reduces duplication across server and shared crates, and makes JSON/RPC interfaces type-safe, whereas Side B mainly wires browser UI features (cookie login, room routes, posting handlers) and adds a planning document without a comparable improvement to the project's core design.

Side B implements a real functional improvement (SSE-based async entity fetch with proper job result tracking, rate-limit handling, and updated JS/client integration plus adjusted integration test), delivering concrete new user-facing behavior. Side A is a large but purely mechanical type-renaming/relocation refactor (moving string helpers into newtypes) with no behavior change and even removes some test coverage duplicated elsewhere, offering less lasting functional value despite its size.

A permanently centralizes path canonicalization and room-aware hrefs into slug-types (GardenItemUrl/ForumThreadUrl/TildeOntologyPath) and types the API/RPC surface, replacing ad-hoc string helpers with a shared identity model. B’s SSE fetch pipeline and Reddit oneshot completion are real UX/architecture gains, but they are localized to one import flow and mix in logging/churn, so they add less cross-cutting lasting value than A’s path core.

Side A performs a substantial architectural refactor by moving path canonicalization and URL construction into a shared `types::paths` module, replacing ad hoc string helpers with strongly typed `GardenItemUrl`, `ForumThreadUrl`, and `TildeOntologyPath` throughout the API and shared types. This centralizes path identity, reduces duplication, and makes JSON/RPC interfaces more type-safe, while preserving behavior via migrated tests; Side B adds useful SSE-based Reddit fetch streaming and UI updates, but it is a more localized feature with additional dependencies rather than a cross-cutting improvement to core project design.

Side A performs a genuine architectural improvement, moving path/URL canonicalization and room-aware href construction into a shared slug-types crate with correct-by-construction newtypes (GardenItemUrl, ForumThreadUrl, TildeOntologyPath), eliminating duplicated string-based helpers and reducing future room-prefixing bugs across the whole API surface. Side B is a solid, more localized fix (faster scan avoiding full replay, better error detail, new compile --ingest debug feature) but its impact is confined to the sorterc devtool rather than the core server's type safety and correctness guarantees.

A centralizes canonicalization and room-aware href rules into shared slug-types newtypes (GardenItemUrl, ForumThreadUrl, TildeOntologyPath) and threads those through API/DTOs and RPC, replacing ad-hoc string helpers with lasting, correct-by-construction path identity. B’s sorterc work is real and useful (fast parse-only scan, richer parse_error output, compile --ingest), but it is localized tooling rather than core domain structure.

Side A makes a lasting architectural improvement by moving canonical path normalization and URL construction into a shared `types::paths` module, replacing ad hoc string helpers with typed wrappers (`GardenItemUrl`, `ForumThreadUrl`, `TildeOntologyPath`) across the API and shared data structures. This centralizes path identity, reduces duplication, and makes many RPC/JSON interfaces correct-by-construction, whereas Side B mainly improves offline tooling with faster log scanning, richer parse errors, and a useful `compile --ingest` workflow but does not affect the project's core data model as broadly.

B is a substantial refactor that centralizes duplicated path/URL logic (canonicalize_item, item_path_for_api_in_room, forum_thread_web_url) into a single shared slug-types::paths module with correct-by-construction newtypes (GardenItemUrl, ForumThreadUrl, TildeOntologyPath), reducing duplication between server and types and tightening type safety across many call sites, with tests preserved. A adds a legitimate small feature (RoomList RPC + CLI + integration test) which is useful but narrower in scope and lower architectural impact than B's cross-cutting consolidation.

A adds a genuine new RPC (RoomList) plus CLI and thorough isolation tests that enforce grant-scoped room visibility; B mostly relocates existing canonicalization/helpers into slug-types newtypes and rewires call sites without new behavior or bugfixes.

Side B performs a broad architectural refactor by moving canonicalization and path/URL identity into a shared `slug_types::paths` module, replacing ad hoc string helpers with strongly typed `GardenItemUrl`, `ForumThreadUrl`, and related types across RPCs, validation, and API responses. Side A adds a useful `RoomList` RPC, CLI subcommand, and thorough integration tests for per-user room visibility, but it is a localized feature, whereas Side B establishes reusable infrastructure that reduces duplication and makes path handling consistent project-wide.

B performs a genuine architectural improvement: moving path/URL logic into slug-types as typed newtypes (GardenItemUrl, ForumThreadUrl, TildeOntologyPath), eliminating stringly-typed helpers and duplicated normalization code across server and shared types, with preserved tests. A adds a new /ui endpoint and a JSON-template form-filling mechanism, which is useful but introduces more speculative complexity (a new DSL-like templating system with security caveats) without clear necessity or broad reuse yet. B's refactor reduces duplication and strengthens type safety across the whole API surface, providing more durable value than A's single new feature endpoint.

A adds lasting UI architecture: form_template hole-filling, HtmlUiAction, and a unified POST /ui handler that shares web_post run_* paths and enables lazy new-thread morphs—not mere churn. B is valuable (path types moved into slug-types with GardenItemUrl/ForumThreadUrl), but it largely relocates and retypes existing string helpers rather than introducing comparable new product capability.

Side B centralizes canonical path normalization and room-aware URL generation into the shared `slug_types::paths` module, replacing scattered string helpers with typed `GardenItemUrl`, `ForumThreadUrl`, and related types across RPCs and API responses. This is a broad architectural improvement that reduces duplication and strengthens type safety, whereas Side A primarily adds a new `/ui` endpoint, HTML UI action parsing, and refactors existing web-post handlers for reuse to support browser interactions.

Side B introduces a real, user-facing DSL semantic change (explanation-first vote syntax) with corresponding parser rework, updated docs, and broad test-fixture migration across server, CLI, and browser integration tests, demonstrating a functional language change with wide validation. Side A is a large but purely internal refactor (moving path/URL types into a shared crate) that improves code organization but changes no external behavior and carries higher risk of regressions without adding new capability.

B changes the core DSL so votes are explanation-first (leading `{…}` then the comparison), with parser, UI payloads, docs, and fixtures updated to match—a lasting product/language design. A is a solid consolidation of path/URL identity into slug-types with wire newtypes (GardenItemUrl, ForumThreadUrl), but it largely relocates existing helpers and retypes JSON fields without changing user-facing behavior.

Side A consolidates canonical path normalization and URL construction into shared `slug_types::paths` newtypes (`GardenItemUrl`, `ForumThreadUrl`, `TildeOntologyPath`) and updates API/RPC types to use those strongly typed representations instead of scattered string helpers. This removes duplicated logic, centralizes canonicalization across crates, and makes many interfaces correct-by-construction, whereas Side B primarily changes the DSL syntax for vote explanations and updates the parser, documentation, fixtures, and tests to match that new format.

B performs a substantive refactor: moves path/URL logic into a shared `slug-types::paths` module, introduces well-typed newtypes (GardenItemUrl, ForumThreadUrl, TildeOntologyPath) that are correct-by-construction and used consistently across RPC/validation code, improving type safety and removing duplicated string-based helpers. A's commit removes an unrelated demo-counter feature and adds a plausible but half-baked async settlement/batching worker with caching, which is useful but smaller in scope, less tested, and mixes unrelated concerns (feature removal + new architecture) in one commit.

A delivers a real architectural step: a settlement worker that batches votes, appends events, recomputes scores once, and serves rankings from a cache under read locks, while deleting the demo-counter path end-to-end. B mostly relocates existing canonicalization/URL helpers into slug-types and thin newtypes (GardenItemUrl, ForumThreadUrl), improving structure without comparable new runtime behavior.

Side A makes substantive architectural improvements by introducing a settlement worker that batches vote persistence and ranking recomputation, adds cached ranking reads (`ranked_items_cached`) to avoid unnecessary recomputation under read locks, and warms the cache at startup. Although it also removes the demo counter UI, the lasting value comes from improving concurrency, performance, and vote processing, whereas Side B is primarily a refactor that relocates path and URL types into a shared `slug_types` module and updates call sites without substantially changing behavior.