@kudzujs/core 0.9.1 → 0.9.3

package/MIGRATION_ROADMAP.md

@@ -2,10 +2,28 @@
 
 This document is the source of truth for Kudzu's product direction, architecture invariants, and future development order. Read it before extending React-shaped syntax or browser capabilities.
 
-The active `0.9.0` execution sequence is maintained in [`docs/next-architecture/0.9-semantic-compression.md`](./docs/next-architecture/0.9-semantic-compression.md), with session-level implementation packets in [`docs/next-architecture/0.9-implementation-plan.md`](./docs/next-architecture/0.9-implementation-plan.md). Follow its ordered work queue and evidence gates for implementation work. The completed compiler foundation and longer-term sequence remain in [`docs/next-architecture/large-application-ai-native-roadmap.md`](./docs/next-architecture/large-application-ai-native-roadmap.md); this document remains authoritative when selecting or accepting a migration capability.
+The completed `0.9.0` execution sequence is maintained in [`docs/next-architecture/0.9-semantic-compression.md`](./docs/next-architecture/0.9-semantic-compression.md), with session-level implementation records in [`docs/next-architecture/0.9-implementation-plan.md`](./docs/next-architecture/0.9-implementation-plan.md). The next authorized milestone is the 1.0 AI delivery protocol recorded there. The completed compiler foundation and longer-term sequence remain in [`docs/next-architecture/large-application-ai-native-roadmap.md`](./docs/next-architecture/large-application-ai-native-roadmap.md); this document remains authoritative when selecting or accepting a migration capability.
 
 [`GOAL_A.md`](./GOAL_A.md) and [`GOAL_B.md`](./GOAL_B.md) are completed capability-validation records. Their commerce and realtime dashboard fixtures prove general lifecycle, navigation, async-workflow, and Worker capabilities; they are not separate product verticals or future priority lists.
 
+The post-0.9 local discovery audit of Memos, Apache Answer, and Actual Budget is recorded in [`docs/next-architecture/1.0-large-application-compatibility-audit.md`](./docs/next-architecture/1.0-large-application-compatibility-audit.md). Its passing reduced builds are not whole-application migrations. Each package-component, browser-data, router/layout, provider, and localization shape requires a separate executable evidence packet under the authorized 1.0 protocol before implementation.
+
+The first Apache Answer reduction is complete: one direct top-level `const match = useMatch("/exact-path")` over a named or aliased React Router import folds case-insensitively against the build-known application route. Reused relative components produce route-specific static HTML with zero browser bytes. Layout use, runtime-parameter pages, params, wildcards, query/hash patterns, trailing slashes, dynamic values, indirect calls, and pattern objects remain diagnosed.
+
+The next Apache Answer reductions preserve its direct numeric page fallback and string order fallback over `useSearchParams()`. Both reuse nullable query signals and existing primitive binding ESM; the string form accepts only a static element of a named relative JSON-safe immutable array. Dynamic indexes, arbitrary wrappers, and general query expressions remain diagnosed.
+
+Apache Answer layouts may retain named React Bootstrap `Row` and `Col` components when they use children, static `className`, and numeric literal `Col` spans from 1 through 12 for `xs` through `xxl`. Compiler normalization emits native Bootstrap grid classes with no browser JavaScript and covers all 63 observed static-breakpoint Col sites; Bootstrap stylesheet ownership remains with the application. Dynamic/object/boolean grid props and broader React Bootstrap components remain separate evidence packets.
+
+Apache Answer's `useTranslation()` cannot be folded safely because its language resources come from 46 YAML files, browser storage, and server responses. Kudzu emits a source-located diagnostic directing build-known locales to `getStaticPaths()` and props or browser-only selection to an owned effect; it does not substitute English or ship i18next.
+
+Apache Answer's SWR/axios/qs question reads now have an executable migration path through one native fetch effect with application-owned loading/error/data state. Derived `page` and `order` query dependencies restart the effect, stale responses lose setter authority, recommendation endpoints and HTTP recovery remain explicit, nested keyed tags retain list ownership, and a static sibling remains JavaScript-free. No cache, Provider, retry scheduler, SWR, axios, or query runtime is added.
+
+Apache Answer authentication now has a reduced layout-owned session path: native login form submission persists a token, a mount effect restores and validates it, shared header/settings consumers read one package-neutral state record, and a 401 clears storage/state before native replacement navigation. The public sibling remains JavaScript-free. Full browser acceptance and the broader server-fed settings stores remain subsequent gates.
+
+Apache Answer's first route-shell gate replaces `RouterProvider` and nested `Outlet` ownership with seven directly addressable Kudzu file routes, one ordinary shared shell, native anchors, and runtime question/tag parameters. Questions, tags, admin dashboard, and unwrapped legal output build without a browser router; the two bracket routes emit only pathname capability and rewrite metadata.
+
+Apache Answer authoring/admin intake now builds native question creation and keyed administration without form, editor, query, or state package runtimes. Constraint-backed title/markdown fields, controlled preview, markdown file import, local draft mutation, keyed admin rows, and deletion compile through existing handlers/lists while a legal sibling remains JavaScript-free. Rich CodeMirror ownership, server validation, upload progress, and destructive confirmation remain later acceptance gates.
+
 ## North Star
 
 An AI should be able to migrate ordinary React-shaped TypeScript and TSX to CDN-deployable static HTML, CSS, and only the route-specific ESM capabilities actually used, with minimal source restructuring.

package/README.md

@@ -14,7 +14,7 @@ Kudzu compiles ordinary React-shaped TypeScript and TSX into complete static HTM
 
 > Experimental `0.9.x`: the compiler API and supported TSX surface may change.
 
-**Latest release: 0.9.1 - Positional primitive lists.** JSON-safe primitive values now render in position-keyed collections while property-keyed rows retain their plain-object boundary. Read the [release notes](./RELEASES.md#091---positional-primitive-lists), open the [release page](https://github.com/kudzujs/kudzu/releases/tag/v0.9.1), or follow the [architecture packet](./docs/next-architecture/README.md).
+**Latest release: 0.9.3 - Large-app migration slices.** Apache Answer-derived fixtures add exact route matching, composed query reads, native React Bootstrap layout, owned browser data, authentication build intake, route-shell, and authoring/admin migration evidence without React or package runtimes. Read the [release notes](./RELEASES.md#093---large-app-migration-slices), open the [release page](https://github.com/kudzujs/kudzu/releases/tag/v0.9.3), or follow the [architecture packet](./docs/next-architecture/README.md).
 
 - [Documentation](https://kudzujs.cloud/docs)
 - [Installation guide](https://kudzujs.cloud/docs#install)
@@ -103,7 +103,10 @@ ordinary React-shaped TSX
 - Native document navigation is the default; static routes do not load a client runtime.
 - A named or aliased React Router `Link` with a static root-relative `to` erases to a base-aware native anchor; no router package or runtime is emitted.
 - A direct named or aliased React Router `useParams()` call on a `runtimeParams` bracket route reuses Kudzu's route-specific pathname reader.
-- React Router `useSearchParams()` supports direct static `get("name")` locals and inline setter updaters, lowering reads and history writes to one route-specific query capability.
+- A direct top-level React Router `useMatch("/exact-path")` route binding folds case-insensitively from the build-known application route without browser JavaScript.
+- React Router `useSearchParams()` supports direct static `get("name")` locals, the exact numeric pagination fallback `Number(params.get("page")) || 1`, a static imported-array string fallback, and inline setter updaters, lowering reads and history writes to one route-specific query capability.
+- React Bootstrap `Row` and `Col` with children, static classes, and numeric literal `Col` breakpoints erase to native Bootstrap grid markup; applications retain ownership of Bootstrap CSS.
+- Browser-only query data uses owned effects with application loading/error/data state; URL-derived dependencies, stale-response isolation, keyed results, and recovery require no query package runtime.
 - Only TypeScript modules reachable from pages are compiled. Imported immutable direct maps can fold to static HTML, while direct fields from relative structured calculations reevaluate through route binding ESM.
 - Package imports used directly inside JSX event callbacks are removed from build modules and retained only in bundled route handler ESM.
 - A named or aliased React Router `useNavigate()` top-level binding lowers direct nested-callback calls with safe static root-relative destinations to native `location.assign()` or `location.replace()` navigation.

package/RELEASES.md

@@ -1,5 +1,74 @@
 # Kudzu Releases
 
+## 0.9.3 - Large-app migration slices
+
+Kudzu 0.9.3 adds evidence-backed compiler and source-migration paths derived
+from Apache Answer while preserving static-first output and fail-closed package
+boundaries.
+
+### Changed in 0.9.3
+
+- Exact static React Router `useMatch()` folds from the build-known route with
+  zero browser JavaScript.
+- React Router query reads support numeric pagination and static imported-string
+  fallbacks, including reactive effect dependencies and read-only `popstate`.
+- React Bootstrap `Row` and `Col` lower to native grid markup, including numeric
+  literal breakpoint spans from 1 through 12.
+- Owned native fetch effects compose URL dependencies, stale-response isolation,
+  loading/error/data state, and nested keyed results without SWR or axios.
+- Reduced shared-authentication build intake and route-shell, authoring, and
+  admin fixtures prove package-neutral paths with static sibling exclusion.
+- Runtime-resource `react-i18next` receives an actionable locale-ownership
+  diagnostic rather than silently folding English or shipping i18next.
+
+### Validation
+
+- Apache Answer-derived positive and negative fixtures cover router, query,
+  layout, data, authentication, route-shell, authoring, and admin boundaries.
+- Static layout/legal/public siblings remain JavaScript-free.
+- `npm run check`, `npm test`, and `npm run test:package` pass on the release
+  worktree.
+
+### Limits
+
+This release does not claim a complete Apache Answer migration. Runtime i18n,
+rich CodeMirror ownership, upload progress, broader React Bootstrap compounds,
+plugins, AI screens, and all-route acceptance remain separate evidence gates.
+
+### Upgrade
+
+```sh
+npm install @kudzujs/core@^0.9.3
+```
+
+## 0.9.2 - Legacy CSS safety
+
+Kudzu 0.9.2 prevents pre-0.8.53 applications from silently producing an
+unstyled deploy after upgrading to route-aware CSS ownership.
+
+### Changed in 0.9.2
+
+- When no route imports CSS and `kudzu.config styles` is empty, source CSS is
+  linked globally in deterministic path order using the legacy behavior.
+- The build prints an actionable warning directing applications to explicit
+  source imports or global configuration.
+- Projects with any explicit CSS ownership retain unchanged route-aware output;
+  the fallback adds no browser JavaScript or explicit-path build work.
+
+### Validation
+
+- A two-route legacy fixture emits both unimported styles on both routes in path
+  order and keeps both routes JavaScript-free.
+- Configured global styles and explicit source-style tests retain their existing
+  output.
+- `npm run check`, `npm test`, and `npm run test:package` pass with 254 tests.
+
+### Upgrade
+
+```sh
+npm install @kudzujs/core@^0.9.2
+```
+
 ## 0.9.1 - Positional primitive lists
 
 Kudzu 0.9.1 allows JSON-safe primitive values in lists keyed by their authored

package/docs/next-architecture/1.0-large-application-compatibility-audit.md

@@ -0,0 +1,370 @@
+# Kudzu 1.0 Large-Application Compatibility Audit
+
+## Status
+
+This 2026-08-21 local discovery audit measures source compatibility after
+`0.9.0`; it does not authorize a new runtime, replace the 1.0 AI delivery
+protocol, or claim whole-application migration success. The probes used Kudzu
+`0.9.2` at `f69722032a3790dfb13151e17e1ab0f60c8280d3` on Node 24.14.0.
+Original repositories and Kudzu remained unchanged.
+
+The result is a compatibility gap: Kudzu builds reduced public slices from all
+three applications, but meaningful source retention is too low for a React-like
+large-application migration claim.
+
+## Pinned Applications
+
+| Application | Revision | License | Frontend scope | Original build |
+|---|---|---|---:|---|
+| [Memos](https://github.com/usememos/memos) | `e5ed6e7ec60e141d6e354f3ab59906c2c47dccac` | MIT | 393 TS/TSX modules, 43,099 LOC, 19 leaf routes | Pass: 5,089 modules, 292 files |
+| [Apache Answer](https://github.com/apache/answer) | `3b9f1370612e690a0b7f230f05e688930db4c6d3` | Apache-2.0 | 377 TS/TSX modules, 48,091 LOC, 88 explicit paths | Pass: 681 files |
+| [Actual Budget](https://github.com/actualbudget/actual) | `87e33e49eb4d666c33e0c0f172faf340d1b7aa0a` | MIT | sparse desktop client: 810 TS/TSX modules, 163,344 LOC, 80 route declarations | Not established: acquisition lacks workspace tooling and core packages |
+
+The Actual Budget result is diagnostic only. Its sparse checkout contains the
+selected desktop components but not the component library, core backend, Yarn
+release, database, worker coordinator, or spreadsheet implementation.
+
+The migrated adapters, copied source, detailed diagnostic logs, and line-diff
+inputs remain local under `/tmp/opencode/kudzu-large-apps`; they are not durable
+tracked evidence. The pinned upstream commits and original build commands are
+reproducible, but retention and migrated-output values remain discovery results
+until an external fixture repository pins the adapters and acceptance harness.
+
+## Migration Results
+
+### Memos
+
+The probe selected `/about`, `/explore`, and `/auth` from the real route and
+component closures. The reduced Kudzu app builds three pages and one interactive
+page. `/about` and `/explore` emit zero JavaScript; `/auth` emits 12,374 raw /
+5,956 gzip bytes of route JavaScript.
+
+| Measure | Result |
+|---|---:|
+| Direct corresponding source retained | 163 / 640 lines (25.5%) |
+| Retention including omitted feed/auth closure | 163 / 996 lines (16.4%) |
+| Final migrated TS/TSX | 12 files, 408 LOC |
+| Deploy | 14 files |
+
+The passing output is not behavior-equivalent. Live instance data, Connect RPC,
+TanStack Query, pagination, privacy filtering, markdown, reactions, SSE refresh,
+authentication, token storage, SSO discovery, and post-auth navigation are
+absent. The public feed is a build-known snapshot.
+
+### Apache Answer
+
+The probe selected questions list/detail and tags list/detail. It preserves all
+six selected component roles, but replaces the browser router, React Bootstrap,
+i18next, SWR/axios, Zustand-backed globals, guards, and live API data. Four Kudzu
+pages build; the questions list is zero JavaScript and the tags list uses the
+existing keyed-filter capabilities.
+
+| Measure | Result |
+|---|---:|
+| Exact selected source retained | 22 / 1,103 lines (2.0%) |
+| Final migrated TS/TSX | 8 files, 257 LOC |
+| Deploy | 17 files, 48,389 raw bytes |
+| JavaScript | 33,384 raw / 13,641 gzip bytes |
+
+The result has no Answer API, auth, mutations, loading/error state, pagination,
+editor, cache invalidation, or route guards. Runtime detail paths render one
+representative snapshot rather than the requested entity.
+
+### Actual Budget
+
+The probe selected the grouped report-table workflow and retained five imported
+component boundaries. It produces one complete static report page with 0 bytes
+of JavaScript.
+
+| Measure | Result |
+|---|---:|
+| Exact selected source retained | 22 / 906 lines (2.4%) |
+| Final authored probe | 268 LOC |
+| Output | 2,810 B HTML, 1,990 B CSS, 0 B JavaScript |
+
+This is an exported report, not Actual Budget. Database opening, query execution,
+spreadsheet bindings, Redux and query state, synchronization, undo, preferences,
+privacy formatting, Worker/SharedWorker ownership, synchronized scrolling, and
+transaction drill-down are absent.
+
+## Repeated Blockers
+
+| Blocker | Memos | Answer | Actual | Decision |
+|---|---|---|---|---|
+| Package components used during render | Lucide, Base UI | React Bootstrap | Actual component library, React Aria | Record separate package shapes; this broad grouping does not prove one shared semantic concept. |
+| Browser data/query ownership | TanStack Query, Connect RPC, SSE | SWR, axios | TanStack Query, worker-backed database | Define build-time snapshot and owned-effect migration contracts before considering an adapter. Do not add a query cache runtime. |
+| Router/layout semantics | RouterProvider, guards, lazy routes | nested guarded routes, outlets, `useMatch` | React Router screens and drill-down state | Keep native/file routing as the default; inventory nested layout and guard source shapes separately. |
+| Provider/global state | auth, instance, view/filter contexts | Zustand site/session/UI stores | Redux, preferences, non-serializable state | Continue package-neutral action/state reductions only from executable behavior fixtures. |
+| Localization and formatting | i18next | i18next | i18next, locale/currency/privacy preferences | Prefer build-known locale routes; browser-switchable locale ownership needs independent evidence. |
+| Dynamic presentation | markdown/editor/media/map | editor, Markdown, package widgets | grids, charts, spreadsheets | Treat imperative leaves and package adapters independently; no generic component runtime. |
+
+These broad blocker families recur, but they do not establish one shared missing
+semantic concept. Each package, query/data, router/layout, provider, localization,
+or imperative-leaf shape still needs an independent executable reduction before
+architecture review. Fixture count does not authorize a semantic primitive. The
+first implementation must stop at native behavior, existing semantics,
+normalization, or a bounded internal adapter before considering kernel growth.
+
+## Compatibility Conclusion
+
+Kudzu `0.9.2` supports large output and selected ordinary TSX, but not low-change
+migration of these large React applications. The reported retention denominators
+are not directly comparable: Memos includes an omitted feed/auth closure, Answer
+counts six selected modules, and Actual counts five retained component files from
+an incomplete sparse checkout. Every method still reports substantial rewriting.
+
+Current viable use is narrower:
+
+- static public pages and build-known read-only exports;
+- bounded forms and keyed interactions that already match Kudzu ownership;
+- separately accepted imperative leaves owned by effects;
+- native navigation to an existing application for unsupported workflows.
+
+Do not describe Memos, Answer, or Actual Budget as migrated applications. The
+passing probes are reductions that identify compatibility work.
+
+## Authorized Handoff
+
+The authoritative next milestone remains the equal-condition 1.0 AI delivery
+protocol in `0.9-implementation-plan.md`; this audit is candidate-selection input
+only. If that protocol selects an Apache Answer task, its first unsupported source
+shape is `useMatch` in the questions route. The implementation process must:
+
+1. preserve that exact failing source and reduce only the first unsupported shape;
+2. identify existing IR producers, consumers, ownership, nearby rejected forms,
+   and expected browser-byte impact before editing the compiler;
+3. run behavior and accessibility acceptance rather than build checks alone;
+4. report source retention as a diagnostic with an explicit denominator, not an
+   unapproved pass threshold;
+5. keep package-component, query/data, router/layout, localization, and provider
+   work as separate evidence packets.
+
+Combining these blockers into one compatibility runtime is not approved.
+
+## First Reduction Completion
+
+The user selected the Apache Answer routing probe under the authorized protocol.
+The first unsupported source shape, direct `const isIndexPage = useMatch("/")`,
+now lowers through the existing router normalization pass to one compiler-internal
+build-time route comparison. The same relative `Questions` component renders the
+Answer title at `/` and the Questions title at `/questions`.
+
+| Measure | Result |
+|---|---:|
+| Upstream-derived positive fixtures | 1 |
+| Nearby negative fixtures | 2 |
+| Semantic primitives | 0 |
+| ModuleIR/RouteIR records | 0 |
+| Compiler passes | 0 new |
+| Browser runtime concepts | 0 |
+| Browser JavaScript | 0 B on both routes |
+
+The producer is `compiler/router-pass.mjs`; the only consumer is a build-time
+helper in `core.mjs` reading the invocation's application route. No SPA router,
+path matcher, route signal, state, effect, handler, or browser module is added.
+Layout and runtime-parameter use fail before output; dynamic patterns and
+parameterized/wildcard/query/hash/trailing-slash forms fail with source
+diagnostics. Matching follows React Router's default case-insensitive behavior.
+Broader nested layouts, guards, outlets, and dynamic matching remain separate
+evidence packets.
+
+## Second Reduction Completion
+
+The next repeated Apache Answer blocker, direct
+`const curPage = Number(urlSearchParams.get("page")) || 1`, now separates the
+nullable query signal into a compiler-owned local and reuses the existing pure
+primitive binding evaluator. Query removal through `popstate` restores the
+finite authored fallback.
+
+| Measure | Result |
+|---|---:|
+| Upstream-derived positive fixtures | 1 |
+| Nearby negative fixtures | 1 |
+| Semantic primitives | 0 |
+| ModuleIR/RouteIR records | 0 |
+| Existing core files changed | 3 |
+| Core LOC delta | +39 |
+| Compiler passes | 0 new |
+| Browser runtime concepts | 0 |
+| Raw browser ESM | 11,211 B |
+| Build benchmark delta | Not measured; route-local compatibility slice |
+
+The producer remains `compiler/router-pass.mjs`; generic reactive-local
+substitution and binding consumers handle the result. `param-codegen.mjs` now
+applies its existing `popstate` synchronization to read-only query routes as
+well as writable routes. `Math.max`, `parseInt`, dynamic names, aliases, and
+other composed query expressions remain unsupported pending independent source
+evidence.
+
+## Third Reduction Completion
+
+Apache Answer's adjacent
+`(urlSearchParams.get("order") || QUESTION_ORDER_KEYS[0]) as QuestionOrderBy`
+now follows the same compiler-owned query signal path. The fallback is accepted
+only when it is a static numeric element of a named relative JSON-safe immutable
+array. The selected string is folded before binding/effect analysis, so the
+browser handler retains neither the array nor its source module.
+
+| Measure | Result |
+|---|---:|
+| Upstream-derived positive fixtures | 1 |
+| Nearby negative fixtures | 1 |
+| Semantic primitives | 0 |
+| ModuleIR/RouteIR records | 0 |
+| Existing core files changed | 2 |
+| Core LOC delta | +7 |
+| Compiler passes | 0 new |
+| Browser runtime concepts | 0 |
+| Raw browser ESM | 11,210 B |
+| Build benchmark delta | Not measured; route-local compatibility slice |
+
+Static output uses `newest`, `?order=active` updates both the attribute and text,
+and query removal through `popstate` restores `newest`. Dynamic indexes, local
+fallback arrays, package imports, calls, and arbitrary expressions remain
+unsupported.
+
+## Fourth Reduction Completion
+
+Apache Answer's Questions page uses React Bootstrap `Row` and `Col` only as
+declarative layout wrappers with static classes and children. The existing React
+migration normalization pass now erases those named package imports and emits
+native `div.row` and `div.col` markup. Bootstrap CSS remains an ordinary
+application stylesheet dependency rather than a Kudzu runtime.
+
+| Measure | Result |
+|---|---:|
+| Upstream-derived positive fixtures | 1 |
+| Nearby negative fixtures | 1 |
+| Semantic primitives | 0 |
+| ModuleIR/RouteIR records | 0 |
+| Existing core files changed | 1 |
+| Core LOC delta | +48 |
+| Compiler passes | 0 new |
+| Browser runtime concepts | 0 |
+| Browser JavaScript | 0 B |
+| Build benchmark delta | Not measured; static normalization slice |
+
+The generated document preserves the Questions heading, complementary sidebar,
+children order, and Bootstrap class contract without scripts or behavior
+markers. Breakpoint/grid props such as `md={6}`, dynamic classes, spreads,
+subpath/default/namespace imports, and other React Bootstrap components remain
+unsupported.
+
+## Runtime Translation Boundary
+
+Apache Answer's next Questions-page failure is `react-i18next`
+`useTranslation()`. Its values are not build-known: initialization uses the
+repository's English YAML fallback, while storage and server responses can add
+or replace the active resource bundle. Folding English would lose behavior and
+shipping i18next would add a forbidden package runtime.
+
+Kudzu now reports that boundary at the hook reference and directs migration to
+the existing static-locale treatment: `getStaticPaths()` plus locale props when
+resources are build-known, or an owned browser effect when selection only exists
+in the browser. This diagnostic adds no semantic primitive, pass, runtime
+concept, browser byte, or successful migration claim.
+
+The following Questions-page store reads are not the same reduced Zustand shape:
+`loggedUserInfoStore`, `siteInfoStore`, and `loginSettingStore` own multiple data
+fields, server-fed replacement actions, and storage side effects. Their values
+are not build-known and cannot be preserved by folding initial literals. They
+remain an application data-ownership migration packet; this audit does not
+authorize a Zustand runtime or broaden `SharedStateIR` around one application's
+store graph.
+
+## Fifth Reduction Completion
+
+Apache Answer's `useQuestionList()` and `useQuestionRecommendList()` wrappers
+compose SWR, axios, and `qs` around browser-only data. The executable reduction
+keeps the Questions page's URL-derived page/order semantics but moves ownership
+to one native fetch effect with application-owned loading, error, and keyed data
+state. The existing dependency replacement contract prevents a delayed old
+response from overwriting a newer query.
+
+| Measure | Result |
+|---|---:|
+| Upstream-derived positive fixtures | 1 |
+| Static exclusion fixtures | 1 |
+| Semantic primitives | 0 |
+| ModuleIR/RouteIR records | 0 new |
+| Existing core files changed | 2 |
+| Core LOC delta | +6 |
+| Compiler passes | 0 new |
+| Browser runtime concepts | 0 new |
+| Raw interactive browser ESM | 32,005 B |
+| Static sibling JavaScript | 0 B |
+| Build benchmark delta | Not measured; browser-data compatibility slice |
+
+Chrome acceptance starts from `?page=2&order=active`, replaces it with the
+recommendation endpoint, rejects the delayed stale response, renders nested
+keyed tags, reports HTTP 500 through `role="alert"`, and recovers on the next
+query. SWR, axios, `qs`, caches, Providers, retries, deduplication, and background
+refetch remain absent. The only compiler adjustment folds the already validated
+imported immutable string fallback before generic effect dependency analysis.
+
+## Sixth Reduction Completion
+
+The full Answer source contains 94 direct `Col` elements; 63 use only static
+numeric spans across `xs`, `sm`, `md`, `lg`, `xl`, and `xxl`. The existing React
+Bootstrap normalization now maps integer literals 1 through 12 to native
+Bootstrap classes, omits bare `col` when spans exist, and preserves static
+authored classes. All 98 observed breakpoint props fit this shape.
+
+| Measure | Result |
+|---|---:|
+| Upstream-derived positive fixtures | 1 |
+| Nearby negative fixtures | 1 |
+| Observed Col sites covered | 63 / 94 |
+| Semantic primitives | 0 |
+| ModuleIR/RouteIR records | 0 |
+| Existing core files changed | 1 |
+| Core LOC delta | +14 |
+| Compiler passes | 0 new |
+| Browser runtime concepts | 0 |
+| Browser JavaScript | 0 B |
+| Build benchmark delta | Not measured; static normalization slice |
+
+Chrome is unnecessary for this static mapping: emitted HTML exactly carries
+`col-md-6`, multi-breakpoint login classes, and the five-span tag grid without
+scripts or behavior markers. Dynamic, boolean, object, offset/order, style,
+spread, and polymorphic forms remain separate evidence packets.
+
+## Seventh Reduction Intake
+
+The first authentication fixture now builds one layout-owned session record from
+the Answer login/current-user/401 shapes. Native `FormData`, token storage,
+current-user fetch, shared header/settings reads, clear, and replacement
+navigation compile without Zustand, axios, React Router, or React in output; a
+public sibling remains static. One compiler correction prevents shared-state
+identifiers such as `session.token` from being misclassified as imported
+calculation results during effect dependency analysis. This adds no IR kind,
+pass, or runtime concept. Browser login/reload/401 acceptance remains required
+before this intake can be marked a completed authentication reduction.
+
+## Route Shell Intake
+
+The first route-shell fixture builds seven representative Answer paths: home,
+questions, runtime question detail, tags, runtime tag detail, admin dashboard,
+and legal. `Layout`/`SideNavLayout` become one ordinary composed shell, links are
+native anchors, and bracket pages reuse the existing pathname reader and rewrite
+metadata. No RouterProvider, Outlet, SPA router, semantic primitive, pass, or new
+runtime concept is added; the legal sibling remains zero-JavaScript. Expanding
+the same manifest/composition treatment across all 88 upstream paths remains the
+next route migration gate.
+
+Chrome acceptance directly enters `/questions/42/example-question`, verifies
+both runtime pathname fields and the composed primary/section navigation, then
+performs native document navigation to `/tags/kudzu` and verifies the tag field
+in the destination document. No hydration or browser router participates.
+
+## Authoring And Admin Intake
+
+A backend-independent Answer authoring/admin fixture now builds three routes.
+Question creation uses native constraints, `FormData`, a controlled markdown
+textarea, file text import, preview, and browser-owned persistence. The admin
+route restores that data into a keyed table and deletes rows through existing
+list and handler semantics. React Hook Form, CodeMirror, axios, Zustand, and
+React are absent from deploy handlers, and the legal sibling remains static.
+This intake adds no compiler or runtime concept; rich editor lifecycle, server
+validation, upload progress, dialogs, and complete admin browser journeys remain
+separate gates.

package/docs/next-architecture/README.md

@@ -13,6 +13,8 @@ The top-level [`GOAL_A.md`](../../GOAL_A.md) and [`GOAL_B.md`](../../GOAL_B.md)
 
 The completed `0.9.0` milestone is recorded in [`0.9-semantic-compression.md`](./0.9-semantic-compression.md) and [`0.9-implementation-plan.md`](./0.9-implementation-plan.md). It freezes the `0.8.62` baseline, then closes evidence-backed work on Derived, shared state/actions, resource ownership, component ownership, pass reduction, and final cross-framework proof. [`large-application-ai-native-roadmap.md`](./large-application-ai-native-roadmap.md) remains the completed foundation and longer-term plan. Model-driven delivery is separately gated for 1.0. ResourceIR remains unapproved; range ownership, virtualization, optimistic transactions, public adapters, and generic runtimes still require independent evidence and architecture review.
 
+[`1.0-large-application-compatibility-audit.md`](./1.0-large-application-compatibility-audit.md) records the first post-0.9 probes against Memos, Apache Answer, and Actual Budget. The audit finds that reduced slices build but whole-application source retention and behavior parity do not yet pass.
+
 ## Required Invariants
 
 - Every route remains a complete static HTML document.
@@ -29,19 +31,20 @@ The completed `0.9.0` milestone is recorded in [`0.9-semantic-compression.md`](.
 2. [`0.9-implementation-plan.md`](./0.9-implementation-plan.md): detailed session packets, benchmark plan, reports, and release procedure.
 3. [`0.9-baseline.md`](./0.9-baseline.md): dated architecture, pass, IR, runtime-concept, LOC, and test baseline.
 4. [`0.9-benchmark-contracts.md`](./0.9-benchmark-contracts.md): frozen matched-content, stateful, commerce, scale, resource, and anti-gaming contracts.
-5. [`compiler-current-architecture.md`](./compiler-current-architecture.md): exact current responsibilities and data flow.
-6. [`performance-gates.md`](./performance-gates.md): output, build, and browser gates.
-7. [`large-application-ai-native-roadmap.md`](./large-application-ai-native-roadmap.md): completed foundation, longer-term direction, and completion evidence.
-8. [`goal-a-compiler-foundation.md`](./goal-a-compiler-foundation.md): completed extraction and generator foundation.
-9. [`versioning.md`](./versioning.md): completed patch sequence and future sequencing rules.
-10. [`goal-b-optimization-benchmarks.md`](./goal-b-optimization-benchmarks.md): active measurements, retained optimizations, and continuation rules.
-11. [`goal-c-state-resource-research.md`](./goal-c-state-resource-research.md): research boundary only.
-12. [`goal-d-routing-compatibility-decisions.md`](./goal-d-routing-compatibility-decisions.md): routing and islands decisions.
+5. [`1.0-large-application-compatibility-audit.md`](./1.0-large-application-compatibility-audit.md): local large-application migration probes, retention caveats, blockers, and authorized-protocol handoff.
+6. [`compiler-current-architecture.md`](./compiler-current-architecture.md): exact current responsibilities and data flow.
+7. [`performance-gates.md`](./performance-gates.md): output, build, and browser gates.
+8. [`large-application-ai-native-roadmap.md`](./large-application-ai-native-roadmap.md): completed foundation, longer-term direction, and completion evidence.
+9. [`goal-a-compiler-foundation.md`](./goal-a-compiler-foundation.md): completed extraction and generator foundation.
+10. [`versioning.md`](./versioning.md): completed patch sequence and future sequencing rules.
+11. [`goal-b-optimization-benchmarks.md`](./goal-b-optimization-benchmarks.md): active measurements, retained optimizations, and continuation rules.
+12. [`goal-c-state-resource-research.md`](./goal-c-state-resource-research.md): research boundary only.
+13. [`goal-d-routing-compatibility-decisions.md`](./goal-d-routing-compatibility-decisions.md): routing and islands decisions.
 
 ## Resume Checklist
 
 - [ ] Read [`MIGRATION_ROADMAP.md`](../../MIGRATION_ROADMAP.md), [`0.9-semantic-compression.md`](./0.9-semantic-compression.md), and [`0.9-implementation-plan.md`](./0.9-implementation-plan.md) before planning migration work.
-- [ ] Follow the first evidence-ready incomplete item in the 0.9 ordered queue; update it before broadening or reordering a patch.
+- [ ] Follow the authorized 1.0 AI delivery protocol; treat post-0.9 compatibility audits as candidate-selection input, not replacement work queues.
 - [ ] Confirm `package.json` still reports the actual current version; never infer release status from this plan.
 - [ ] Inspect the worktree and preserve unrelated or uncommitted changes.
 - [ ] Start later architecture work only by an explicit decision from the completed Goal A baseline.

package/docs/next-architecture/goal-d-routing-compatibility-decisions.md

@@ -12,6 +12,7 @@ Supported React Router-shaped migration remains narrow:
 
 - static root-relative `Link` lowers to a base-prefixed native `<a>`;
 - bracket runtime routes may lower direct `useParams()` to the pathname reader;
+- route-owned exact static root-relative `useMatch()` bindings fold case-insensitively from the build-known application route;
 - top-level direct `useSearchParams()` reads/writes lower to URL signals and native history;
 - direct nested `useNavigate()` calls lower to native `location.assign()` or `location.replace()`;
 - no React Router package executes in build output or the browser.

package/framework/README.md

@@ -10,7 +10,7 @@ Native platform work remains ordinary source. A direct async handler or directly
 
 Imperative canvas migrations use the same effect ownership rather than a component or canvas runtime. One `null`-initialized canvas DOM ref may feed an inline effect whose local variables persist across a recursive animation-frame callback, an `IntersectionObserver`, and native canvas/window listeners; the returned cleanup must cancel the latest frame, disconnect the observer, and remove every listener. Bare `IntersectionObserver` and `performance` identifiers remain browser globals in emitted effect ESM. Component-level mutable value refs and callbacks shared across effects or JSX handlers remain unsupported; move resource-private state and listeners into the owning effect.
 
-Localized static migrations do not need a package router. `getStaticPaths()` emits each build-known locale, a small relative Link replacement prefixes native hrefs from the locale prop, and an optional `/` mount effect may choose a stored locale or inspect `navigator.languages` before calling `location.replace()` with the original query and hash. This preserves automatic browser-language entry and locale-prefixed navigation; request-time `Accept-Language` negotiation still requires host or edge configuration. Build-known MDX becomes static `dangerouslySetInnerHTML`, while copy controls, tabs, and other supported interactive components remain ordinary state and handler capabilities beside that HTML.
+Localized static migrations do not need a package router. `getStaticPaths()` emits each build-known locale, a small relative Link replacement prefixes native hrefs from the locale prop, and an optional `/` mount effect may choose a stored locale or inspect `navigator.languages` before calling `location.replace()` with the original query and hash. Runtime-resource `react-i18next` `useTranslation()` calls receive a source diagnostic directing this migration instead of silently selecting one language or retaining i18next. This preserves automatic browser-language entry and locale-prefixed navigation; request-time `Accept-Language` negotiation still requires host or edge configuration. Build-known MDX becomes static `dangerouslySetInnerHTML`, while copy controls, tabs, and other supported interactive components remain ordinary state and handler capabilities beside that HTML.
 
 A top-level component local shaped exactly as `const supported = "literal" in navigator` may control one direct `supported && <Branch />` JSX site. Kudzu emits the branch as false static fallback, evaluates the browser capability once through an existing mount effect, and uses existing state-conditional ownership to mount its DOM and handlers only when supported. The value cannot escape or feed aliases, composed expressions, ternaries, dynamic properties, `canShare()`, or other browser globals.
 
@@ -20,10 +20,16 @@ A named or aliased `Link` import from `react-router-dom` may render directly wit
 
 A named or aliased React Router `useParams` import may also be called directly without runtime arguments on a bracket route exporting `runtimeParams = true`. The compiler redirects that local binding to `@kudzujs/core`, preserving one optional TypeScript type argument, and reuses the existing route-specific pathname matcher. Indirect calls and other router hooks remain unsupported. Build-known `getStaticPaths()` routes use page props instead because no browser pathname capability is needed.
 
-A named or aliased React Router `useSearchParams` import may initialize one top-level `const [params]` or `const [params, setParams]` binding. Each top-level `const value = params.get("literal")` lowers to one cached nullable `useSearchParam()` signal. New Kudzu source may call that same literal reader directly; binding nullable query values to hidden input `value` and `disabled` attributes initializes native GET form carry without a generic mount effect. Direct setter calls inside nested browser callbacks accept one synchronous inline updater over native `URLSearchParams`; no options pushes history and exactly `{ replace: true }` replaces it. The route parameter asset recommits changed query signals and follows `popstate`. Missing keys remain `null`, direct text renders blank, and nullable attributes are removed. Dynamic names, direct-value setters, other methods on the outer params object, aliases, wrapped reads, and layout ownership are rejected. Routes without query reads or writes do not emit this branch or a parameter asset.
+A named or aliased React Router `useMatch` import may directly initialize one top-level `const` from an exact static root-relative string such as `useMatch("/")` in route scope. The compiler compares it case-insensitively with the build-known application route and returns the conventional match object or `null` during rendering, then erases the router import. Reused relative components receive the route of each page invocation. Layout use, runtime-parameter pages, params, wildcards, query/hash patterns, trailing slashes, dynamic patterns, indirect calls, and pattern objects are rejected. No route matcher ships to the browser.
+
+A named or aliased React Router `useSearchParams` import may initialize one top-level `const [params]` or `const [params, setParams]` binding. Each top-level `const value = params.get("literal")` lowers to one cached nullable `useSearchParam()` signal. The exact top-level pagination form `const page = Number(params.get("literal")) || finiteNumber` and string form `const order = params.get("literal") || importedImmutableArray[staticIndex]` separate that raw signal into a compiler-owned local and reuse the existing primitive binding evaluator. The string fallback must be a static numeric element of a named relative JSON-safe immutable array. New Kudzu source may call the literal reader directly; binding nullable query values to hidden input `value` and `disabled` attributes initializes native GET form carry without a generic mount effect. Direct setter calls inside nested browser callbacks accept one synchronous inline updater over native `URLSearchParams`; no options pushes history and exactly `{ replace: true }` replaces it. The route parameter asset recommits changed query signals and follows `popstate`, including read-only routes. Missing keys remain `null`, direct text renders blank, and nullable attributes are removed. Dynamic names or indexes, direct-value setters, other methods on the outer params object, aliases, indirect reads, broader wrappers, and layout ownership are rejected. Routes without query reads or writes do not emit this branch or a parameter asset.
 
 A named or aliased React Router `useNavigate` import may initialize one top-level `const` identifier. A direct call from a nested browser callback with one safe static root-relative string lowers to `location.assign()` after applying `base`; exactly `{ replace: true }` lowers to `location.replace()`. This deliberately performs native document navigation even when enhanced navigation is configured. Dynamic or relative destinations, render-time calls, aliases passed as values, and options such as `state`, `relative`, or `preventScrollReset` are rejected. Routes without an actual navigation handler emit no browser JavaScript.
 
+Named or aliased React Bootstrap `Row` and `Col` imports may be used as direct JSX elements with children and at most one static `className`. The React migration normalization pass erases those package imports and emits native `<div>` elements. `Row` emits `row`; a `Col` without spans emits `col`, while numeric literal `xs`, `sm`, `md`, `lg`, `xl`, and `xxl` values from 1 through 12 emit Bootstrap span classes in deterministic largest-to-smallest breakpoint order. The application must keep Bootstrap CSS reachable. Boolean, object, dynamic, offset, and order grid props, dynamic classes, spreads, default/subpath/namespace imports, non-JSX references, and other React Bootstrap components are rejected or remain unsupported. This shape emits no browser JavaScript.
+
+Browser-only package-query migrations use one inline dependency effect with native `fetch()` and application-owned loading, error, and data state. Apache Answer-shaped page/order search signals may derive both effect dependencies and endpoint values; dependency replacement prevents a superseded response from writing state, while existing keyed-list ownership handles nested result rows. SWR, axios, `qs`, query clients, caches, Providers, retries, and background schedulers are not retained. Build-known reads should remain async page/component work instead.
+
 Direct `clsx` calls over literal strings, numbers, arrays, object conditions, and conditional expressions are similarly lowered to ordinary concatenation and conditional expressions. The package import is erased, and dynamic classes continue through the existing binding compiler without serializing or shipping the `clsx` function.
 
 Repeated ordinary same-file and relative-imported child components execute independently at build time, so each `useState` call receives a distinct concrete state ID while shared native handler modules retain per-element state maps and captures. A direct JSON-safe primitive parent state passed to a destructured child prop remains the same signal for child DOM bindings and effect dependencies; repeated calls own independent effect records, and conditional removal cleans up before remount recreates the effect. Reactive text and attributes may reference recursively chained top-level immutable locals derived through supported pure primitive expressions from direct state; the compiler substitutes those expressions into the existing binding evaluator and subscribes every source state. Fixed-locale `new Intl.NumberFormat("literal").format(Math.round(expression))` display chains reuse that binding ESM, while dynamic locales and options remain unsupported. Multiple direct primitive dependencies share the existing commit batching path: every value is compared with `Object.is`, and one or more same-turn changes cause one cleanup and rerun. A top-level immutable local derived through a supported pure primitive expression from direct state may also be an effect dependency: source state commits schedule evaluation, the derived result is compared with `Object.is`, and the expression is substituted into setup and cleanup handlers. Effect setup and directly returned cleanup callbacks may each resolve one top-level simple `const` function in the same component; those functions are substituted into the existing handler graph rather than retained in a browser registry. Reactive conditional descriptors own state created by their direct branch: initial visible output reuses the rendered template IDs, removal deletes those slots, and remount recreates them from serialized initial values. Static sibling routes and branches without local state add no ownership metadata, component function, hook dispatcher, or rerender loop.
@@ -47,7 +53,7 @@ Reduced Zustand migration stores lower through package-neutral `SharedStateIR` a
 - `compiler/handler-lowering.mjs`: source-local native/effect callback, reducer, Context, package-neutral shared-action, reactive-binding, and list-evaluator AST lowering before IR finalization.
 - `compiler/handler-codegen.mjs`: AST-free ordered import rendering and finalized handler/binding export-source assembly.
 - `compiler/render-control-pass.mjs`: render-function early-return and exhaustive adjacent-assignment normalization.
-- `compiler/router-pass.mjs`: React Router import validation and native Link, pathname parameter, search parameter, and imperative navigation lowering.
+- `compiler/router-pass.mjs`: React Router import validation and native Link, build-time exact match, pathname parameter, search parameter, and imperative navigation lowering.
 - `compiler/route-capability-planner.mjs`: RouteIR v1 validation and pure CapabilityIR v1 projection into runtime and artifact requirements.
 - `compiler/runtime-family-planner.mjs`: deterministic standalone capability deduplication and enhanced-navigation group unioning at the ESM singleton boundary.
 - `compiler/route-artifact-report.mjs`: deterministic per-route capability signatures and runtime requirements plus handler, Worker, stylesheet, and transitive esbuild chunk closure reporting.
@@ -80,7 +86,7 @@ Static routes receive no browser runtime. Command routes receive `runtime.js`; d
 
 Exact relative `.worker.ts` constructors in inline effects are validated and bundled in a separate content-hashed ESM graph under `dist/assets/workers/`. Those files are referenced only by rendered effect handlers and never become document capability scripts, preloads, or window imports; unreachable source effects do not emit their Worker roots. Worker graphs allow relative TypeScript ESM runtime imports only and reject JSX, package runtime imports, import-equals declarations, dynamic imports, `require()`, and paths outside `src`. Ordinary runtime imports or re-exports of `.worker.ts` and Worker construction in imported keyed-row effects are rejected.
 
-Page `metadata` can emit description, canonical, favicon, manifest, Open Graph, and Twitter Card tags without a client runtime. Relative source CSS imports follow each page's reachable TypeScript graph and link only from those routes; `kudzu.config` styles remain explicitly global. Enhanced navigation loads incoming managed styles before route replacement, reuses shared links, and removes outgoing links. All styles are emitted before `afterBuild()` runs; static stylesheet links in component JSX fail compilation instead of loading from the body.
+Page `metadata` can emit description, canonical, favicon, manifest, Open Graph, and Twitter Card tags without a client runtime. Relative source CSS imports follow each page's reachable TypeScript graph and link only from those routes; `kudzu.config` styles remain explicitly global. For pre-0.8.53 projects with source CSS but no explicit style ownership at all, Kudzu preserves the former global path-ordered output and prints a migration warning instead of silently emitting an unstyled deploy. Enhanced navigation loads incoming managed styles before route replacement, reuses shared links, and removes outgoing links. All styles are emitted before `afterBuild()` runs; static stylesheet links in component JSX fail compilation instead of loading from the body.
 
 Inline SVG rendering normalizes an explicit set of common React presentation aliases before static serialization and binding descriptor creation. Reactive aliases use the existing generic `setAttribute` path. Reactive conditionals and flat intrinsic keyed lists store inert branch or row markup on SVG markers and parse it in the actual parent namespace only when replacement nodes are needed; existing condition/list ownership then handles insertion, identity, updates, and removal. Focus, keyboard, and click handlers on keyed SVG points may update parent state for an external accessible HTML tooltip, and retained handlers read the latest item after list updates. Builds without structural SVG compile out that fragment path, and static SVG adds no JavaScript. Keyed-item conditions, nested SVG lists, MathML structures, and namespaced attributes remain unsupported.
 

package/framework/build.mjs

@@ -45,7 +45,7 @@ export async function buildWithSession(project, { changedFiles, quiet = false, m
   try {
     await recoverOutput(outputDirectory, backupOutput)
     await rm(stagedOutput, { recursive: true, force: true })
-    const { result, pageCount, behaviorCount, cache } = await buildInto(project, stagedOutput, { changedFiles, minify, retainCache })
+    const { result, pageCount, behaviorCount, cache } = await buildInto(project, stagedOutput, { changedFiles, minify, quiet, retainCache })
     await promoteOutput(stagedOutput, outputDirectory, backupOutput)
     project.buildCache = retainCache ? cache : undefined
     if (!quiet) console.log(`Built ${pageCount} page(s), ${behaviorCount} interactive page(s) into dist/`)
@@ -63,7 +63,7 @@ export async function buildWithSession(project, { changedFiles, quiet = false, m
   }
 }
 
-async function buildInto(project, outputDirectory, { changedFiles, minify, retainCache }) {
+async function buildInto(project, outputDirectory, { changedFiles, minify, quiet, retainCache }) {
   const { root, sourceDirectory, pagesDirectory, workDirectory } = project
   const previous = retainCache ? project.buildCache : undefined
   project.buildGeneration = (project.buildGeneration ?? 0) + 1
@@ -108,6 +108,14 @@ async function buildInto(project, outputDirectory, { changedFiles, minify, retai
   for (const file of sourceFiles) sourceFileSet.add(file)
   const staticFiles = await safeStaticFiles(projectFiles)
   const stylesByPage = new Map(pageFiles.map(file => [file, orderSourceStyles([file], sourceFiles, sourceIndex, staticFiles).filter(style => !configuredStyleSources.has(style))]))
+  const explicitSourceStyles = new Set([...stylesByPage.values()].flat())
+  const legacyStyles = configuredStyles.sources.length || configuredStyles.urls.length || explicitSourceStyles.size
+    ? []
+    : [...staticFiles].filter(file => file.toLowerCase().endsWith(".css")).sort()
+  if (legacyStyles.length) {
+    for (const file of pageFiles) stylesByPage.set(file, legacyStyles)
+    if (!quiet) console.warn("Kudzu: no route imports CSS and kudzu.config styles is empty; applying the legacy global CSS fallback. Import CSS from reachable source or declare config.styles for route-aware output.")
+  }
   const cssFiles = [...new Set([...stylesByPage.values()].flat())]
   const importedAssets = new Set()
   const { cssModules, cssOutputs } = await prepareSourceStyles(cssFiles, staticFiles, importedAssets, base, project)
@@ -238,6 +246,7 @@ async function buildInto(project, outputDirectory, { changedFiles, minify, retai
         styles: styleUrls.length ? styleUrls : false,
         managedStyles: navigable ? sourceStyleUrls : [],
         base,
+        applicationRoute,
         runtimeAsset: runtimePlaceholder,
         bindingAsset: bindingPlaceholder,
         listAsset: listPlaceholder,

package/framework/compiler/param-codegen.mjs

@@ -39,7 +39,7 @@ function decodeSegment(raw, param) {
   return value
 }
 ` : ""
-    const searchInitializer = searchParamsWritable && searchParams.length ? `function initializeSearch(search) {
+    const searchInitializer = searchParams.length ? `function initializeSearch(search) {
 const query = new URLSearchParams(search)
 for (const param of ${inlineJson(searchParams)}) {
   const value = query.get(param.name)
@@ -48,13 +48,7 @@ for (const param of ${inlineJson(searchParams)}) {
 }
 }
 ` : ""
-    const query = searchParams.length ? searchParamsWritable ? "initializeSearch(search)\n" : `const query = new URLSearchParams(search)
-for (const param of ${inlineJson(searchParams)}) {
-  const value = query.get(param.name)
-  browserState.set(param.id, value)
-  commitDom(param.id, value)
-}
-` : ""
+    const query = searchParams.length ? "initializeSearch(search)\n" : ""
     const writer = searchParamsWritable ? `
 function setSearchParams(update, replace) {
   const next = update(new URLSearchParams(location.search))
@@ -66,7 +60,8 @@ function setSearchParams(update, replace) {
 }
 ${navigable ? "" : `globalThis.__kSetSearchParams = setSearchParams
 addEventListener("popstate", () => ${searchParams.length ? "initializeSearch(location.search)" : "undefined"})`}` : ""
+    const reader = !navigable && !searchParamsWritable && searchParams.length ? '\naddEventListener("popstate", () => initializeSearch(location.search))' : ""
     return `import { browserState, commitDom } from ${JSON.stringify(relativeModulePath(output, join(runtimeDirectory, runtimeName)))}
-${searchInitializer}${prefix}${pathname}${query}${suffix}${writer}`
+${searchInitializer}${prefix}${pathname}${query}${suffix}${writer}${reader}`
   }
 }

package/framework/compiler/react-migration-pass.mjs

@@ -3,6 +3,68 @@ import { bindingNames, importDeclarationNames, isFunctionLike, isLocalConst, isR
 import { analyzeCollectionPipeline, isArrayFromCall } from "./collection-analysis.mjs"
 
 export function createReactMigrationPass({ cloneAst, jsxTagName }) {
+  function normalizeReactBootstrapLayout(sourceFile, factory, context) {
+    const layouts = new Map()
+    for (const statement of sourceFile.statements) {
+      if (!ts.isImportDeclaration(statement) || statement.importClause?.isTypeOnly || !ts.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== "react-bootstrap") continue
+      const clause = statement.importClause
+      if (!clause || clause.name || !clause.namedBindings || ts.isNamespaceImport(clause.namedBindings)) throw sourceNodeError(statement, sourceFile, "React Bootstrap layout migration requires named Row or Col imports")
+      for (const entry of clause.namedBindings.elements) {
+        const imported = (entry.propertyName ?? entry.name).text
+        if (!entry.isTypeOnly && ["Row", "Col"].includes(imported)) layouts.set(entry.name.text, imported.toLowerCase())
+      }
+    }
+    if (!layouts.size) return sourceFile
+
+    const layout = tag => ts.isIdentifier(tag) && layouts.has(tag.text) && !isShadowedIdentifier(tag, sourceFile) ? layouts.get(tag.text) : undefined
+    const attributes = node => {
+      let authored
+      const spans = new Map()
+      const kind = layout(node.parent.tagName)
+      const breakpoints = ["xxl", "xl", "lg", "md", "sm", "xs"]
+      for (const property of node.properties) {
+        if (ts.isJsxSpreadAttribute(property)) throw sourceNodeError(property, sourceFile, "React Bootstrap Row and Col do not support spread props during native layout lowering")
+        const name = property.name.text
+        const initializer = property.initializer
+        const value = ts.isStringLiteral(initializer) ? initializer : initializer && ts.isJsxExpression(initializer) ? unwrapExpression(initializer.expression) : undefined
+        if (name === "className") {
+          if (authored !== undefined) throw sourceNodeError(property, sourceFile, "React Bootstrap Row and Col accept className only once")
+          if (!value || !ts.isStringLiteral(value) && !ts.isNoSubstitutionTemplateLiteral(value)) throw sourceNodeError(property, sourceFile, "React Bootstrap Row and Col className must be a static string")
+          authored = value.text
+          continue
+        }
+        if (kind === "col" && breakpoints.includes(name)) {
+          const span = value && ts.isNumericLiteral(value) ? Number(value.text) : NaN
+          if (!Number.isInteger(span) || span < 1 || span > 12) throw sourceNodeError(property, sourceFile, `React Bootstrap Col breakpoint ${JSON.stringify(name)} must be an integer literal from 1 through 12`)
+          spans.set(name, span)
+          continue
+        }
+        throw sourceNodeError(property, sourceFile, `React Bootstrap Row and Col only support a static className or numeric Col breakpoint prop; found ${JSON.stringify(name)}`)
+      }
+      const generated = kind === "row" ? ["row"] : spans.size ? breakpoints.filter(name => spans.has(name)).map(name => name === "xs" ? `col-${spans.get(name)}` : `col-${name}-${spans.get(name)}`) : ["col"]
+      return factory.createJsxAttributes([factory.createJsxAttribute(factory.createIdentifier("className"), factory.createStringLiteral([...generated, authored].filter(Boolean).join(" ")))])
+    }
+    const visitor = node => {
+      if (ts.isJsxElement(node) && layout(node.openingElement.tagName)) {
+        const opening = factory.updateJsxOpeningElement(node.openingElement, factory.createIdentifier("div"), node.openingElement.typeArguments, attributes(node.openingElement.attributes))
+        const closing = factory.updateJsxClosingElement(node.closingElement, factory.createIdentifier("div"))
+        return factory.updateJsxElement(node, opening, ts.visitNodes(node.children, visitor), closing)
+      }
+      if (ts.isJsxSelfClosingElement(node) && layout(node.tagName)) return factory.updateJsxSelfClosingElement(node, factory.createIdentifier("div"), node.typeArguments, attributes(node.attributes))
+      if (ts.isIdentifier(node) && layouts.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, sourceFile)) throw sourceNodeError(node, sourceFile, "React Bootstrap Row and Col imports may only be used as direct JSX elements")
+      if (ts.isImportDeclaration(node) && !node.importClause?.isTypeOnly && ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === "react-bootstrap") {
+        const clause = node.importClause
+        const bindings = clause?.namedBindings
+        if (!clause || !bindings || !ts.isNamedImports(bindings)) return node
+        const elements = bindings.elements.filter(entry => entry.isTypeOnly || !["Row", "Col"].includes((entry.propertyName ?? entry.name).text))
+        if (!elements.length) return undefined
+        return factory.updateImportDeclaration(node, node.modifiers, factory.updateImportClause(clause, clause.isTypeOnly, undefined, factory.updateNamedImports(bindings, elements)), node.moduleSpecifier, node.attributes)
+      }
+      return ts.visitEachChild(node, visitor, context)
+    }
+    return ts.visitNode(sourceFile, visitor)
+  }
+
   function normalizeReactMigrationSyntax(sourceFile, factory, context, importedCollections = new Set()) {
     const supported = new Set(["createContext", "useContext", "useEffect", "useId", "useReducer", "useRef", "useState"])
     const erased = new Set(["createRef", "forwardRef", "memo", "useCallback", "useMemo"])
@@ -19,7 +81,7 @@ export function createReactMigrationPass({ cloneAst, jsxTagName }) {
         else if (!entry.isTypeOnly && /^use[A-Z]/.test(imported)) throw sourceNodeError(entry, sourceFile, `React ${imported} is not supported by Kudzu migration input`)
       }
     }
-    if (!aliases.size && !reactObjects.size) return sourceFile
+    if (!aliases.size && !reactObjects.size) return normalizeReactBootstrapLayout(sourceFile, factory, context)
 
     const migrationCallName = call => {
       if (ts.isIdentifier(call.expression) && aliases.has(call.expression.text) && !isShadowedIdentifier(call.expression, sourceFile)) return aliases.get(call.expression.text)
@@ -193,7 +255,7 @@ export function createReactMigrationPass({ cloneAst, jsxTagName }) {
     }
     let normalized = ts.visitNode(sourceFile, visitor)
     const missing = [...required].filter(name => !imported.has(name)).sort()
-    if (!missing.length) return normalized
+    if (!missing.length) return normalizeReactBootstrapLayout(normalized, factory, context)
     for (const name of missing) {
       const collision = sourceFile.statements.some(statement => statementDeclaresName(statement, name) || ts.isImportDeclaration(statement) && importDeclarationNames(statement).includes(name) && statement.moduleSpecifier.text !== "react")
       if (collision) throw sourceNodeError(sourceFile, sourceFile, `React.${name} cannot be normalized because ${JSON.stringify(name)} is already declared`)
@@ -203,7 +265,7 @@ export function createReactMigrationPass({ cloneAst, jsxTagName }) {
     const lastImport = statements.findLastIndex(statement => ts.isImportDeclaration(statement))
     statements.splice(lastImport + 1, 0, declaration)
     normalized = factory.updateSourceFile(normalized, statements)
-    return normalized
+    return normalizeReactBootstrapLayout(normalized, factory, context)
   }
 
   function lowerReactForwardRef(call, sourceFile, factory) {

package/framework/compiler/router-pass.mjs

@@ -2,9 +2,10 @@ import ts from "typescript"
 import { bindingNames, functionVarDeclaresName, isFunctionLike, isLocalConst, isReferenceIdentifier, isShadowedIdentifier, loopDeclaresName, nearestFunction, sourceNodeError, statementDeclaresName, unwrapExpression } from "./ast-helpers.mjs"
 
 export function createRouterPass({ withBase }) {
-  return function normalizeReactRouterSyntax(sourceFile, factory, context, base) {
+  return function normalizeReactRouterSyntax(sourceFile, factory, context, base, importedCollections = new Map()) {
     const links = new Set()
     const params = new Set()
+    const matchHooks = new Set()
     const searchHooks = new Set()
     const navigateHooks = new Set()
     for (const statement of sourceFile.statements) {
@@ -13,22 +14,62 @@ export function createRouterPass({ withBase }) {
         const clause = statement.importClause
         if (clause?.isTypeOnly) continue
         if (!clause) throw sourceNodeError(statement, sourceFile, "Side-effect React Router imports are not supported")
-        if (clause.name) throw sourceNodeError(clause.name, sourceFile, "React Router default imports are not supported; use named Link, useParams, useSearchParams, or useNavigate imports")
+        if (clause.name) throw sourceNodeError(clause.name, sourceFile, "React Router default imports are not supported; use named Link, useParams, useMatch, useSearchParams, or useNavigate imports")
         const bindings = clause.namedBindings
-        if (!bindings || ts.isNamespaceImport(bindings)) throw sourceNodeError(bindings ?? statement, sourceFile, "React Router namespace imports are not supported; use named Link, useParams, useSearchParams, or useNavigate imports")
+        if (!bindings || ts.isNamespaceImport(bindings)) throw sourceNodeError(bindings ?? statement, sourceFile, "React Router namespace imports are not supported; use named Link, useParams, useMatch, useSearchParams, or useNavigate imports")
         for (const entry of bindings.elements) {
           if (entry.isTypeOnly) continue
           const imported = (entry.propertyName ?? entry.name).text
           if (imported === "NavLink") throw sourceNodeError(entry, sourceFile, "React Router NavLink active-route semantics cannot be erased to a native anchor")
           if (imported === "Link") links.add(entry.name.text)
           else if (imported === "useParams") params.add(entry.name.text)
+          else if (imported === "useMatch") matchHooks.add(entry.name.text)
           else if (imported === "useSearchParams") searchHooks.add(entry.name.text)
           else if (imported === "useNavigate") navigateHooks.add(entry.name.text)
-          else throw sourceNodeError(entry, sourceFile, `React Router ${imported} is not supported; only named Link, useParams, useSearchParams, and useNavigate imports can be lowered`)
+          else throw sourceNodeError(entry, sourceFile, `React Router ${imported} is not supported; only named Link, useParams, useMatch, useSearchParams, and useNavigate imports can be lowered`)
         }
       }
     }
-    if (!links.size && !params.size && !searchHooks.size && !navigateHooks.size) return sourceFile
+    if (!links.size && !params.size && !matchHooks.size && !searchHooks.size && !navigateHooks.size) return sourceFile
+
+    let matchHelper = "__kUseRouteMatch"
+    while (sourceFile.text.includes(matchHelper)) matchHelper += "_"
+    const matchCalls = new Map()
+    const topLevelFunction = owner => owner.parent === sourceFile || ts.isExportAssignment(owner.parent) && owner.parent.parent === sourceFile || (ts.isArrowFunction(owner) || ts.isFunctionExpression(owner)) && ts.isVariableDeclaration(owner.parent) && owner.parent.parent?.parent?.parent === sourceFile
+    const componentFunction = owner => {
+      if (!topLevelFunction(owner)) return false
+      if (ts.isExportAssignment(owner.parent)) return true
+      if (ts.isFunctionDeclaration(owner) && owner.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.DefaultKeyword)) return true
+      const name = ts.isFunctionDeclaration(owner) ? owner.name?.text : ts.isVariableDeclaration(owner.parent) && ts.isIdentifier(owner.parent.name) ? owner.parent.name.text : undefined
+      if (!name || !/^[A-Z]/.test(name)) return false
+      let eventHandlerUse = false
+      const inspect = node => {
+        if (eventHandlerUse) return
+        if (ts.isIdentifier(node) && node.text === name && isReferenceIdentifier(node) && !isShadowedIdentifier(node, sourceFile)) {
+          for (let current = node.parent; current && current !== sourceFile; current = current.parent) {
+            if (ts.isJsxAttribute(current) && /^on[A-Z]/.test(current.name.text)) eventHandlerUse = true
+          }
+        }
+        ts.forEachChild(node, inspect)
+      }
+      inspect(sourceFile)
+      return !eventHandlerUse
+    }
+    const collectMatchHooks = node => {
+      if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && matchHooks.has(node.expression.text) && !isShadowedIdentifier(node.expression, sourceFile)) {
+        const declaration = node.parent
+        const statement = declaration?.parent?.parent
+        const owner = nearestFunction(node)
+        if (node.questionDotToken || node.typeArguments?.length || node.arguments.length !== 1 || !ts.isStringLiteral(node.arguments[0]) || !ts.isVariableDeclaration(declaration) || declaration.initializer !== node || !ts.isIdentifier(declaration.name) || !isLocalConst(declaration) || !owner || !componentFunction(owner) || statement?.parent !== owner.body) {
+          throw sourceNodeError(node, sourceFile, 'React Router useMatch must directly initialize one top-level const from one static root-relative pattern such as useMatch("/")')
+        }
+        const pattern = node.arguments[0].text
+        if (!pattern.startsWith("/") || pattern.startsWith("//") || pattern !== "/" && pattern.endsWith("/") || /[:*?#\\\0]/.test(pattern)) throw sourceNodeError(node.arguments[0], sourceFile, 'React Router useMatch only supports an exact static root-relative pattern without params, wildcards, query, hash, or a trailing slash')
+        matchCalls.set(node, pattern)
+      }
+      ts.forEachChild(node, collectMatchHooks)
+    }
+    collectMatchHooks(sourceFile)
 
     let searchHelper = "__kUseSearchParam"
     while (sourceFile.text.includes(searchHelper)) searchHelper += "_"
@@ -36,8 +77,18 @@ export function createRouterPass({ withBase }) {
     while (sourceFile.text.includes(searchWriterHelper)) searchWriterHelper += "_"
     const searchDeclarations = new Set()
     const searchReads = new Map()
+    const searchFallbackValues = new Map()
+    const composedSearchDeclarations = new Map()
+    const composedSearchCalls = new Map()
     const searchWrites = new Map()
     const searchObjects = []
+    let composedSearchIndex = 0
+    const composedSearchName = () => {
+      let name
+      do name = `__kRouterSearchParam${composedSearchIndex++ || ""}`
+      while (sourceFile.text.includes(name) || [...composedSearchCalls.values()].includes(name))
+      return name
+    }
     const collectSearchHooks = node => {
       if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && searchHooks.has(node.expression.text) && !isShadowedIdentifier(node.expression, sourceFile)) {
         const declaration = node.parent
@@ -71,15 +122,38 @@ export function createRouterPass({ withBase }) {
           if (entry.setter && ts.isCallExpression(node.parent) && node.parent.arguments.includes(node) && ts.isIdentifier(node.parent.expression) && node.parent.expression.text === entry.setter) return
           const property = node.parent
           const call = property?.parent
-          const declaration = call?.parent
+          const directDeclaration = call?.parent
+          const numberCall = directDeclaration && ts.isCallExpression(directDeclaration) && ts.isIdentifier(directDeclaration.expression) && directDeclaration.expression.text === "Number" && !isShadowedIdentifier(directDeclaration.expression, sourceFile) && directDeclaration.arguments.length === 1 && directDeclaration.arguments[0] === call && !directDeclaration.questionDotToken && !directDeclaration.typeArguments?.length ? directDeclaration : undefined
+          const binary = numberCall?.parent ?? directDeclaration
+          const numericRight = binary?.right
+          const numericValue = numericRight && ts.isNumericLiteral(numericRight) ? Number(numericRight.text) : numericRight && ts.isPrefixUnaryExpression(numericRight) && [ts.SyntaxKind.PlusToken, ts.SyntaxKind.MinusToken].includes(numericRight.operator) && ts.isNumericLiteral(numericRight.operand) ? Number(numericRight.getText(sourceFile)) : NaN
+          const numericFallback = numberCall && ts.isBinaryExpression(binary) && binary.left === numberCall && binary.operatorToken.kind === ts.SyntaxKind.BarBarToken && Number.isFinite(numericValue) ? binary : undefined
+          const importedValue = !numberCall && ts.isBinaryExpression(binary) && binary.left === call && binary.operatorToken.kind === ts.SyntaxKind.BarBarToken ? binary.right : undefined
+          const importedCollection = importedValue && ts.isElementAccessExpression(importedValue) && !importedValue.questionDotToken && ts.isIdentifier(importedValue.expression) && ts.isNumericLiteral(importedValue.argumentExpression) ? importedCollections.get(importedValue.expression.text) : undefined
+          const importedIndex = importedValue && ts.isElementAccessExpression(importedValue) && ts.isNumericLiteral(importedValue.argumentExpression) ? Number(importedValue.argumentExpression.text) : undefined
+          const importedElement = importedCollection && Number.isSafeInteger(importedIndex) ? importedCollection.elements[importedIndex] : undefined
+          const importedString = importedElement && unwrapExpression(importedElement)
+          const importedFallback = importedString && (ts.isStringLiteral(importedString) || ts.isNoSubstitutionTemplateLiteral(importedString)) ? binary : undefined
+          const fallback = numericFallback ?? importedFallback
+          let composedInitializer = fallback
+          while (composedInitializer?.parent && (ts.isParenthesizedExpression(composedInitializer.parent) || ts.isAsExpression(composedInitializer.parent) || ts.isTypeAssertionExpression(composedInitializer.parent) || ts.isSatisfiesExpression(composedInitializer.parent) || ts.isNonNullExpression(composedInitializer.parent)) && composedInitializer.parent.expression === composedInitializer) composedInitializer = composedInitializer.parent
+          const composedDeclaration = composedInitializer?.parent
+          const declaration = directDeclaration && ts.isVariableDeclaration(directDeclaration) ? directDeclaration : composedDeclaration && ts.isVariableDeclaration(composedDeclaration) ? composedDeclaration : undefined
           const statement = declaration?.parent?.parent
           if (!ts.isPropertyAccessExpression(property) || property.expression !== node || property.name.text !== "get" || !ts.isCallExpression(call) || call.expression !== property || call.questionDotToken || call.typeArguments?.length || call.arguments.length !== 1 || !ts.isStringLiteral(call.arguments[0])) {
             throw sourceNodeError(node, sourceFile, 'React Router search parameters only support direct get("static-name") reads')
           }
-          if (!ts.isVariableDeclaration(declaration) || declaration.initializer !== call || !ts.isIdentifier(declaration.name) || !isLocalConst(declaration) || statement?.parent !== entry.owner.body) {
-            throw sourceNodeError(call, sourceFile, "React Router search parameter get() must directly initialize one top-level const identifier")
+          if (!declaration || declaration.initializer !== call && declaration.initializer !== composedInitializer || !ts.isIdentifier(declaration.name) || !isLocalConst(declaration) || statement?.parent !== entry.owner.body) {
+            throw sourceNodeError(call, sourceFile, 'React Router search parameter get() must directly initialize one top-level const, appear as Number(params.get("name")) || finiteNumber, or use params.get("name") || importedArray[staticIndex]')
           }
+          if (fallback && declaration.parent.declarations.length !== 1) throw sourceNodeError(declaration, sourceFile, "React Router composed search parameter reads require their own top-level const statement")
           searchReads.set(call, call.arguments[0])
+          if (importedValue && importedFallback) searchFallbackValues.set(importedValue, importedString.text)
+          if (fallback) {
+            const name = composedSearchName()
+            composedSearchDeclarations.set(declaration, { call, name })
+            composedSearchCalls.set(call, name)
+          }
           return
         }
         ts.forEachChild(node, collectReads)
@@ -185,6 +259,17 @@ export function createRouterPass({ withBase }) {
     }
     const importedLink = tag => ts.isIdentifier(tag) && links.has(tag.text) && !isShadowedIdentifier(tag, sourceFile)
     const visitor = node => {
+      if (searchFallbackValues.has(node)) return factory.createStringLiteral(searchFallbackValues.get(node))
+      if (ts.isVariableStatement(node) && node.declarationList.declarations.length === 1) {
+        const declaration = node.declarationList.declarations[0]
+        const composed = composedSearchDeclarations.get(declaration)
+        if (composed) {
+          const raw = factory.createVariableStatement(undefined, factory.createVariableDeclarationList([
+            factory.createVariableDeclaration(composed.name, undefined, undefined, factory.createCallExpression(factory.createIdentifier(searchHelper), undefined, [searchReads.get(composed.call)]))
+          ], ts.NodeFlags.Const))
+          return [raw, ts.visitEachChild(node, visitor, context)]
+        }
+      }
       if (ts.isVariableStatement(node) && node.declarationList.declarations.some(declaration => searchDeclarations.has(declaration) || navigateDeclarations.has(declaration))) {
         const declarations = node.declarationList.declarations.flatMap(declaration => {
           if (navigateDeclarations.has(declaration)) return []
@@ -196,7 +281,7 @@ export function createRouterPass({ withBase }) {
         if (!declarations.length) return undefined
         return factory.updateVariableStatement(node, node.modifiers, factory.updateVariableDeclarationList(node.declarationList, declarations))
       }
-      if (ts.isCallExpression(node) && searchReads.has(node)) return factory.createCallExpression(factory.createIdentifier(searchHelper), undefined, [searchReads.get(node)])
+      if (ts.isCallExpression(node) && searchReads.has(node)) return composedSearchCalls.has(node) ? factory.createIdentifier(composedSearchCalls.get(node)) : factory.createCallExpression(factory.createIdentifier(searchHelper), undefined, [searchReads.get(node)])
       if (ts.isCallExpression(node) && searchWrites.has(node)) {
         const { updater, replace } = searchWrites.get(node)
         return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("globalThis"), "__kSetSearchParams"), undefined, [ts.visitNode(updater, visitor), replace ? factory.createTrue() : factory.createFalse()])
@@ -205,6 +290,7 @@ export function createRouterPass({ withBase }) {
         const { method, destination } = navigateCalls.get(node)
         return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createPropertyAccessExpression(factory.createIdentifier("globalThis"), "location"), method), undefined, [factory.createStringLiteral(destination)])
       }
+      if (ts.isCallExpression(node) && matchCalls.has(node)) return factory.createCallExpression(factory.createIdentifier(matchHelper), undefined, [factory.createStringLiteral(matchCalls.get(node))])
       if (ts.isJsxElement(node) && importedLink(node.openingElement.tagName)) {
         const opening = factory.updateJsxOpeningElement(node.openingElement, factory.createIdentifier("a"), node.openingElement.typeArguments, attributes(node.openingElement.attributes))
         const closing = factory.updateJsxClosingElement(node.closingElement, factory.createIdentifier("a"))
@@ -217,6 +303,7 @@ export function createRouterPass({ withBase }) {
       }
       if (ts.isIdentifier(node) && links.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, sourceFile)) throw sourceNodeError(node, sourceFile, "React Router Link imports may only be used as direct JSX elements")
       if (ts.isIdentifier(node) && params.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, sourceFile)) throw sourceNodeError(node, sourceFile, "React Router useParams imports may only be called directly")
+      if (ts.isIdentifier(node) && matchHooks.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, sourceFile)) throw sourceNodeError(node, sourceFile, "React Router useMatch imports may only initialize the supported top-level const binding")
       if (ts.isIdentifier(node) && searchHooks.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, sourceFile)) throw sourceNodeError(node, sourceFile, "React Router useSearchParams imports may only initialize the supported top-level tuple binding")
       if (ts.isIdentifier(node) && navigateHooks.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, sourceFile)) throw sourceNodeError(node, sourceFile, "React Router useNavigate imports may only initialize the supported top-level navigate binding")
       if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === "react-router-dom") {
@@ -224,16 +311,17 @@ export function createRouterPass({ withBase }) {
         if (!clause || clause.isTypeOnly) return node
         const bindings = clause.namedBindings
         if (!bindings || !ts.isNamedImports(bindings)) return node
-        const elements = bindings.elements.filter(entry => entry.isTypeOnly || !["Link", "useParams", "useSearchParams", "useNavigate"].includes((entry.propertyName ?? entry.name).text))
+        const elements = bindings.elements.filter(entry => entry.isTypeOnly || !["Link", "useParams", "useMatch", "useSearchParams", "useNavigate"].includes((entry.propertyName ?? entry.name).text))
         if (!elements.length) return undefined
         return factory.updateImportDeclaration(node, node.modifiers, factory.updateImportClause(clause, clause.isTypeOnly, undefined, factory.updateNamedImports(bindings, elements)), node.moduleSpecifier, node.attributes)
       }
       return ts.visitEachChild(node, visitor, context)
     }
     const normalized = ts.visitNode(sourceFile, visitor)
-    if (!params.size && !searchHooks.size) return normalized
+    if (!params.size && !matchHooks.size && !searchHooks.size) return normalized
     const imports = [
       ...[...params].map(name => factory.createImportSpecifier(false, name === "useParams" ? undefined : factory.createIdentifier("useParams"), factory.createIdentifier(name))),
+      ...(matchHooks.size ? [factory.createImportSpecifier(false, matchHelper === "__kUseRouteMatch" ? undefined : factory.createIdentifier("__kUseRouteMatch"), factory.createIdentifier(matchHelper))] : []),
       ...(searchReads.size ? [factory.createImportSpecifier(false, factory.createIdentifier("useSearchParam"), factory.createIdentifier(searchHelper))] : []),
       ...(searchObjects.some(entry => entry.setter) ? [factory.createImportSpecifier(false, factory.createIdentifier("useSearchParamsWriter"), factory.createIdentifier(searchWriterHelper))] : [])
     ]

package/framework/compiler/source-compiler.mjs

@@ -315,12 +315,12 @@ function normalizeParameterizedDebounceHooks(sourceFile, factory, context) {
   return ts.visitNode(sourceFile, visitor)
 }
 
-function normalizeCompilerSource(sourceFile, { base, context, file, importedCollections, importedStaticCollections, sourceFiles, sourceIndex }) {
+function normalizeCompilerSource(sourceFile, { base, context, file, importedCollections, importedFallbackCollections, importedStaticCollections, sourceFiles, sourceIndex }) {
   const factory = context.factory
   let customHookTimerStates = new Set()
   sourceFile = applyNormalizationPasses(sourceFile, [
     ...(importedStaticCollections ? [source => normalizeImportedStaticCollections(source, importedStaticCollections, factory, context)] : []),
-    source => normalizeReactRouterSyntax(source, factory, context, base),
+    source => normalizeReactRouterSyntax(source, factory, context, base, importedFallbackCollections),
     source => normalizeClsxSyntax(source, factory, context),
     source => normalizeMediaQueryExternalStores(source, factory, context),
     source => normalizeReactMigrationSyntax(source, factory, context, importedCollections ?? importedSerializableCollectionNames(source, file, sourceFiles, sourceIndex)),
@@ -354,7 +354,8 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
     const hasLinkElements = /<link/i.test(sourceFile.text)
     const importedStaticCollections = importedSerializableCollections(sourceFile, file, sourceFiles, sourceIndex, true)
     const importedCollections = new Set(importedStaticCollections.keys())
-    const normalized = normalizeCompilerSource(sourceFile, { base, context, file, importedCollections, importedStaticCollections, sourceFiles, sourceIndex })
+    const importedFallbackCollections = importedSerializableCollections(sourceFile, file, sourceFiles, sourceIndex)
+    const normalized = normalizeCompilerSource(sourceFile, { base, context, file, importedCollections, importedFallbackCollections, importedStaticCollections, sourceFiles, sourceIndex })
     sourceFile = normalized.sourceFile
     const { customHookTimerStates } = normalized
     const bindingIndex = createBindingIndex(sourceFile)
@@ -398,9 +399,10 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
     })
     const importBindings = clientImportBindings(sourceFile, file, sourceFiles)
     const packageBindings = packageImportBindings(sourceFile)
-    for (const [name] of packageBindings) {
+    for (const [name, binding] of packageBindings) {
       const references = referenceIdentifiers(sourceFile, name)
       const invalid = references.find(reference => !insideJsxEventHandler(reference, sourceFile) && !insideOwnedEffectCallback(reference, sourceFile))
+      if (invalid && binding.target === "react-i18next" && binding.imported === "useTranslation") throw sourceNodeError(invalid, sourceFile, "React i18next useTranslation() depends on runtime locale resources; migrate build-known locales through getStaticPaths() and props, or browser-only locale reads through an owned effect")
       if (invalid) throw sourceNodeError(invalid, sourceFile, `Package import ${JSON.stringify(name)} may only be referenced directly inside JSX event handlers or owned effect setup/cleanup callbacks`)
     }
     const hasUseEffectImport = sourceFile.statements.some(statement => ts.isImportDeclaration(statement) && ["@kudzujs/core", "react"].includes(statement.moduleSpecifier.text) && statement.importClause?.namedBindings && ts.isNamedImports(statement.importClause.namedBindings) && statement.importClause.namedBindings.elements.some(entry => !entry.propertyName && entry.name.text === "useEffect"))
@@ -661,6 +663,15 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
     const collect = node => {
       if (ts.isVariableDeclaration(node) && node.initializer && ts.isCallExpression(node.initializer)) {
         const callName = ts.isIdentifier(node.initializer.expression) ? node.initializer.expression.text : ""
+        if (ts.isIdentifier(node.name) && /^__kRouterSearchParam\d*$/.test(node.name.text) && /^__kUseSearchParam_*$/.test(callName)) {
+          const owner = nearestFunction(node)
+          if (!owner || !isLocalConst(node) || node.parent?.parent?.parent !== owner.body) throw sourceNodeError(node, sourceFile, "Compiler-owned search parameter signals must be top-level component const declarations")
+          const setters = settersByFunction.get(owner) ?? new Map()
+          const setter = `__kSet${node.name.text}`
+          setters.set(setter, node.name.text)
+          registerState(owner, node.name.text, setter, "search-param", node)
+          settersByFunction.set(owner, setters)
+        }
         const customHookImport = callName && /^use[A-Z]/.test(callName) && importBindings.has(callName) && importBindings.get(callName).kind !== "namespace" && !resolvedSharedState(importBindings.get(callName))
         const debounce = customHookImport && ts.isIdentifier(node.name) ? resolveParameterizedDebounceHook(importBindings.get(callName)) : undefined
         if (debounce) {
@@ -1110,6 +1121,7 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
       const declarations = jsxLocalDeclarations.get(owner)
       if (!declarations) return expression
       const substitutions = new Map()
+      const stateNames = new Set(setters.values())
       const resolving = []
       const resolve = (name, reference) => {
         if (substitutions.has(name)) return
@@ -1122,7 +1134,7 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
         resolving.push(name)
         const initializer = entries[0].initializer
         const visit = node => {
-          if (ts.isIdentifier(node) && isReferenceIdentifier(node) && !isShadowedByParameter(node, initializer) && declarations.has(node.text)) resolve(node.text, node)
+          if (ts.isIdentifier(node) && isReferenceIdentifier(node) && !isShadowedByParameter(node, initializer) && declarations.has(node.text) && !stateNames.has(node.text)) resolve(node.text, node)
           ts.forEachChild(node, visit)
         }
         visit(initializer)
@@ -1130,7 +1142,7 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
         resolving.pop()
       }
       const visit = node => {
-        if (ts.isIdentifier(node) && isReferenceIdentifier(node) && !isShadowedByParameter(node, expression) && declarations.has(node.text)) resolve(node.text, node)
+        if (ts.isIdentifier(node) && isReferenceIdentifier(node) && !isShadowedByParameter(node, expression) && declarations.has(node.text) && !stateNames.has(node.text)) resolve(node.text, node)
         ts.forEachChild(node, visit)
       }
       visit(expression)
@@ -1632,7 +1644,7 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
           const entries = jsxLocalDeclarations.get(nearestFunction(node))?.get(value.expression.text)
           if (!entries?.length) return undefined
           const initializer = entries.length === 1 ? unwrapExpression(entries[0].initializer) : undefined
-          if (!initializer || !ts.isCallExpression(initializer) || !ts.isIdentifier(initializer.expression) || !importBindings.has(initializer.expression.text)) return undefined
+          if (!initializer || !ts.isCallExpression(initializer) || !ts.isIdentifier(initializer.expression) || !importBindings.has(initializer.expression.text) || resolvedSharedState(importBindings.get(initializer.expression.text))) return undefined
           if (entries[0].node.parent?.parent?.parent !== nearestFunction(entries[0].node)?.body) fail(value.expression, `Calculated collection result "${value.expression.text}" must be one top-level immutable local`)
           validateImportedCalculation(initializer, value.name.text)
           const expanded = resolveReactiveJsxExpression(value, nearestFunction(node), setters)
@@ -1974,11 +1986,13 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
         if (callback.parameters.length) effectFail(callback, "useEffect() callback cannot declare parameters")
         if (!ts.isArrayLiteralExpression(dependencies)) effectFail(dependencies, "useEffect() dependencies must be a literal array")
         const setters = settersForNode(node, settersByFunction)
+        const effectStateNames = new Set(setters.values())
         const resolveCalculation = dependency => {
           if (specializedEffect) return undefined
           const value = unwrapExpression(dependency)
           const result = ts.isIdentifier(value) ? value : ts.isPropertyAccessExpression(value) || ts.isElementAccessExpression(value) ? unwrapExpression(value.expression) : undefined
           if (!result || !ts.isIdentifier(result)) return undefined
+          if (effectStateNames.has(result.text)) return undefined
           const entries = jsxLocalDeclarations.get(effectOwner)?.get(result.text)
           const initializer = entries?.length === 1 && entries[0].node.parent?.parent?.parent === effectOwner?.body ? unwrapExpression(entries[0].initializer) : undefined
           if (!initializer || !ts.isCallExpression(initializer) || !ts.isIdentifier(initializer.expression) || !importBindings.has(initializer.expression.text)) return undefined

package/framework/core.mjs

@@ -123,6 +123,19 @@ export function useParams() {
   return renderContext.params
 }
 
+export function __kUseRouteMatch(pattern) {
+  if (!renderContext) throw new Error("React Router useMatch can only run while rendering a Kudzu component")
+  if (renderContext.renderScope === "layout") throw new Error("React Router useMatch is only supported in route scope")
+  if (renderContext.runtimeParamNames?.length) throw new Error("React Router useMatch requires a build-known route and cannot run on a runtimeParams bracket page")
+  const pathname = renderContext.applicationRoute
+  let decodedPathname = pathname
+  try {
+    decodedPathname = pathname.split("/").map(segment => decodeURIComponent(segment).replaceAll("/", "%2F")).join("/")
+  } catch {}
+  const matches = new RegExp(`^${pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`, "i").test(decodedPathname)
+  return matches ? { params: {}, pathname: decodedPathname, pathnameBase: decodedPathname, pattern: { path: pattern, caseSensitive: false, end: true } } : null
+}
+
 export function useSearchParam(name) {
   if (!renderContext) throw new Error("useSearchParam() can only run while rendering a Kudzu component")
   if (renderContext?.renderScope === "layout") throw new Error("useSearchParam() is only supported in route scope")
@@ -471,7 +484,7 @@ function serializeCapture(name, value, seen) {
 }
 
 export async function renderPage(component, metadata = {}, props = {}, layout) {
-  renderContext = { scoped: Boolean(layout), renderScope: layout ? "layout" : "route", counters: { layout: { s: 0, r: 0, c: 0, l: 0, e: 0, p: 0, i: 0 }, route: { s: 0, r: 0, c: 0, l: 0, e: 0, p: 0, i: 0 } }, nextState: 0, nextRef: 0, nextCondition: 0, nextList: 0, nextEffect: 0, nextParam: 0, nextId: 0, conditionDepth: 0, listDepth: 0, listRoot: undefined, listRowRoot: undefined, listTemplate: false, listInitialMarkers: false, listConditionalBranch: false, listFields: undefined, listEffectOwners: [], listRowStates: [], listRowRefs: [], listRowConditions: [], listRowLists: [], effectOwners: [], contexts: [], captureCache: new WeakMap(), sharedStates: new Map(), states: {}, textStates: new Set(), conditionStates: new Set(), conditionOwnedStates: new Set(), events: [], effects: [], bindings: [], textBindings: [], conditions: [], lists: [], handlerReferences: new Map(), runtimeParamNames: metadata.runtimeParams, paramEntries: [], params: undefined, searchParams: new Map(), searchParamEntries: [], searchParamsWritable: false, hasBehaviors: false, hasNativeBehaviors: false, hasEffects: false, hasParams: false, hasBindings: false, hasLists: false, hasListStyles: false }
+  renderContext = { scoped: Boolean(layout), renderScope: layout ? "layout" : "route", applicationRoute: metadata.applicationRoute, counters: { layout: { s: 0, r: 0, c: 0, l: 0, e: 0, p: 0, i: 0 }, route: { s: 0, r: 0, c: 0, l: 0, e: 0, p: 0, i: 0 } }, nextState: 0, nextRef: 0, nextCondition: 0, nextList: 0, nextEffect: 0, nextParam: 0, nextId: 0, conditionDepth: 0, listDepth: 0, listRoot: undefined, listRowRoot: undefined, listTemplate: false, listInitialMarkers: false, listConditionalBranch: false, listFields: undefined, listEffectOwners: [], listRowStates: [], listRowRefs: [], listRowConditions: [], listRowLists: [], effectOwners: [], contexts: [], captureCache: new WeakMap(), sharedStates: new Map(), states: {}, textStates: new Set(), conditionStates: new Set(), conditionOwnedStates: new Set(), events: [], effects: [], bindings: [], textBindings: [], conditions: [], lists: [], handlerReferences: new Map(), runtimeParamNames: metadata.runtimeParams, paramEntries: [], params: undefined, searchParams: new Map(), searchParamEntries: [], searchParamsWritable: false, hasBehaviors: false, hasNativeBehaviors: false, hasEffects: false, hasParams: false, hasBindings: false, hasLists: false, hasListStyles: false }
 
   try {
     const page = { [routeScopeMarker]: true, component, props }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kudzujs/core",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "description": "HTML-first TSX framework with synchronous state semantics and no virtual DOM",
   "type": "module",
   "license": "MIT",