@reactra/vite-plugin 0.1.0-alpha.0

package/dist/walker.js

@@ -0,0 +1,1070 @@
+// @reactra/vite-plugin — file-based route walker
+//
+// Owner: reactra-router-spec.md §2 (file-based convention) + §5.1 (manifest
+//        format) + reactra-compiler-spec.md §7.1 (vite plugin watcher hook)
+//
+// Phase 1 #5b scope:
+//   - deriveRoutePath:    file-relative-path → URL pattern (pure fn)
+//   - scanPages:          recursively walk <root>/src/pages/ → DiscoveredRoute[]
+//   - emitRouteManifest:  format the typed-route-manifest TS module text
+//
+// Phase-1-supported page-file conventions:
+//   - `index.tsx`         → segment is implicit (parent dir)
+//   - `foo.tsx`           → segment is `foo`
+//   - `[id].tsx`          → segment is `:id` (single dynamic segment)
+//   - `.ts` / `.jsx` / `.js` are accepted too (pages without JSX possible)
+//
+// Phase-1-skipped (logged as "unsupported in v0.1" → null):
+//   - `_*`                → underscore-prefixed = special (middleware/layout/
+//                           loading/error)  → tracked as #5c/#5d
+//   - `(group)/`          → route group  → #5c
+//   - `[...slug]`         → catch-all  → #5c
+//   - `@parallel/`        → parallel route  → Phase 4 (per Router §2 table)
+//
+// Walker output is sorted by `path` for deterministic manifests — important
+// so HMR doesn't churn the manifest on every dev-server boot.
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { lex, skipTrivia } from "@reactra/babel-plugin";
+import { createGraphCache } from "./graph-cache.js";
+import { componentNameFromContainers, containersToInfo, queriesFromContainers, storeNamesFromContainers, serviceNamesFromContainers, prefetchFromContainers, } from "./extract.js";
+const SUPPORTED_EXT_RE = /\.(?:tsx|jsx|ts|js)$/;
+const stripExt = (s) => s.replace(SUPPORTED_EXT_RE, "");
+/**
+ * A path segment that the walker should refuse to derive a route from.
+ * Returning true at the per-segment level lets us skip whole subtrees
+ * (the directory traversal also checks isSpecialSegment).
+ *
+ * NOTE — Wave-3 §2b: route groups (`(group)`) and catch-all rest segments
+ * (`[...slug]`) were removed from this predicate. They're now handled
+ * inside {@link deriveRoutePath} as transparent / catch-all respectively.
+ */
+const isSpecialSegment = (segment) => segment.startsWith("_") ||
+    segment.startsWith("@");
+/**
+ * Wave-3 §2b — `[...name]` catch-all segment. Must appear ONLY as the LAST
+ * segment of the file path; a catch-all in the middle is rejected by
+ * {@link deriveRoutePath}. The URL representation is `*name`.
+ */
+const isCatchAllSegment = (segment) => segment.startsWith("[...") && segment.endsWith("]") && segment.length > 5;
+/**
+ * Wave-3 §2b — a `(name)` directory at any depth under `src/pages/`.
+ * Route groups organise files in the source tree without affecting the
+ * URL: `pages/(marketing)/about.tsx` → URL `/about`, not `/marketing/about`.
+ * Middleware inside a group applies based on FILE-TREE location, not URL
+ * prefix — see {@link chainsForRoutes}.
+ */
+const isRouteGroupSegment = (segment) => segment.length >= 2 && segment.startsWith("(") && segment.endsWith(")");
+/**
+ * Convert a path relative to `src/pages/` into the URL pattern the router
+ * registers. Returns `null` for Phase-1-unsupported features, special
+ * filenames, and unsupported extensions.
+ *
+ * Examples:
+ *   "index.tsx"                  → "/"
+ *   "about.tsx"                  → "/about"
+ *   "customers/index.tsx"        → "/customers"
+ *   "customers/[id].tsx"         → "/customers/:id"
+ *   "customers/[id]/edit.tsx"    → "/customers/:id/edit"
+ *   "(auth)/login.tsx"           → "/login"      (route group — Wave 3 §2b)
+ *   "(marketing)/index.tsx"      → "/"           (route group at root)
+ *   "(auth)/dashboard/index.tsx" → "/dashboard"  (route group + nested)
+ *   "blog/[...slug].tsx"         → "/blog/*slug" (catch-all — Wave 3 §2b)
+ *   "[...rest].tsx"              → "/*rest"      (root catch-all)
+ *   "_middleware.ts"             → null  (special — Wave 3 §2b)
+ *   "README.md"                  → null  (unsupported extension)
+ *
+ * Catch-all constraints:
+ *   - `[...name]` must be the LAST segment (a mid-path catch-all is
+ *     rejected with `null`).
+ *   - `index` filename + catch-all not allowed
+ *     (`[...slug]/index.tsx` rejected).
+ */
+export const deriveRoutePath = (relativePath) => {
+    const normalized = relativePath.replace(/\\/g, "/");
+    if (!SUPPORTED_EXT_RE.test(normalized))
+        return null;
+    const segments = stripExt(normalized).split("/");
+    // Reject anywhere along the path — a special parent dir disqualifies all
+    // its files in the walker. Route groups (`(group)`) and catch-alls
+    // (`[...name]`) are NOT special here — handled below.
+    for (const seg of segments)
+        if (isSpecialSegment(seg))
+            return null;
+    // Drop route-group segments (Wave 3 §2b) before deriving the URL.
+    const urlSegments = segments.filter((s) => !isRouteGroupSegment(s));
+    if (urlSegments.length === 0)
+        return "/"; // e.g. `(marketing)/index.tsx`
+    // Catch-all check: `[...name]` must be the LAST segment if present.
+    // A mid-path catch-all is rejected.
+    for (let i = 0; i < urlSegments.length - 1; i++) {
+        if (isCatchAllSegment(urlSegments[i]))
+            return null;
+    }
+    const last = urlSegments[urlSegments.length - 1];
+    // `[...slug]/index.tsx` is not a valid shape (catch-all has no children).
+    if (last === "index" && urlSegments.length > 1 && isCatchAllSegment(urlSegments[urlSegments.length - 2])) {
+        return null;
+    }
+    const trimmed = last === "index" ? urlSegments.slice(0, -1) : urlSegments;
+    const routeSegments = trimmed.map((s) => {
+        // Catch-all `[...name]` → `*name` in the URL pattern.
+        if (isCatchAllSegment(s))
+            return "*" + s.slice(4, -1);
+        // `[param]` → `:param`. Anything else is a literal segment.
+        if (s.startsWith("[") && s.endsWith("]"))
+            return ":" + s.slice(1, -1);
+        return s;
+    });
+    return routeSegments.length === 0 ? "/" : "/" + routeSegments.join("/");
+};
+/**
+ * Slugify a URL pattern into a stable id used as the `RouteConfig.id` field
+ * and as part of generated chunk names downstream.
+ *   "/"               → "index"
+ *   "/about"          → "about"
+ *   "/customers/:id"  → "customers-id"
+ */
+const pathToId = (routePath) => {
+    if (routePath === "/")
+        return "index";
+    return routePath
+        .slice(1)
+        .replace(/[:*]/g, "")
+        .replace(/\//g, "-");
+};
+/**
+ * Build a PascalCase identifier from a file's relative path. Brackets are
+ * stripped; segments are uppercased and joined.
+ *   "index.tsx"                  → "PageIndex"
+ *   "customers/[id].tsx"         → "PageCustomersId"
+ *   "customers/[id]/edit.tsx"    → "PageCustomersIdEdit"
+ *
+ * The `Page` prefix avoids collisions with React's reserved component
+ * names (`Component`, `Fragment`, etc.) when the manifest is auto-generated.
+ */
+/**
+ * Pull the source name of the page's `export component <Name>` declaration
+ * from the raw `.tsx` text. Delegates to `extract.extractComponentName` which
+ * calls `preprocess()` — fixes the R2 regression where the old regex missed
+ * the header-`uses` form (`export component Foo uses traceable {`).
+ *
+ * Returns null when no exported component is found (plain React TSX page, or a
+ * page whose container is not yet declared). Reads first match only — pages
+ * with multiple components aren't a Phase-1 case.
+ */
+const extractPageComponentName = (cache, filePath) => componentNameFromContainers(cache.containersFor(filePath));
+/**
+ * Source-scan a page file for its `query` declarations via `preprocess()`.
+ * Phase 3 replacement of `QUERY_DECL_RE` / `extractPageQueries` — fixes the
+ * v2 semicolon leak where the old regex captured the trailing `;` as part of
+ * `tsType`. Cold-start safe (no sidecar dependency).
+ */
+const extractPageQueries = (cache, filePath) => queriesFromContainers(cache.containersFor(filePath));
+/**
+ * Walk UP from `fileDir` to `pagesRoot`, returning the nearest ancestor
+ * `<basename>` (Router §2.3 — special files `_loading.tsx`, `_error.tsx`).
+ * Returns its import specifier (relative to the manifest location, like
+ * `./pages/dashboard/_loading`) plus a path-unique PascalCase identifier
+ * derived from the directory (so multiple routes sharing the same ancestor
+ * dedupe to one import). Stage 3 reuses this for `_layout.tsx` (one chain
+ * collector built on the same walk).
+ */
+const extractNearestSpecial = (fileDir, pagesRoot, basename, identifierPrefix) => {
+    let cur = fileDir;
+    while (true) {
+        const candidate = join(cur, basename);
+        try {
+            if (statSync(candidate).isFile()) {
+                const relDir = relative(pagesRoot, cur).replace(/\\/g, "/");
+                const stem = basename.replace(/\.(tsx|ts|jsx|js)$/, "");
+                const specifier = relDir ? `./pages/${relDir}/${stem}` : `./pages/${stem}`;
+                const identifier = relDir
+                    ? `${identifierPrefix}_${relDir.replace(/[\\/[\]]/g, "_")}`
+                    : `${identifierPrefix}_root`;
+                return { specifier, identifier };
+            }
+        }
+        catch {
+            // File missing → continue walking up.
+        }
+        if (cur === pagesRoot)
+            break;
+        const parent = dirname(cur);
+        if (parent === cur)
+            break;
+        cur = parent;
+    }
+    return undefined;
+};
+const extractNearestLoading = (fileDir, pagesRoot) => extractNearestSpecial(fileDir, pagesRoot, "_loading.tsx", "Loading");
+const extractNearestError = (fileDir, pagesRoot) => extractNearestSpecial(fileDir, pagesRoot, "_error.tsx", "Error");
+/**
+ * Walk UP from `fileDir` to `pagesRoot`, collecting **every** ancestor
+ * `_layout.tsx` (Router §2.3 — layout chain wrapping the page). Returned
+ * outermost-first (root → innermost), so the runtime can wrap layouts in
+ * order. Multiple routes sharing an ancestor layout dedupe at emission time
+ * (the same specifier resolves to the same identifier).
+ */
+const extractLayoutChain = (fileDir, pagesRoot) => {
+    const innermostFirst = [];
+    let cur = fileDir;
+    while (true) {
+        const candidate = join(cur, "_layout.tsx");
+        try {
+            if (statSync(candidate).isFile()) {
+                const relDir = relative(pagesRoot, cur).replace(/\\/g, "/");
+                const specifier = relDir ? `./pages/${relDir}/_layout` : `./pages/_layout`;
+                const identifier = relDir
+                    ? `Layout_${relDir.replace(/[\\/[\]]/g, "_")}`
+                    : "Layout_root";
+                innermostFirst.push({ specifier, identifier });
+            }
+        }
+        catch {
+            // File missing → continue walking up.
+        }
+        if (cur === pagesRoot)
+            break;
+        const parent = dirname(cur);
+        if (parent === cur)
+            break;
+        cur = parent;
+    }
+    return innermostFirst.reverse(); // outermost-first
+};
+/**
+ * Source-scan a page for its `prefetch on <trigger>` policy via the compiled
+ * graph (the first component wins — it's a single per-page policy). Returns the
+ * trigger or `undefined`.
+ */
+const extractPagePrefetch = (cache, filePath) => prefetchFromContainers(cache.containersFor(filePath));
+/**
+ * Pull the `:name` param names out of a route pattern, in order.
+ *   "/"               → []
+ *   "/customers"      → []
+ *   "/customers/:id"  → ["id"]
+ *   "/c/:a/o/:b"      → ["a", "b"]
+ *
+ * Day 28+ / `#5c-typed`: feeds the generated `RouteParams` map so
+ * `navigate("/customers/:id", { params: { id } })` is compile-checked.
+ */
+const extractParamNames = (routePath) => routePath
+    .split("/")
+    // Both `:name` and `*name` (catch-all) contribute a param.
+    .filter((seg) => seg.startsWith(":") || seg.startsWith("*"))
+    .map((seg) => seg.slice(1));
+const pathToComponentIdentifier = (relativePath) => {
+    const noExt = stripExt(relativePath.replace(/\\/g, "/"));
+    const tokens = ["Page"];
+    for (const segment of noExt.split("/")) {
+        if (!segment)
+            continue;
+        // Route groups (Wave 3 §2b) — `(marketing)` etc. — are invisible to
+        // the URL and so to the component identifier. They were ALREADY
+        // invalid here (parens aren't valid JS identifier chars), so skipping
+        // them is both correct and necessary.
+        if (isRouteGroupSegment(segment))
+            continue;
+        // Catch-all `[...name]` — extract `name` (the dots aren't valid
+        // identifier chars, and the trailing brackets would survive the
+        // single-bracket replacement below without help).
+        const catchAllMatch = /^\[\.\.\.(\w+)\]$/.exec(segment);
+        if (catchAllMatch) {
+            const name = catchAllMatch[1];
+            tokens.push(name.charAt(0).toUpperCase() + name.slice(1));
+            continue;
+        }
+        const cleaned = segment.replace(/\[(\w+)\]/g, "$1");
+        for (const sub of cleaned.split(/[-.]/)) {
+            if (!sub)
+                continue;
+            tokens.push(sub.charAt(0).toUpperCase() + sub.slice(1));
+        }
+    }
+    return tokens.join("");
+};
+/**
+ * Recursively scan `<projectRoot>/src/pages/` for page files. Files that
+ * `deriveRoutePath` returns `null` for are skipped. Returns the routes
+ * sorted by `path` so the generated manifest is byte-stable across runs.
+ *
+ * Tolerates a missing `src/pages/` directory (returns `[]`) — useful during
+ * a fresh `dev` boot before pages exist.
+ */
+export const scanPages = (projectRoot, cache = createGraphCache()) => {
+    const pagesRoot = join(projectRoot, "src", "pages");
+    const out = [];
+    const seenComponentIdentifiers = new Set();
+    const seenIds = new Set();
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = join(dir, entry);
+            // A file listed by readdir can vanish before we stat it — atomic-save
+            // temp files (an editor/tool writes `foo.tsx.tmp.NNNN` then renames it
+            // away) race the watcher. Skip the vanished entry; it's a transient, not
+            // a page-tree error worth failing the regen over (scanPages rethrows).
+            let stat;
+            try {
+                stat = statSync(full);
+            }
+            catch (err) {
+                if (err.code === "ENOENT")
+                    continue;
+                throw err;
+            }
+            if (stat.isDirectory()) {
+                // Skip whole subtrees rooted at a special-name dir (Phase 1).
+                if (isSpecialSegment(entry))
+                    continue;
+                walk(full);
+                continue;
+            }
+            if (!stat.isFile())
+                continue;
+            const rel = relative(pagesRoot, full).replace(/\\/g, "/");
+            const routePath = deriveRoutePath(rel);
+            if (routePath === null)
+                continue;
+            const id = pathToId(routePath);
+            const componentIdentifier = pathToComponentIdentifier(rel);
+            // Duplicate-route detection. `pages/foo.tsx` + `pages/foo.jsx`
+            // would both derive to "/foo"; refuse rather than silently overwrite.
+            if (seenIds.has(id)) {
+                throw new Error(`[@reactra/vite-plugin] duplicate route path "${routePath}" — two ` +
+                    `files under src/pages/ map to the same URL. Disambiguate or ` +
+                    `delete one. (file: ${rel})`);
+            }
+            seenIds.add(id);
+            // PascalCase collision (theoretically impossible given the algorithm
+            // is path-injective, but cheap to assert).
+            if (seenComponentIdentifiers.has(componentIdentifier)) {
+                throw new Error(`[@reactra/vite-plugin] internal: duplicate component identifier ` +
+                    `${componentIdentifier} for ${rel}`);
+            }
+            seenComponentIdentifiers.add(componentIdentifier);
+            const bindingsName = extractPageComponentName(cache, full) ?? undefined;
+            const dirRel = dirname(rel).replace(/\\/g, "/");
+            const fileDirRelativeToPages = dirRel === "." ? "" : dirRel;
+            out.push({
+                id,
+                path: routePath,
+                filePath: ["src", "pages", rel].join("/"),
+                importSpecifier: `./pages/${stripExt(rel)}`,
+                componentIdentifier,
+                fileDirRelativeToPages,
+                bindingsName,
+                queries: extractPageQueries(cache, full),
+                prefetch: extractPagePrefetch(cache, full),
+                loading: extractNearestLoading(dirname(full), pagesRoot),
+                errorBoundary: extractNearestError(dirname(full), pagesRoot),
+                layouts: extractLayoutChain(dirname(full), pagesRoot),
+            });
+        }
+    };
+    walk(pagesRoot);
+    // Sort with catch-all routes LAST so the runtime's first-match iteration
+    // in matchRoute picks the more specific concrete/dynamic route over a
+    // catch-all that would also accept the URL (Wave 3 §2b). Within each
+    // tier, alphabetical by path keeps the generated manifest byte-stable.
+    out.sort((a, b) => {
+        const aCatch = a.path.includes("/*");
+        const bCatch = b.path.includes("/*");
+        if (aCatch !== bCatch)
+            return aCatch ? 1 : -1;
+        return a.path.localeCompare(b.path);
+    });
+    return out;
+};
+/**
+ * Discover every store binding declared anywhere under `<projectRoot>/src/`
+ * by source-regex via `preprocess()` (cold-start safe). Returns a deterministic
+ * name-sorted list so the manifest renderer's output is byte-stable.
+ *
+ * **Collect ALL declared stores regardless of the source `export` keyword.**
+ * The compiler force-exports every container it processes (Pass 9 emits
+ * `export const name = …` unconditionally), so `session store X {}` and
+ * `route store X {}` are BOTH importable as `import { X }` — the walker must
+ * collect them. When the compiler stops force-exporting (a future coordinated
+ * change), re-introduce an `exported=true` filter and a "non-exported store
+ * consumed cross-file" diagnostic. For now, collect all.
+ *
+ * Phase 3: replaced the hand-rolled `STORE_DECL_RE` regex with `preprocess()`
+ * for v1+v2 dual-accept grammar. The `exported` field from `extractStoreNames`
+ * is available for diagnostics but is NOT used to filter here.
+ *
+ * Tolerates a missing `src/` directory (returns []).
+ */
+export const scanStores = (projectRoot, cache = createGraphCache()) => {
+    const srcRoot = join(projectRoot, "src");
+    const out = [];
+    const seen = new Set();
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = join(dir, entry);
+            const stat = statSync(full);
+            if (stat.isDirectory()) {
+                walk(full);
+                continue;
+            }
+            if (!stat.isFile())
+                continue;
+            if (!SUPPORTED_EXT_RE.test(entry))
+                continue;
+            // A3: one cached compile per file (was readFileSync + per-scanner compile).
+            // The `exported` field is present but NOT used to filter: the compiler
+            // force-exports all containers so every declared store is importable
+            // (see JSDoc above). Cache returns [] on read/compile failure (was the
+            // old `continue` on read error).
+            for (const { name } of storeNamesFromContainers(cache.containersFor(full))) {
+                // First declaration wins; later collisions surface via
+                // `loadSidecarIndex` at transform time (where the conflict
+                // error knows both source paths).
+                if (seen.has(name))
+                    continue;
+                seen.add(name);
+                out.push({
+                    name,
+                    sourcePath: full,
+                    importSpecifier: deriveStoreImportSpecifier(srcRoot, full),
+                });
+            }
+        }
+    };
+    walk(srcRoot);
+    out.sort((a, b) => a.name.localeCompare(b.name));
+    return out;
+};
+/**
+ * Discover every service binding declared anywhere under
+ * `<projectRoot>/src/` by source-regex via `preprocess()` (cold-start safe).
+ * Returns a deterministic name-sorted list so the manifest renderer's output
+ * is byte-stable.
+ *
+ * **Collect ALL declared services regardless of the source `export` keyword.**
+ * Same force-export rationale as {@link scanStores} — see its JSDoc for the
+ * full explanation and the re-introduction trigger.
+ *
+ * Tolerates a missing `src/` directory (returns []).
+ */
+export const scanServices = (projectRoot, cache = createGraphCache()) => {
+    const srcRoot = join(projectRoot, "src");
+    const out = [];
+    const seen = new Set();
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = join(dir, entry);
+            const stat = statSync(full);
+            if (stat.isDirectory()) {
+                walk(full);
+                continue;
+            }
+            if (!stat.isFile())
+                continue;
+            if (!SUPPORTED_EXT_RE.test(entry))
+                continue;
+            // A3: one cached compile per file. The `exported` field is present but
+            // NOT used to filter — same force-export rationale as scanStores.
+            for (const { name, serviceModifier } of serviceNamesFromContainers(cache.containersFor(full))) {
+                // First declaration wins; duplicate names across files are unusual for
+                // services (unlike stores) but we apply the same dedup policy.
+                if (seen.has(name))
+                    continue;
+                seen.add(name);
+                out.push({
+                    name,
+                    sourcePath: full,
+                    importSpecifier: deriveStoreImportSpecifier(srcRoot, full),
+                    serviceModifier,
+                });
+            }
+        }
+    };
+    walk(srcRoot);
+    out.sort((a, b) => a.name.localeCompare(b.name));
+    return out;
+};
+/**
+ * Walk `<projectRoot>/src/` and collect every `inject service X` site where
+ * `X` is NOT declared anywhere under `src/` (i.e. no `service X {}` or
+ * `export service X {}` block exists). Returns one diagnostic per injection
+ * site that references an undeclared name.
+ *
+ * Decision (brief §Step 5): warn-only — no minted error code. An `inject
+ * service X` where `X` is declared but non-exported is NOT a diagnostic
+ * (it's declared = configurable via hand-listed `configureServices`).
+ * `inject baseUrl from config("X")` carries `source:"config"`, not
+ * `kind:"service"`, so it is never counted.
+ *
+ * Tolerates a missing `src/` directory (returns []).
+ */
+export const collectServiceInjectionDiagnostics = (projectRoot, cache = createGraphCache()) => {
+    const srcRoot = join(projectRoot, "src");
+    // First pass: collect ALL declared service names (exported or not).
+    const allDeclaredServices = new Set();
+    // Second pass source material: injection sites per file.
+    const injectionSites = [];
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = join(dir, entry);
+            const stat = statSync(full);
+            if (stat.isDirectory()) {
+                walk(full);
+                continue;
+            }
+            if (!stat.isFile())
+                continue;
+            if (!SUPPORTED_EXT_RE.test(entry))
+                continue;
+            // A3: one cached compile per file (shared with scanStores/scanServices).
+            const containers = containersToInfo(cache.containersFor(full));
+            for (const c of containers) {
+                if (c.kind === "service") {
+                    allDeclaredServices.add(c.name);
+                }
+                for (const svcName of c.injectedServiceNames) {
+                    injectionSites.push({ service: svcName, file: full });
+                }
+            }
+        }
+    };
+    walk(srcRoot);
+    // Return only sites whose service was never declared anywhere in src/.
+    return injectionSites.filter((site) => !allDeclaredServices.has(site.service));
+};
+/**
+ * Token-scan `source` for a default export. Detects two forms:
+ *   - `export default …` (function / class / expression)
+ *   - the re-export `export { x as default }` (the `as default` pairing)
+ *
+ * Uses `lex()` so comments and string literals are their own token kinds —
+ * a commented-out `// export default x` or a string `"export default"` cannot
+ * false-match. Known limitation (acceptable per B5): `lex()` does not recognise
+ * regex literals; this is irrelevant to `export default` detection.
+ */
+const hasDefaultExport = (source) => {
+    const tokens = lex(source);
+    const nextCode = (from) => skipTrivia(tokens, from);
+    const isIdent = (t, text) => t !== undefined && t.kind === "ident" && t.text === text;
+    const isPunct = (t, text) => t !== undefined && t.kind === "punct" && t.text === text;
+    for (let i = 0; i < tokens.length; i++) {
+        if (!isIdent(tokens[i], "export"))
+            continue;
+        const j = nextCode(i + 1);
+        // `export default …`
+        if (isIdent(tokens[j], "default"))
+            return true;
+        // `export { … as default }` — scan the brace group for an `as default` pair.
+        if (isPunct(tokens[j], "{")) {
+            for (let k = j + 1; k < tokens.length; k++) {
+                const t = tokens[k];
+                if (isPunct(t, "}"))
+                    break;
+                if (isIdent(t, "as") && isIdent(tokens[nextCode(k + 1)], "default"))
+                    return true;
+            }
+        }
+    }
+    return false;
+};
+/**
+ * RO014 — `_middleware.ts` files must have a default export so the walker-
+ * emitted `router-middleware.generated.ts` can `import middlewareN from "..."`
+ * the user's MiddlewareDef. Lexical check via {@link hasDefaultExport}: a
+ * token-scan for one of the common default-export patterns (function decl,
+ * expression, class, named re-export-as-default).
+ *
+ * On miss, throws an Error with the spec reference + the offending path so
+ * the build fails loudly. The vite-plugin's try/catch around scanMiddleware
+ * logs the error and emits an empty `router-middleware.generated.ts`,
+ * keeping the dev server up while still surfacing the problem.
+ */
+const validateMiddlewareDefaultExport = (absolutePath, relativeToPages) => {
+    let source;
+    try {
+        source = readFileSync(absolutePath, "utf8");
+    }
+    catch (err) {
+        throw new Error(`[@reactra/vite-plugin] RO014: cannot read _middleware file ` +
+            `at ${relativeToPages} (${err.message}). ` +
+            `(reactra-router-spec.md §5.8)`);
+    }
+    // Token-scan for a default export instead of comment-stripping by regex.
+    // `lex()` emits comments and strings as their own token kinds, so a
+    // commented-out `// export default …` or a string literal `"export default"`
+    // can never false-match. Middleware is plain TS (NOT DSL), so we lex it
+    // directly — no compileToGraph.
+    if (!hasDefaultExport(source)) {
+        throw new Error(`[@reactra/vite-plugin] RO014: _middleware file ${relativeToPages} ` +
+            `has no default export. Add ` +
+            `\`export default defineMiddleware({ … })\` (Router §6.3). ` +
+            `(reactra-router-spec.md §5.8)`);
+    }
+};
+/**
+ * Walk `<projectRoot>/src/pages/` for `_middleware.ts` files. Skips
+ * Phase-1-unsupported directory shapes (route groups `(group)/`,
+ * catch-alls `[...slug]/`, parallel routes `@x/`) the same way
+ * {@link scanPages} does — a middleware inside a Phase-1-excluded
+ * subtree wouldn't be exercisable until those features land.
+ *
+ * Multiple `_middleware.ts` files in the same directory aren't a
+ * supported case (per spec — one per dir); but if both `_middleware.ts`
+ * and `_middleware.tsx` exist, only the `.ts` is recognised (the
+ * EXT_PRIORITY array drives the lookup).
+ *
+ * Tolerates a missing `src/pages/` directory (returns []).
+ */
+export const scanMiddleware = (projectRoot) => {
+    const pagesRoot = join(projectRoot, "src", "pages");
+    const out = [];
+    let counter = 0;
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = join(dir, entry);
+            const stat = statSync(full);
+            if (stat.isDirectory()) {
+                // Same exclusions as scanPages — `(group)/`, `[...slug]/`, `@parallel/`,
+                // any `_*` directory (we don't recurse into those for middleware
+                // either; e.g. `_layout/_middleware.ts` would never apply to a
+                // route since the parent dir itself is special).
+                if (isSpecialSegment(entry))
+                    continue;
+                walk(full);
+                continue;
+            }
+            if (!stat.isFile())
+                continue;
+            if (entry !== "_middleware.ts" && entry !== "_middleware.tsx")
+                continue;
+            const rel = relative(pagesRoot, full).replace(/\\/g, "/");
+            // RO014 (Stage 4) — `_middleware.ts` must have a default export.
+            // We read the file as text and run a permissive regex covering the
+            // common `export default …` forms (function decl, expression, class).
+            // The check is intentionally lexical, not AST-based — a malformed
+            // file would still bail here, which is the right behaviour: the
+            // walker can't safely treat a no-default file as middleware.
+            validateMiddlewareDefaultExport(full, rel);
+            const dirRel = dirname(rel).replace(/\\/g, "/");
+            const dirRelativeToPages = dirRel === "." ? "" : dirRel;
+            const importSpecifier = "./pages/" + stripExt(rel);
+            out.push({
+                dirRelativeToPages,
+                sourcePath: full,
+                importSpecifier,
+                identifier: `middleware${counter++}`,
+            });
+        }
+    };
+    walk(pagesRoot);
+    // Sort by depth then path so chain resolution returns root-first
+    // deterministically (alphabetical within a depth tier).
+    out.sort((a, b) => {
+        const da = a.dirRelativeToPages === "" ? 0 : a.dirRelativeToPages.split("/").length;
+        const db = b.dirRelativeToPages === "" ? 0 : b.dirRelativeToPages.split("/").length;
+        if (da !== db)
+            return da - db;
+        return a.dirRelativeToPages.localeCompare(b.dirRelativeToPages);
+    });
+    return out;
+};
+/**
+ * For every route in `routes`, compute the ordered list of `_middleware.ts`
+ * files that apply, root-first → leaf-last (spec §5.7 example). Pure —
+ * given the same inputs, produces the same chains, so the generated
+ * `router-middleware.generated.ts` is byte-stable.
+ *
+ * A middleware at directory `D` applies to a route at file directory `R`
+ * iff `D` is a prefix of `R` (`D === ""` always applies; `D === "dashboard"`
+ * applies to `dashboard/**`). The match treats path components atomically
+ * — `dash` does NOT prefix `dashboard`.
+ *
+ * Wave-3 §2b — route groups: the match is on FILE-TREE location, not URL
+ * prefix. `pages/(auth)/_middleware.ts` (dir `(auth)`) applies to
+ * `pages/(auth)/login.tsx` (URL `/login`) because the file lives inside
+ * `(auth)/`, even though the URL doesn't carry the group segment. Hand-
+ * built `DiscoveredRoute` fixtures without `fileDirRelativeToPages` fall
+ * back to root (`""`), preserving prior test behaviour.
+ */
+export const chainsForRoutes = (routes, middleware) => {
+    const out = new Map();
+    for (const route of routes) {
+        const routeDir = route.fileDirRelativeToPages ?? "";
+        const chain = [];
+        for (const mw of middleware) {
+            const mwDir = mw.dirRelativeToPages;
+            if (mwDir === "") {
+                chain.push(mw); // root applies to all
+                continue;
+            }
+            // Path-component prefix: mwDir === routeDir OR mwDir + "/" prefixes routeDir.
+            if (routeDir === mwDir ||
+                routeDir.startsWith(mwDir + "/")) {
+                chain.push(mw);
+            }
+        }
+        if (chain.length > 0)
+            out.set(route.path, chain);
+    }
+    return out;
+};
+/**
+ * Format the `router-middleware.generated.ts` module text per spec §6.4.
+ * Empty input (no `_middleware.ts` files OR no routes have a chain) emits
+ * a stub module with an empty map — importers don't break on a fresh
+ * clone before any middleware exists.
+ *
+ * Deviation from the spec's illustrative `MiddlewareFn[]` shape: we emit
+ * `MiddlewareDef[]` so both `beforeEnter` AND `afterLeave` are reachable
+ * from a single map. The runtime (Stage 3) iterates the def's `.beforeEnter`
+ * and `.afterLeave` properties directly.
+ */
+export const emitRouterMiddleware = (middleware, chains) => {
+    const header = [
+        "// router-middleware.generated.ts — DO NOT EDIT",
+        "// Regenerated by @reactra/vite-plugin on every `_middleware.ts` change.",
+        "// Spec: reactra-router-spec.md §6 + phase-2.md Wave 3 / Stage 2.",
+        "",
+        'import type { MiddlewareDef } from "@reactra/router"',
+    ];
+    if (middleware.length === 0) {
+        return [
+            ...header,
+            "",
+            "export const middlewareChains: Record<string, MiddlewareDef[]> = {}",
+            "",
+        ].join("\n");
+    }
+    // Default-import each unique `_middleware.ts` file. The user's
+    // `export default defineMiddleware(...)` is the imported value.
+    const imports = middleware.map((m) => `import ${m.identifier} from ${JSON.stringify(m.importSpecifier)}`);
+    // Emit chains in route-path-sorted order for byte-stability.
+    const sortedKeys = [...chains.keys()].sort();
+    const rows = [];
+    for (const routePath of sortedKeys) {
+        const chain = chains.get(routePath);
+        if (chain.length === 0)
+            continue;
+        rows.push(`  ${JSON.stringify(routePath)}: [${chain
+            .map((m) => m.identifier)
+            .join(", ")}],`);
+    }
+    return [
+        ...header,
+        ...imports,
+        "",
+        "export const middlewareChains: Record<string, MiddlewareDef[]> = {",
+        ...rows,
+        "}",
+        "",
+    ].join("\n");
+};
+// ─── ─────────────────────────────────────────────────────────────────────
+/**
+ * Turn an absolute source path under `<projectRoot>/src/` into a
+ * `./`-prefixed, extension-stripped import specifier. The generated
+ * manifest sits at `<projectRoot>/src/routeManifest.generated.ts`, so
+ * specifiers are relative to that file's directory (`src/`).
+ *
+ * Falls back to the raw source path if it's not under `src/` — keeps
+ * the walker from crashing on unusual layouts, even if Vite/TS may not
+ * resolve the resulting import correctly. The bigger concern of
+ * "stores outside src/" is rare enough to defer.
+ */
+const deriveStoreImportSpecifier = (srcRoot, sourcePath) => {
+    const normalisedSrc = srcRoot.replace(/\\/g, "/");
+    const normalisedSource = sourcePath.replace(/\\/g, "/");
+    const prefix = normalisedSrc.endsWith("/") ? normalisedSrc : normalisedSrc + "/";
+    if (!normalisedSource.startsWith(prefix))
+        return normalisedSource;
+    const rel = normalisedSource.slice(prefix.length);
+    return "./" + stripExt(rel);
+};
+/**
+ * Format the routeManifest.generated.ts module text. The output is what the
+ * vite plugin writes to `<projectRoot>/src/routeManifest.generated.ts` on
+ * `buildStart` and on subsequent `src/pages/` watcher events.
+ *
+ * Phase-1 shape: an untyped `ROUTES: RouteConfig[]` array. Typed `RouteId`
+ * / `RouteParams` / `RouteQuery` / `TypedNavigate` exports per Router §5.1
+ * land with #5c (typed query coercion needs the compiler to surface the
+ * `query` declarations into the manifest).
+ *
+ * Import strategy: Day 21 / `#18` — the compiler now also emits
+ * `export default Foo` for `export component Foo` (Pass-9 auto-default-
+ * export), so the manifest uses clean default imports
+ * (`import PageX from "..."`) and references them directly in the
+ * ROUTES array. The Day-13 `pickPageComponent` runtime helper is gone.
+ */
+export const emitRouteManifest = (routes, stores = [], services = []) => {
+    // Day 27 / `#5c-followup`: the tail HMR block needs the live
+    // `RouterRegistry` + `StoreRegistry` runtime references, not just
+    // their types. We import the values when there's anything to apply
+    // a delta against (any routes OR any stores).
+    const hasAnyRuntime = routes.length > 0 || stores.length > 0;
+    const hasRoutes = routes.length > 0;
+    // Build the single `@reactra/router` value-import line. RouterRegistry
+    // is needed by the HMR tail (any routes OR stores); buildPath +
+    // baseNavigate back the typed `navigate` (#5c-typed — routes only).
+    const routerValueImports = [];
+    if (hasAnyRuntime)
+        routerValueImports.push("RouterRegistry");
+    if (hasRoutes)
+        routerValueImports.push("buildPath", "navigate as baseNavigate", "RouteLink as baseRouteLink");
+    const header = [
+        "// routeManifest.generated.ts — DO NOT EDIT",
+        "// Regenerated by @reactra/vite-plugin on every src/ Reactra-source change.",
+        "// Phase 1 shape: typed RouteId / RouteParams / RouteQuery + a typed",
+        "// `navigate` (#5c-typed), plus untyped ROUTES + STORES arrays and an",
+        "// HMR-accept tail (Day 27 / #5c-followup) so manifest changes apply via",
+        "// delta-reconcile instead of forcing a page reload. RouteQuery is a",
+        "// permissive placeholder until the compiler surfaces `query foo: T`",
+        "// declarations into the manifest.",
+        "",
+        ...(hasRoutes
+            ? ['import type { RouteConfig, RouteLinkProps as BaseRouteLinkProps } from "@reactra/router"']
+            : ['import type { RouteConfig } from "@reactra/router"']),
+        // §5.2 automatic code-splitting: each route's component is `lazy()`-loaded
+        // so its chunk is fetched on demand (the router wraps it in <Suspense>).
+        ...(hasRoutes ? ['import { lazy } from "react"'] : []),
+        // The `StoreBinding` type import is unconditional because STORES is —
+        // see the STORES emission below. Type-only, so it's erased at runtime.
+        'import type { StoreBinding } from "@reactra/store"',
+        // Phase 3: `ServiceBinding` type import is also unconditional (SERVICES
+        // is always emitted). Mirrors the StoreBinding import above.
+        'import type { ServiceBinding } from "@reactra/service"',
+        ...(routerValueImports.length > 0
+            ? [
+                // Value imports. The HMR-tail use of RouterRegistry/StoreRegistry
+                // is tree-shaken in prod (the `if (import.meta.hot)` guard is
+                // false at build time so Rollup drops the block + these imports);
+                // buildPath + baseNavigate stay (the typed `navigate` is live app
+                // code).
+                `import { ${routerValueImports.join(", ")} } from "@reactra/router"`,
+            ]
+            : []),
+        ...(hasAnyRuntime ? ['import { StoreRegistry } from "@reactra/store"'] : []),
+    ];
+    // §5.2 automatic code-splitting: routes are NO LONGER eagerly imported.
+    // Each ROUTES row inlines `component: lazy(() => import("./pages/..."))`, so
+    // Rollup splits every page into its own on-demand chunk. (`componentIdentifier`
+    // is retained on DiscoveredRoute for tooling but no longer emitted as an import.)
+    // Day 20 / `#5c`: store imports stay named + EAGER (the compiler emits
+    // `export const <name>`; stores back the registry and aren't route-gated). One
+    // named import per store discovered by `scanStores`.
+    const storeImports = stores.map((s) => `import { ${s.name} } from ${JSON.stringify(s.importSpecifier)}`);
+    // Phase 3: service imports — named + EAGER, mirroring store imports. One named
+    // import per exported service discovered by `scanServices`.
+    const serviceImports = services.map((s) => `import { ${s.name} } from ${JSON.stringify(s.importSpecifier)}`);
+    // §2.3 `_loading.tsx`: collect unique nearest-ancestor loading files and emit
+    // EAGER imports (the fallback must render synchronously when the route's lazy
+    // chunk suspends — a lazy fallback would itself need a fallback). Multiple
+    // routes that share an ancestor `_loading.tsx` dedupe to one import.
+    const loadingMap = new Map(); // specifier → identifier
+    for (const r of routes)
+        if (r.loading)
+            loadingMap.set(r.loading.specifier, r.loading.identifier);
+    const loadingImports = [...loadingMap.entries()].map(([specifier, identifier]) => `import ${identifier} from ${JSON.stringify(specifier)}`);
+    // §2.3 `_error.tsx`: same dedup + eager-import treatment as `_loading.tsx`
+    // (a lazy error UI that itself suspends would render as a loading state).
+    const errorMap = new Map(); // specifier → identifier
+    for (const r of routes)
+        if (r.errorBoundary)
+            errorMap.set(r.errorBoundary.specifier, r.errorBoundary.identifier);
+    const errorImports = [...errorMap.entries()].map(([specifier, identifier]) => `import ${identifier} from ${JSON.stringify(specifier)}`);
+    // §2.3 `_layout.tsx`: dedup the union of every route's layout chain. Eager
+    // imports so layouts persist around a (suspending) page below — only the page
+    // area shows the route's loading fallback. Multiple routes sharing an
+    // ancestor layout resolve to the same identifier (single import line).
+    const layoutMap = new Map(); // specifier → identifier
+    for (const r of routes)
+        if (r.layouts)
+            for (const l of r.layouts)
+                layoutMap.set(l.specifier, l.identifier);
+    const layoutImports = [...layoutMap.entries()].map(([specifier, identifier]) => `import ${identifier} from ${JSON.stringify(specifier)}`);
+    const imports = [...layoutImports, ...loadingImports, ...errorImports, ...storeImports, ...serviceImports];
+    const body = [
+        "",
+        "export const ROUTES: RouteConfig[] = [",
+        ...routes.map((r) => {
+            const spec = JSON.stringify(r.importSpecifier);
+            // §5.5 prefetch: `preload` is the same dynamic import as `component`'s
+            // lazy() — a bare thunk PrefetchRuntime calls to warm the chunk ahead of
+            // navigation (Rollup dedups them into one chunk).
+            const head = `  { id: ${JSON.stringify(r.id)}, path: ${JSON.stringify(r.path)}, ` +
+                `component: lazy(() => import(${spec})), preload: () => import(${spec})`;
+            // §5.5: the page's declared prefetch policy, so a RouteLink with no
+            // `prefetch` prop inherits the destination's trigger.
+            const prefetchPart = r.prefetch != null ? `, prefetch: { trigger: ${JSON.stringify(r.prefetch)} }` : "";
+            // §2.3 `_loading.tsx`: the route's nearest-ancestor loading component;
+            // RouteRenderer uses it as the Suspense fallback in place of the global one.
+            const loadingPart = r.loading != null ? `, loading: ${r.loading.identifier}` : "";
+            // §2.3 `_error.tsx`: nearest-ancestor error boundary; RouteRenderer wraps
+            // the route in `<RouteErrorBoundary>` rendering it on a render-time throw.
+            const errorPart = r.errorBoundary != null ? `, errorBoundary: ${r.errorBoundary.identifier}` : "";
+            // §2.3 `_layout.tsx`: full ancestor chain (outermost-first); RouteRenderer
+            // nests them around the page so layouts persist while the page area
+            // suspends. Emitted only when non-empty so an outerless route stays clean.
+            const layoutsPart = r.layouts && r.layouts.length > 0
+                ? `, layouts: [${r.layouts.map((l) => l.identifier).join(", ")}]`
+                : "";
+            const tail = r.bindingsName != null ? `, bindingsName: ${JSON.stringify(r.bindingsName)} }` : " }";
+            return head + prefetchPart + loadingPart + errorPart + layoutsPart + tail + ",";
+        }),
+        "]",
+        // STORES is emitted even when empty: `main.tsx`'s documented bootstrap
+        // (`configureStores({ stores: STORES })`) and the HMR tail both import it
+        // unconditionally, so a store-less app (e.g. examples/checkout-replay)
+        // must still find the export.
+        "",
+        "// Day 20 / #5c: stores discovered via source-regex scan of",
+        "// src/. `main.tsx` does `configureStores({ stores: STORES })`",
+        "// instead of hand-importing each binding — new store files",
+        "// under src/ are picked up automatically on the next watcher",
+        "// event.",
+        "export const STORES: StoreBinding[] = [",
+        ...stores.map((s) => `  ${s.name},`),
+        "]",
+        // SERVICES is emitted even when empty — mirrors STORES; `main.tsx` bootstrap
+        // uses `configureServices({ services: SERVICES })`. A service-less app must
+        // still find the export so the import doesn't break on a fresh clone.
+        "",
+        "// Phase 3: services discovered via preprocess()-based scan of src/.",
+        "// `main.tsx` does `configureServices({ services: SERVICES })`",
+        "// instead of hand-listing each binding.",
+        "export const SERVICES: ServiceBinding[] = [",
+        ...services.map((s) => `  ${s.name},`),
+        "]",
+        ...(hasRoutes
+            ? [
+                "",
+                "// #5c-typed: compiler-derived navigation types. RouteId is the",
+                "// union of route patterns; RouteParams maps each to its `:name`",
+                "// params (or never); RouteQuery maps each to its `query foo: T`",
+                "// schema (every field optional — query params are omittable in a",
+                "// URL) or `Record<string, never>` when the page declares no query.",
+                "export type RouteId =",
+                ...routes.map((r) => `  | ${JSON.stringify(r.path)}`),
+                "",
+                "export type RouteParams = {",
+                ...routes.map((r) => {
+                    const params = extractParamNames(r.path);
+                    const value = params.length > 0
+                        ? `{ ${params.map((n) => `${n}: string`).join("; ")} }`
+                        : "never";
+                    return `  ${JSON.stringify(r.path)}: ${value}`;
+                }),
+                "}",
+                "",
+                "export type RouteQuery = {",
+                ...routes.map((r) => {
+                    const qs = r.queries ?? [];
+                    const value = qs.length > 0
+                        ? `{ ${qs.map((q) => `${q.name}?: ${q.tsType}`).join("; ")} }`
+                        : "Record<string, never>";
+                    return `  ${JSON.stringify(r.path)}: ${value}`;
+                }),
+                "}",
+                "",
+                "// Two deviations from Router §5.1's illustrative type, both to",
+                "// correctly implement §5.3's stated intent (RO001/RO002/RO003 are",
+                "// build errors):",
+                "//   1. `[RouteParams[R]] extends [never]` (tuple-wrapped) — the",
+                "//      naked `RouteParams[R] extends never` distributes over the",
+                "//      empty union and collapses the no-param branch to `never`.",
+                "//   2. a variadic REST tuple instead of `options?` — an optional",
+                "//      `options` lets `navigate(\"/customers/:id\")` compile (RO002",
+                "//      not caught). The rest tuple makes options REQUIRED for",
+                "//      param routes and optional for no-param routes.",
+                "export type TypedNavigate = {",
+                "  <R extends RouteId>(",
+                "    route: R,",
+                "    ...args: [RouteParams[R]] extends [never]",
+                "      ? [options?: { query?: RouteQuery[R]; replace?: boolean }]",
+                "      : [options: { params: RouteParams[R]; query?: RouteQuery[R]; replace?: boolean }]",
+                "  ): void",
+                "}",
+                "",
+                "// Typed navigation entry point (Router §5.3). Delegates to the",
+                "// runtime buildPath + base navigate; the types above make a wrong",
+                "// or missing param a build error. The spec's `(delta: number)`",
+                "// history.go overload is deferred to a later session.",
+                "export const navigate: TypedNavigate = ((",
+                "  route: RouteId,",
+                "  options?: { params?: Record<string, string>; query?: Record<string, string>; replace?: boolean },",
+                ") => {",
+                "  baseNavigate(buildPath(route, options?.params, options?.query), options?.replace ?? false)",
+                "}) as TypedNavigate",
+                "",
+                "// Typed <RouteLink>: `to` is checked against RouteId, and `params` /",
+                "// `query` against that route's RouteParams / RouteQuery (params is",
+                "// required for routes with `:name` segments, forbidden otherwise). All",
+                "// non-routing anchor props are inherited from the runtime RouteLinkProps.",
+                "export type RouteLinkProps<R extends RouteId> =",
+                '  Omit<BaseRouteLinkProps, "to" | "params" | "query"> & { to: R } & ([RouteParams[R]] extends [never]',
+                "    ? { params?: undefined; query?: RouteQuery[R] }",
+                "    : { params: RouteParams[R]; query?: RouteQuery[R] })",
+                "",
+                "export const RouteLink = <R extends RouteId>(props: RouteLinkProps<R>) =>",
+                "  baseRouteLink(props as unknown as BaseRouteLinkProps)",
+            ]
+            : []),
+        ...(hasAnyRuntime
+            ? [
+                "",
+                "// Day 27 / #5c-followup: HMR-accept the manifest module so",
+                "// add/remove of route + store files reconciles into the live",
+                "// registries instead of forcing a page reload. Per-file edits",
+                "// to a store's body still flow through the Day-16 #11 per-store",
+                "// accept block; THIS block handles the manifest-shape changes",
+                "// (new file appears under src/, file removed) that the per-file",
+                "// blocks can't see.",
+                "if (import.meta.hot) {",
+                "  import.meta.hot.accept((newMod) => {",
+                "    if (!newMod) return",
+                "    StoreRegistry.applyDelta(newMod.STORES ?? [])",
+                "    RouterRegistry.replaceRoutes(newMod.ROUTES ?? [])",
+                "  })",
+                "}",
+            ]
+            : []),
+        "",
+    ];
+    return header.concat(imports.length > 0 ? [""] : [], imports, body).join("\n");
+};
+//# sourceMappingURL=walker.js.map