@warlock.js/web 5.0.2 → 5.2.0

package/esm/vite/page-registry-plugin.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"page-registry-plugin.mjs","names":[],"sources":["../../../../../../../web/src/vite/page-registry-plugin.ts"],"sourcesContent":["/**\n * The wire between the two halves that already existed and never met:\n * `discoverPages` (the page graph, read off disk) and `generateClientRegistry`\n * (the module SOURCE that carries that graph into the browser). Neither one\n * touches Vite; this plugin is the only place they are joined, and it joins\n * them as a VIRTUAL module so nothing is ever written to the user's tree.\n *\n * Identical in dev and build — no `apply`/`command` gating, matching the rest\n * of `warlockClientBoundary`'s composition (`index.ts`), which is also\n * mode-agnostic. A registry that differed between `vite dev` and `vite build`\n * would make every dev-only or prod-only page bug unreproducible in the other\n * mode.\n */\nimport { parse } from \"@babel/parser\";\nimport MagicString from \"magic-string\";\nimport path from \"node:path\";\nimport type { Plugin } from \"vite\";\nimport { discoverPages, toPosix } from \"../build/discover-pages\";\nimport { generateClientRegistry } from \"../build/generate-client-registry\";\n\n/**\n * The specifier application code writes.\n *\n * Exported so the client runtime imports this constant instead of retyping the\n * string: a constant two sides must agree on is a guard, and a guard duplicated\n * at a second site fails open at the third — a typo'd re-spelling doesn't fail\n * loudly, it resolves to \"no such module\" or, worse, to a stale real file.\n */\nexport const CLIENT_PAGE_REGISTRY_ID = \"virtual:warlock/pages\";\n\n/**\n * The resolved id, `\\0`-prefixed per Vite/Rollup convention so no other plugin\n * (and no filesystem watcher) mistakes it for a real path.\n */\nexport const RESOLVED_CLIENT_PAGE_REGISTRY_ID = `\\0${CLIENT_PAGE_REGISTRY_ID}`;\n\nexport type ClientPageRegistryPluginOptions = {\n  /** Absolute path to the application root. Defaults to `process.cwd()`, matching Vite's own default `root` and Gate A's `appRoot` default. */\n  appRoot?: string;\n  /** Source directory name under `appRoot`; forwarded verbatim to `discoverPages`, which defaults it to `\"src\"`. */\n  srcDir?: string;\n};\n\n/**\n * The import specifiers the emitted registry names must be ABSOLUTE POSIX file\n * paths, never relative ones.\n *\n * A relative specifier resolves against its IMPORTER, and the importer here is\n * `\\0virtual:warlock/pages` — a synthetic id whose `dirname` is not a real\n * directory. `./blog.page.tsx` from that importer resolves to nonsense that\n * fails at bundle time with a path no user authored and no user can act on.\n *\n * Separator normalization is `hydration-entries.ts`'s\n * (`hydration-entries.ts:12-14`) and `discover-pages.ts`'s single\n * `.replace(/\\\\/g, \"/\")` rule, reused via the already-exported `toPosix` rather\n * than spelled a third time — keeping the drive colon (`D:/...`) is exactly\n * what Vite's resolver wants on Windows.\n */\nfunction toImportSpecifier(absoluteFilePath: string): string {\n  return toPosix(path.resolve(absoluteFilePath));\n}\n\n/**\n * Erases the generated module's TypeScript down to plain JavaScript.\n *\n * NOT optional, and not a style choice. Vite's `vite:esbuild` transform is\n * gated behind `createFilter`, which refuses ANY id containing a NUL byte\n * (`node_modules/vite/dist/node/chunks/config.js:1512` — `if\n * (id.includes(\"\\0\")) return false`). So the one module in this build that is\n * `\\0`-prefixed by convention is precisely the one module esbuild will never\n * transform, while `generateClientRegistry` always emits TypeScript (a\n * type-only `ClientPageEntry` import plus the array's type annotation). Handed\n * to Rollup verbatim, `import type { ClientPageEntry } from ...` is a\n * JavaScript syntax error.\n *\n * Done with the AST rather than a regex, using the same `@babel/parser` +\n * `MagicString` pair `projection.ts` already uses in this directory — a regex\n * over generated source is a second grammar that drifts from the generator's\n * silently. If the generator ever emits a TS construct outside these two\n * shapes, the result is a Rollup parse error naming the virtual module: loud,\n * not silent. `page-registry-plugin.spec.ts` pins that the erased output\n * re-parses as plain JavaScript with the TypeScript plugin switched OFF.\n */\nfunction eraseTypes(source: string): string {\n  const ast = parse(source, { sourceType: \"module\", plugins: [\"typescript\"] });\n  const magic = new MagicString(source);\n\n  for (const statement of ast.program.body as any[]) {\n    if (statement.type === \"ImportDeclaration\" && statement.importKind === \"type\") {\n      let end = statement.end as number;\n      if (source[end] === \"\\r\" && source[end + 1] === \"\\n\") end += 2;\n      else if (source[end] === \"\\n\") end += 1;\n      magic.remove(statement.start as number, end);\n      continue;\n    }\n\n    const declaration =\n      statement.type === \"ExportNamedDeclaration\" ? statement.declaration : statement;\n\n    if (declaration?.type !== \"VariableDeclaration\") continue;\n\n    for (const declarator of declaration.declarations as any[]) {\n      const annotation = declarator.id?.typeAnnotation;\n      if (annotation) magic.remove(annotation.start as number, annotation.end as number);\n    }\n  }\n\n  return magic.toString();\n}\n\n/**\n * Serves the client page registry at {@link CLIENT_PAGE_REGISTRY_ID}.\n *\n * Discovery runs INSIDE `load`, once per `load` call, and its result is NOT\n * cached across builds — the plugin holds no state at all. A registry cached\n * past the moment a page file appears is a page that silently 404s until\n * someone restarts the dev server, which is a far more expensive bug than\n * re-walking a source tree. Rollup calls `load` once per module per build, and\n * in dev Vite's module graph caches the transformed result until the module is\n * invalidated, so the walk is not per-request either way. (Invalidating that\n * dev-server cache when a page file is ADDED needs a `handleHotUpdate`/watcher\n * hook that belongs with the dev provider slice — see the followup.)\n *\n * `enforce: \"pre\"` and placed FIRST in `warlockClientBoundary`'s array — see\n * that function's comment in `index.ts` for why position is what it is, and\n * `page-registry-plugin.spec.ts` for the real-build proof that the pages this\n * module names still reach `projection()`.\n */\nexport function clientPageRegistry(options: ClientPageRegistryPluginOptions = {}): Plugin {\n  const appRoot = path.resolve(options.appRoot ?? process.cwd());\n\n  return {\n    name: \"warlock:client-page-registry\",\n    enforce: \"pre\",\n    resolveId(source) {\n      if (source === CLIENT_PAGE_REGISTRY_ID) return RESOLVED_CLIENT_PAGE_REGISTRY_ID;\n      return undefined;\n    },\n    load(id) {\n      if (id !== RESOLVED_CLIENT_PAGE_REGISTRY_ID) return undefined;\n\n      const pages = discoverPages({ appRoot, srcDir: options.srcDir });\n\n      return eraseTypes(generateClientRegistry({ pages, toImportSpecifier }));\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,MAAa,0BAA0B;;;;;AAMvC,MAAa,mCAAmC,KAAK;;;;;;;;;;;;;;;;AAwBrD,SAAS,kBAAkB,kBAAkC;CAC3D,OAAO,QAAQ,KAAK,QAAQ,gBAAgB,CAAC;AAC/C;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAS,WAAW,QAAwB;CAC1C,MAAM,MAAM,MAAM,QAAQ;EAAE,YAAY;EAAU,SAAS,CAAC,YAAY;CAAE,CAAC;CAC3E,MAAM,QAAQ,IAAI,YAAY,MAAM;CAEpC,KAAK,MAAM,aAAa,IAAI,QAAQ,MAAe;EACjD,IAAI,UAAU,SAAS,uBAAuB,UAAU,eAAe,QAAQ;GAC7E,IAAI,MAAM,UAAU;GACpB,IAAI,OAAO,SAAS,QAAQ,OAAO,MAAM,OAAO,MAAM,OAAO;QACxD,IAAI,OAAO,SAAS,MAAM,OAAO;GACtC,MAAM,OAAO,UAAU,OAAiB,GAAG;GAC3C;EACF;EAEA,MAAM,cACJ,UAAU,SAAS,2BAA2B,UAAU,cAAc;EAExE,IAAI,aAAa,SAAS,uBAAuB;EAEjD,KAAK,MAAM,cAAc,YAAY,cAAuB;GAC1D,MAAM,aAAa,WAAW,IAAI;GAClC,IAAI,YAAY,MAAM,OAAO,WAAW,OAAiB,WAAW,GAAa;EACnF;CACF;CAEA,OAAO,MAAM,SAAS;AACxB;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,mBAAmB,UAA2C,CAAC,GAAW;CACxF,MAAM,UAAU,KAAK,QAAQ,QAAQ,WAAW,QAAQ,IAAI,CAAC;CAE7D,OAAO;EACL,MAAM;EACN,SAAS;EACT,UAAU,QAAQ;GAChB,IAAI,oCAAoC,OAAO;EAEjD;EACA,KAAK,IAAI;GACP,IAAI,OAAO,kCAAkC,OAAO;GAIpD,OAAO,WAAW,uBAAuB;IAAE,OAF7B,cAAc;KAAE;KAAS,QAAQ,QAAQ;IAAO,CAEf;IAAG;GAAkB,CAAC,CAAC;EACxE;CACF;AACF"}
+{"version":3,"file":"page-registry-plugin.mjs","names":[],"sources":["C:/Work/Warlock.js/web/src/vite/page-registry-plugin.ts"],"sourcesContent":["/**\n * The wire between the two halves that already existed and never met:\n * `discoverPages` (the page graph, read off disk) and `generateClientRegistry`\n * (the module SOURCE that carries that graph into the browser). Neither one\n * touches Vite; this plugin is the only place they are joined, and it joins\n * them as a VIRTUAL module so nothing is ever written to the user's tree.\n *\n * Identical in dev and build — no `apply`/`command` gating, matching the rest\n * of `warlockClientBoundary`'s composition (`index.ts`), which is also\n * mode-agnostic. A registry that differed between `vite dev` and `vite build`\n * would make every dev-only or prod-only page bug unreproducible in the other\n * mode.\n */\nimport { parse } from \"@babel/parser\";\nimport MagicString from \"magic-string\";\nimport path from \"node:path\";\nimport type { Plugin, ViteDevServer } from \"vite\";\nimport { discoverPages, toPosix } from \"../build/discover-pages\";\nimport { generateClientRegistry } from \"../build/generate-client-registry\";\nimport { SERVER_EXPORT_NAMES } from \"./projection\";\n\n/**\n * The specifier application code writes.\n *\n * Exported so the client runtime imports this constant instead of retyping the\n * string: a constant two sides must agree on is a guard, and a guard duplicated\n * at a second site fails open at the third — a typo'd re-spelling doesn't fail\n * loudly, it resolves to \"no such module\" or, worse, to a stale real file.\n */\nexport const CLIENT_PAGE_REGISTRY_ID = \"virtual:warlock/pages\";\n\n/**\n * The resolved id, `\\0`-prefixed per Vite/Rollup convention so no other plugin\n * (and no filesystem watcher) mistakes it for a real path.\n */\nexport const RESOLVED_CLIENT_PAGE_REGISTRY_ID = `\\0${CLIENT_PAGE_REGISTRY_ID}`;\n\n/**\n * Evicts the client registry so its next request re-runs page discovery, then\n * reloads the document so hydration consumes that fresh registry.\n *\n * Vite 7 keeps separate module graphs per environment. Pages are imported by\n * the browser, so only the resolved virtual module in the client graph is the\n * cache entry this operation owns.\n */\nexport function invalidateClientPageRegistry(vite: ViteDevServer): void {\n  const moduleGraph = vite.environments.client.moduleGraph;\n  const registryModule = moduleGraph.getModuleById(RESOLVED_CLIENT_PAGE_REGISTRY_ID);\n\n  if (registryModule) moduleGraph.invalidateModule(registryModule);\n\n  vite.hot.send({ type: \"full-reload\", path: \"*\" });\n}\n\nexport type ClientPageRegistryPluginOptions = {\n  /** Absolute path to the application root. Defaults to `process.cwd()`, matching Vite's own default `root` and Gate A's `appRoot` default. */\n  appRoot?: string;\n  /** Source directory name under `appRoot`; forwarded verbatim to `discoverPages`, which defaults it to `\"src\"`. */\n  srcDir?: string;\n  /**\n   * Optional server-side barrier run before this plugin decides how the browser\n   * receives a page update. `true` means the callback already published the\n   * new route graph and sent the required reload, so this hook emits no second\n   * update for the same filesystem event.\n   */\n  beforePageHotUpdate?: (context: {\n    file: string;\n    type: \"create\" | \"update\" | \"delete\";\n  }) => boolean | Promise<boolean>;\n};\n\n/**\n * The import specifiers the emitted registry names must be ABSOLUTE POSIX file\n * paths, never relative ones.\n *\n * A relative specifier resolves against its IMPORTER, and the importer here is\n * `\\0virtual:warlock/pages` — a synthetic id whose `dirname` is not a real\n * directory. `./blog.page.tsx` from that importer resolves to nonsense that\n * fails at bundle time with a path no user authored and no user can act on.\n *\n * Separator normalization is `hydration-entries.ts`'s\n * (`hydration-entries.ts:12-14`) and `discover-pages.ts`'s single\n * `.replace(/\\\\/g, \"/\")` rule, reused via the already-exported `toPosix` rather\n * than spelled a third time — keeping the drive colon (`D:/...`) is exactly\n * what Vite's resolver wants on Windows.\n */\nfunction toImportSpecifier(absoluteFilePath: string): string {\n  return toPosix(path.resolve(absoluteFilePath));\n}\n\n/**\n * Erases the generated module's TypeScript down to plain JavaScript.\n *\n * NOT optional, and not a style choice. Vite's `vite:esbuild` transform is\n * gated behind `createFilter`, which refuses ANY id containing a NUL byte\n * (`node_modules/vite/dist/node/chunks/config.js:1512` — `if\n * (id.includes(\"\\0\")) return false`). So the one module in this build that is\n * `\\0`-prefixed by convention is precisely the one module esbuild will never\n * transform, while `generateClientRegistry` always emits TypeScript (a\n * type-only `ClientPageEntry` import plus the array's type annotation). Handed\n * to Rollup verbatim, `import type { ClientPageEntry } from ...` is a\n * JavaScript syntax error.\n *\n * Done with the AST rather than a regex, using the same `@babel/parser` +\n * `MagicString` pair `projection.ts` already uses in this directory — a regex\n * over generated source is a second grammar that drifts from the generator's\n * silently. If the generator ever emits a TS construct outside these two\n * shapes, the result is a Rollup parse error naming the virtual module: loud,\n * not silent. `page-registry-plugin.spec.ts` pins that the erased output\n * re-parses as plain JavaScript with the TypeScript plugin switched OFF.\n */\nfunction eraseTypes(source: string): string {\n  const ast = parse(source, { sourceType: \"module\", plugins: [\"typescript\"] });\n  const magic = new MagicString(source);\n\n  for (const statement of ast.program.body as any[]) {\n    if (statement.type === \"ImportDeclaration\" && statement.importKind === \"type\") {\n      let end = statement.end as number;\n      if (source[end] === \"\\r\" && source[end + 1] === \"\\n\") end += 2;\n      else if (source[end] === \"\\n\") end += 1;\n      magic.remove(statement.start as number, end);\n      continue;\n    }\n\n    const declaration =\n      statement.type === \"ExportNamedDeclaration\" ? statement.declaration : statement;\n\n    if (declaration?.type !== \"VariableDeclaration\") continue;\n\n    for (const declarator of declaration.declarations as any[]) {\n      const annotation = declarator.id?.typeAnnotation;\n      if (annotation) magic.remove(annotation.start as number, annotation.end as number);\n    }\n  }\n\n  return magic.toString();\n}\n\n/**\n * The four file shapes that carry SERVER data (`metadata` chief among them)\n * and are therefore projected before the client graph forms — the exact set\n * `projection.ts`'s `isProjectableFile` matches, spelled here by BASENAME so\n * the two agree by construction on what \"a server-side page module\" is. A\n * change to one of these is the only kind of change whose SERVER half\n * (`metadata`, `loader`, …) can move without the client half moving at all.\n */\nfunction isServerPageModule(file: string): boolean {\n  const base = path.basename(file.split(\"?\")[0]);\n  if (/\\.page\\.tsx?$/.test(base)) return true;\n  if (base === \"layout.tsx\" || base === \"layout.ts\") return true;\n  if (/\\.layout\\.tsx?$/.test(base)) return true;\n  if (base === \"root.tsx\") return true;\n  return false;\n}\n\n/**\n * The server-vs-client reload seam.\n *\n * A page module carries TWO halves. The CLIENT half is the projected code the\n * browser actually runs; Fast Refresh can hot-swap it with zero reloads. The\n * SERVER half — `metadata`, `loader`, `route`, `middleware`, `validation`, `prefix`, plus\n * the imports/locals orphaned with them — is stripped by projection\n * (`projection.ts:49`) and set to `undefined` on hydration\n * (`client/hydrate-page.tsx`), so the browser never holds it and there is\n * nothing on the client to hot-swap. Its effect is felt only when SSR re-runs\n * and re-renders `<head>`; the honest way to apply a change to it is a full\n * document reload.\n *\n * THE RULING (canon `6b240682`), stated as the invariant it is:\n *\n *   FAST REFRESH ONLY WHEN THE ONLY CHANGES ARE INSIDE COMPONENT BODIES.\n *   EVERYTHING ELSE RELOADS.\n *\n * Concretely: any change to an import statement, to a module-level\n * declaration, or to a server export forces a full document reload — whether\n * or not the JSX moved in the same save.\n *\n * WHY AN OVER-APPROXIMATION, AND WHY NOBODY SHOULD \"IMPROVE\" IT BACK\n *\n * Two earlier cuts tried to name the server half EXACTLY and both shipped a\n * stale `<head>`:\n *\n *   1. Comparing only the projected CLIENT code. A save that changed the JSX\n *      *and* `metadata` moved the client half, which was read as proof that\n *      only the JSX moved. Mixed saves took the Fast Refresh branch.\n *   2. Adding the complement — the stripped server half, recovered by\n *      subsequence diff. `projection.ts:447-448` KEEPS an import when the\n *      client reads it, so an import read by BOTH `metadata` and the JSX\n *      lives in the projection and appears in NEITHER half exclusively.\n *      Change its specifier and the complement is byte-identical → Fast\n *      Refresh, stale `<title>`. Shared module-level LOCALS have the same\n *      shape, so extending the complement a third time is a third bug.\n *\n * Both failures were UNDER-approximations, and under-approximating is the\n * unsafe direction. A precise reachability analysis over shared imports and\n * locals is the correct answer and is a later refinement; getting it subtly\n * wrong reproduces this bug again. Over-approximating can only err toward\n * RELOADING. A needless reload costs component state; a missed one ships a\n * stale `<head>` and calls it a hot update.\n *\n * THE ACCEPTED COST, which is not a bug to be optimised away: editing a\n * module-level helper read only by the JSX now reloads.\n *\n * The skeleton has to be captured BEFORE the edit, because by the time\n * `hotUpdate` runs Vite has already hard-invalidated the module and cleared its\n * `transformResult` (`onFileChange` → `invalidateModule`, which runs before any\n * `hotUpdate` hook). The `transform` spy below is that capture: it runs first in\n * the client environment, records the skeleton, and returns nothing so\n * projection still performs the real transform.\n */\ntype SkeletonCache = Map<string, string>;\n\n/**\n * What replaces a refresh-safe body in the skeleton. Its content is irrelevant —\n * only that it is CONSTANT, so two sources that differ solely inside a masked\n * body serialise identically.\n */\nconst MASKED_REFRESH_BODY = \"/*warlock:refresh-body*/\";\n\n/** React's own convention, and the one `react-refresh` itself uses: components are PascalCase. */\nfunction isComponentName(name: string | undefined): boolean {\n  return typeof name === \"string\" && /^[A-Z]/.test(name);\n}\n\n/** The `body` node of a function-shaped expression/declaration, or `undefined` for anything else. */\nfunction functionBody(node: any): any | undefined {\n  if (!node) return undefined;\n  if (\n    node.type === \"FunctionDeclaration\" ||\n    node.type === \"FunctionExpression\" ||\n    node.type === \"ArrowFunctionExpression\"\n  ) {\n    return node.body;\n  }\n  return undefined;\n}\n\n/**\n * Generic duck-typed identifier walk, the same shape `projection.ts`'s\n * `collectIdentifierNames` uses (it is not exported, and re-deriving one\n * OVER-collecting walk is safe here for the same reason it is safe there).\n *\n * Over-collecting — counting an object property key or a shadowing parameter\n * as a \"read\" — can only make the reachable set BIGGER, which can only UNMASK\n * more component bodies, which can only produce more reloads. The safe\n * direction.\n */\nfunction collectIdentifierNames(node: unknown, names: Set<string>): void {\n  if (!node || typeof node !== \"object\") return;\n  if (Array.isArray(node)) {\n    for (const item of node) collectIdentifierNames(item, names);\n    return;\n  }\n  const record = node as Record<string, unknown>;\n  if (typeof record.type !== \"string\") return;\n  if (record.type === \"Identifier\" || record.type === \"JSXIdentifier\") {\n    names.add((record as any).name);\n  }\n  for (const key of Object.keys(record)) {\n    if (key === \"type\" || key === \"start\" || key === \"end\" || key === \"loc\" || key === \"range\") continue;\n    if (key === \"leadingComments\" || key === \"trailingComments\" || key === \"innerComments\" || key === \"extra\") {\n      continue;\n    }\n    collectIdentifierNames(record[key], names);\n  }\n}\n\n/** The module-scope names a top-level statement binds (the `export` wrapper looked through). */\nfunction topLevelBoundNames(stmt: any): Set<string> {\n  const names = new Set<string>();\n  const declaration = stmt.type === \"ExportNamedDeclaration\" ? stmt.declaration : stmt;\n  if (!declaration) return names;\n  if (declaration.type === \"VariableDeclaration\") {\n    for (const declarator of declaration.declarations) {\n      if (declarator.id?.type === \"Identifier\") names.add(declarator.id.name);\n    }\n  } else if (declaration.id?.type === \"Identifier\") {\n    names.add(declaration.id.name);\n  }\n  return names;\n}\n\n/**\n * Every module-scope name reachable from one of the six server exports.\n *\n * Used ONLY to UNMASK: a PascalCase function that `metadata` or `loader` can\n * reach is not a component for this purpose, it is a server-side helper that\n * merely looks like one, and a change inside its body must reload. Seeded from\n * any top-level statement binding a `SERVER_EXPORT_NAMES` name — deliberately\n * looser than `projection.ts`'s own `isServerExportDeclaration` (no export\n * requirement, no single-declarator requirement), because seeding from MORE\n * statements can only unmask more, i.e. reload more.\n *\n * Fixpoint, not one pass, for the same reason projection's is: a server-only\n * helper can be reached only through another server-only helper.\n */\nfunction serverReachableNames(body: any[]): Set<string> {\n  const reached = new Set<string>();\n  const declarations = body\n    .filter((stmt) => stmt.type !== \"ImportDeclaration\")\n    .map((stmt) => ({ stmt, names: topLevelBoundNames(stmt) }));\n\n  for (const { stmt, names } of declarations) {\n    let isServerExport = false;\n    for (const name of names) {\n      if (SERVER_EXPORT_NAMES.has(name)) isServerExport = true;\n    }\n    if (isServerExport) collectIdentifierNames(stmt, reached);\n  }\n\n  for (let changed = true; changed; ) {\n    changed = false;\n    for (const { stmt, names } of declarations) {\n      let isReached = false;\n      for (const name of names) {\n        if (reached.has(name)) isReached = true;\n      }\n      if (!isReached) continue;\n      const before = reached.size;\n      collectIdentifierNames(stmt, reached);\n      if (reached.size !== before) changed = true;\n    }\n  }\n\n  return reached;\n}\n\n/**\n * The body node to mask for a top-level statement, or `undefined` if this\n * statement is neither a component declaration nor an exported `register`\n * declaration.\n *\n * Recognised shapes, and only these:\n *   - `export default function () {…}` / `export default () => …` — the page\n *     component, whatever it is called.\n *   - `function Name() {…}` / `const Name = () => …` (PascalCase, optionally\n *     `export`ed) — a component declared alongside it.\n *   - `export function register() {…}` / `export const register = () => …` —\n *     the lifecycle hook whose replacement namespace is invoked by projection.\n *\n * Everything else — `memo(...)`/`forwardRef(...)` wrappers, classes,\n * lowercase helpers, every server export — is left UNMASKED and therefore\n * compared byte-for-byte. That costs Fast Refresh on those shapes and buys the\n * guarantee; see this seam's header.\n */\nfunction componentBodyToMask(stmt: any, serverReachable: Set<string>): any | undefined {\n  if (stmt.type === \"ExportDefaultDeclaration\") return functionBody(stmt.declaration);\n\n  if (stmt.type === \"ExportNamedDeclaration\") {\n    const exported = stmt.declaration;\n    if (exported?.type === \"FunctionDeclaration\" && exported.id?.name === \"register\") {\n      return functionBody(exported);\n    }\n    if (exported?.type === \"VariableDeclaration\" && exported.declarations.length === 1) {\n      const declarator = exported.declarations[0];\n      if (declarator.id?.type === \"Identifier\" && declarator.id.name === \"register\") {\n        return functionBody(declarator.init);\n      }\n    }\n  }\n\n  const declaration = stmt.type === \"ExportNamedDeclaration\" ? stmt.declaration : stmt;\n  if (!declaration) return undefined;\n\n  const named = (name: string | undefined, node: any) =>\n    isComponentName(name) && !serverReachable.has(name as string) ? functionBody(node) : undefined;\n\n  if (declaration.type === \"FunctionDeclaration\") {\n    return named(declaration.id?.name, declaration);\n  }\n  if (declaration.type === \"VariableDeclaration\" && declaration.declarations.length === 1) {\n    const declarator = declaration.declarations[0];\n    if (declarator.id?.type !== \"Identifier\") return undefined;\n    return named(declarator.id.name, declarator.init);\n  }\n  return undefined;\n}\n\n/**\n * The module source with every component and exported `register` body replaced\n * by a constant — the ONE value the reload decision compares across an edit.\n *\n * Everything outside those bodies survives verbatim: imports, signatures,\n * module-level declarations, all six server exports, and the comments and\n * whitespace between them. So the skeleton is unchanged iff the save touched\n * nothing but refresh-safe bodies.\n *\n * Returns `undefined` when the source does not parse — a half-typed file whose\n * error Vite is already reporting from projection's real `transform`. The\n * caller leaves the cache holding the last GOOD skeleton, so the next\n * successful save is still compared against the right baseline.\n */\nfunction captureSkeleton(code: string): string | undefined {\n  let ast: ReturnType<typeof parse>;\n  try {\n    ast = parse(code, { sourceType: \"module\", plugins: [\"typescript\", \"jsx\"] });\n  } catch {\n    return undefined;\n  }\n\n  const body = ast.program.body as any[];\n  const serverReachable = serverReachableNames(body);\n  const magic = new MagicString(code);\n\n  for (const stmt of body) {\n    const bodyNode = componentBodyToMask(stmt, serverReachable);\n    if (!bodyNode) continue;\n    const start = bodyNode.start as number;\n    const end = bodyNode.end as number;\n    if (end > start) magic.overwrite(start, end, MASKED_REFRESH_BODY);\n  }\n\n  return magic.toString();\n}\n\n/**\n * Serves the client page registry at {@link CLIENT_PAGE_REGISTRY_ID}.\n *\n * Discovery runs INSIDE `load`, once per `load` call, and its result is NOT\n * cached across builds — the plugin holds no state at all. A registry cached\n * past the moment a page file appears is a page that silently 404s until\n * someone restarts the dev server, which is a far more expensive bug than\n * re-walking a source tree. Rollup calls `load` once per module per build, and\n * in dev Vite's module graph caches the transformed result until the module is\n * invalidated, so the walk is not per-request either way. (Invalidating that\n * dev-server cache when a page file is ADDED needs a `handleHotUpdate`/watcher\n * hook that belongs with the dev provider slice — see the followup.)\n *\n * `enforce: \"pre\"` and placed FIRST in `warlockClientBoundary`'s array — see\n * that function's comment in `index.ts` for why position is what it is, and\n * `page-registry-plugin.spec.ts` for the real-build proof that the pages this\n * module names still reach `projection()`.\n */\nexport function clientPageRegistry(options: ClientPageRegistryPluginOptions = {}): Plugin {\n  const appRoot = path.resolve(options.appRoot ?? process.cwd());\n\n  // Per-plugin-instance, so two composed pipelines never cross-contaminate.\n  // Holds the last captured SKELETON (source with refresh-safe bodies masked) of\n  // each server page module the client environment transformed — the \"before\"\n  // side of the comparison in `hotUpdate`. See `captureSkeleton` above.\n  const skeletonCache: SkeletonCache = new Map();\n\n  return {\n    name: \"warlock:client-page-registry\",\n    enforce: \"pre\",\n    resolveId(source) {\n      if (source === CLIENT_PAGE_REGISTRY_ID) return RESOLVED_CLIENT_PAGE_REGISTRY_ID;\n      return undefined;\n    },\n    load(id) {\n      if (id !== RESOLVED_CLIENT_PAGE_REGISTRY_ID) return undefined;\n\n      const pages = discoverPages({ appRoot, srcDir: options.srcDir });\n\n      return eraseTypes(generateClientRegistry({ pages, toImportSpecifier }));\n    },\n    /**\n     * Capture-only spy. Records the SKELETON of every server page module the\n     * CLIENT environment transforms, and returns nothing so projection's own\n     * `transform` still does the real work. SERVE-ONLY:\n     * `this.environment.mode !== \"dev\"` skips it during `vite build`, where\n     * there is no `hotUpdate` to feed and the extra parse would be pure cost.\n     */\n    transform(code, id) {\n      if (this.environment?.mode !== \"dev\") return undefined;\n      if (!isServerPageModule(id)) return undefined;\n\n      const skeleton = captureSkeleton(code);\n      if (skeleton !== undefined) skeletonCache.set(id, skeleton);\n\n      return undefined;\n    },\n    /**\n     * Applies the ruling (canon `6b240682`): Fast Refresh ONLY when the only\n     * changes are inside component or exported `register` bodies.\n     *\n     *   - Skeleton moved (an import, a module-level declaration, ANY server\n     *     export — with or without a simultaneous JSX change) → full reload.\n     *   - Skeleton unchanged → defer to Fast Refresh, zero reloads.\n     *\n     * Note what is NOT here: no attempt to name which half a shared import or\n     * local belongs to. That question is what produced the two previous stale\n     * `<head>` bugs; this seam refuses to answer it and reloads instead.\n     * `hotUpdate` exists only on the dev server, so this is serve-only by\n     * construction.\n     */\n    async hotUpdate(context) {\n      if (isServerPageModule(context.file)) {\n        const routeGraphHandled = await options.beforePageHotUpdate?.({\n          file: context.file,\n          type: context.type,\n        });\n\n        if (routeGraphHandled) return [];\n      }\n\n      // `create`/`delete` are page graph churn, not in-place edits — leave them\n      // to Vite's normal handling (a new/removed module reloads on its own).\n      if (context.type !== \"update\") return undefined;\n      if (!isServerPageModule(context.file)) return undefined;\n\n      const nextSource = await context.read();\n      const next = captureSkeleton(nextSource);\n      const prev = skeletonCache.get(context.file);\n\n      // Refresh the cache for the next edit regardless of the decision below.\n      if (next !== undefined) skeletonCache.set(context.file, next);\n\n      // Could not parse the new source (Vite is already reporting that error),\n      // or the client environment never transformed this module — which means\n      // the browser is not holding this page, so there is no stale `<head>` to\n      // ship and nothing a reload of some OTHER page would fix.\n      if (next === undefined || prev === undefined) return undefined;\n\n      // Anything outside a component body moved: the browser cannot hot-swap\n      // it, so reload the document to re-run SSR and re-render `<head>`.\n      // `path: \"*\"` matches Vite's own middleware-mode reload.\n      if (prev !== next) {\n        this.environment.hot.send({ type: \"full-reload\", path: \"*\" });\n\n        // Empty module list: we've issued the update ourselves, so Vite should\n        // not additionally push a Fast Refresh for the client module.\n        return [];\n      }\n\n      // Only component bodies moved: defer to Vite's Fast Refresh with zero\n      // reloads. A no-op re-save falls through the same harmless path.\n      return undefined;\n    },\n  };\n}\n"],"mappings":"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"}

package/esm/vite/projection.d.mts

@@ -1,7 +1,7 @@
 import MagicString from "magic-string";
 import { Plugin } from "vite";
 
-//#region ../web/src/vite/projection.d.ts
+//#region web/src/vite/projection.d.ts
 /**
  * Thrown when projection encounters an attribution-ambiguous top-level
  * statement (`c604f0bc` §3: "the compiler must not guess"). Carries the
@@ -23,7 +23,7 @@ interface ProjectionResult {
 /**
  * The client-build Vite plugin. Scoped to `*.page.tsx`/`layout.tsx`/`root.tsx`
  * and skipped entirely for the SSR build (`options.ssr`) — the server still
- * needs `route`/`middleware`/`validation`/`loader`/`metadata` intact.
+ * needs `route`/`middleware`/`validation`/`loader`/`metadata`/`prefix` intact.
  */
 declare function projection(): Plugin;
 //#endregion

package/esm/vite/projection.mjs

@@ -2,18 +2,19 @@ import path from "node:path";
 import { parse } from "@babel/parser";
 import MagicString from "magic-string";
 
-//#region ../web/src/vite/projection.ts
+//#region web/src/vite/projection.ts
 /**
 * Projection — the compile-time AST transform that strips a page module's
-* five server exports before the CLIENT graph forms.
+* six server exports before the CLIENT graph forms.
 *
-* Removes `export const route/middleware/validation/loader/metadata = ...`
+* Removes `export const route/middleware/validation/loader/metadata/prefix = ...`
 * (const-arrow form) and `export async function loader(...) {...}`
 * (function-declaration form — a page declares these as separate named
 * exports, not one fused object, so both forms are real), plus any import
 * OR top-level declaration that becomes
 * unreferenced ONLY as a result of that removal. The default export (the
-* page component) and every other non-server-named export survive
+* page component) and every other non-server-named export — including the
+* synchronous, no-argument `register()` lifecycle hook — survive
 * unconditionally, regardless of what they reference — classification is by
 * FILE, not by what an export does with data (`c604f0bc` §9).
 *
@@ -51,7 +52,8 @@ const SERVER_EXPORT_NAMES = new Set([
 	"middleware",
 	"validation",
 	"loader",
-	"metadata"
+	"metadata",
+	"prefix"
 ]);
 /**
 * Recognized client-safe assets that always survive projection untouched,
@@ -65,14 +67,18 @@ const ASSET_EXTENSION_RE = /\.(css|scss|sass|less|styl|stylus|svg|png|jpe?g|gif|
 /**
 * Top-level statement types that need no ambiguity check and are never
 * touched by removal: import declarations are handled by their own
-* survives/orphaned logic below, and every export (other than the 5 server
+* survives/orphaned logic below, and every export (other than the 6 server
 * names) plus type-only declarations survive unconditionally per
 * `c604f0bc` §9 ("classify FILES, not the data they touch").
+*
+* `ExportAllDeclaration` (`export * from "./x"` / `export * as ns from
+* "./x"`) is deliberately NOT in this set — it can forward ANY name from its
+* source module, including a server export, and is refused explicitly below
+* rather than assumed safe.
 */
 const ALWAYS_SAFE_STATEMENT_TYPES = new Set([
 	"ExportNamedDeclaration",
 	"ExportDefaultDeclaration",
-	"ExportAllDeclaration",
 	"TSInterfaceDeclaration",
 	"TSTypeAliasDeclaration",
 	"EmptyStatement"
@@ -134,7 +140,7 @@ function isServerExportDeclaration(stmt) {
 * Generic duck-typed AST walk (no `@babel/traverse` dependency — this
 * package only needs `@babel/parser` + `@babel/types`-shaped nodes).
 * Collects every `Identifier`/`JSXIdentifier` name reachable from `node`,
-* used to decide whether an import binding still has a reader once the 5
+* used to decide whether an import binding still has a reader once the 6
 * server exports are gone. Over-collecting (e.g. counting an object
 * property key as a "use") only ever biases toward KEEPING an import, never
 * toward dropping one that is still needed — the safe direction for a
@@ -253,7 +259,7 @@ function statementSnippet(code, node) {
 	return code.slice(node.start, node.end).split("\n")[0].trim();
 }
 /**
-* The transform itself: parse, remove the 5 server exports and every import
+* The transform itself: parse, remove the 6 server exports and every import
 * orphaned only by that removal, fail closed on anything attribution-
 * ambiguous. `filePath` is only used for error messages (`c604f0bc` §7 —
 * fence errors must name the file).
@@ -273,6 +279,8 @@ function projectModule(code, filePath) {
 			importDeclarations.push(stmt);
 			continue;
 		}
+		const isNamespaceReexport = stmt.type === "ExportNamedDeclaration" && stmt.source != null && stmt.specifiers?.some((specifier) => specifier.type === "ExportNamespaceSpecifier");
+		if (stmt.type === "ExportAllDeclaration" || isNamespaceReexport) throw new ProjectionAmbiguityError(filePath, statementSnippet(code, stmt), stmt.loc.start.line, `a star re-export forwards every name the source module exports, including possibly one of the 6 known server exports (route, middleware, validation, loader, metadata, prefix) — projection cannot inspect the source module's exports without parsing a second file, so it can't tell whether this leaks a server-only binding into the client bundle`, `replace the star re-export with explicit named re-exports (export { ComponentA, ComponentB } from "./source"), listing only the client-safe names`);
 		if (isServerExportDeclaration(stmt)) {
 			removedServerExports.push(stmt);
 			continue;
@@ -287,7 +295,7 @@ function projectModule(code, filePath) {
 			});
 			continue;
 		}
-		throw new ProjectionAmbiguityError(filePath, statementSnippet(code, stmt), stmt.loc.start.line, `top-level executable code that declares nothing — outside the 5 known server exports (route, middleware, validation, loader, metadata), and binding no name, so projection has no reader to attribute it by and can't tell whether it belongs to the server or the client`, `mark it with an explicit .server/.client file, or move it inside one of the 5 declared server exports (if server-only) or the default export/a component (if client-safe)`);
+		throw new ProjectionAmbiguityError(filePath, statementSnippet(code, stmt), stmt.loc.start.line, `top-level executable code that declares nothing — outside the 6 known server exports (route, middleware, validation, loader, metadata, prefix), and binding no name, so projection has no reader to attribute it by and can't tell whether it belongs to the server or the client`, `move universal static declarations and their imports into export function register(), or mark the code with an explicit .server/.client file; server-only work can instead move inside one of the 6 declared server exports`);
 	}
 	const removedLocals = /* @__PURE__ */ new Set();
 	/**
@@ -327,12 +335,12 @@ function projectModule(code, filePath) {
 	}
 	for (const local of localDeclarations) {
 		if (local.removed || hasSurvivingReader(local, survivingNames)) continue;
-		throw new ProjectionAmbiguityError(filePath, statementSnippet(code, local.stmt), local.stmt.loc.start.line, `a top-level declaration read only by the server exports being removed, but whose initializer executes code rather than just defining a value — projection can't tell whether that work is server-only or a side effect the client depends on`, `move the initializer inside the server export that reads it, or split it into an explicit .server/.client file`);
+		throw new ProjectionAmbiguityError(filePath, statementSnippet(code, local.stmt), local.stmt.loc.start.line, `a top-level declaration read only by the server exports being removed, but whose initializer executes code rather than just defining a value — projection can't tell whether that work is server-only or a side effect the client depends on`, `move universal static declarations and their imports into export function register(), move a server-only initializer inside the export that reads it, or split it into an explicit .server/.client file`);
 	}
 	for (const decl of importDeclarations) {
 		const source = decl.source.value;
 		if (isKnownSafeAsset(source)) continue;
-		if (decl.specifiers.length === 0) throw new ProjectionAmbiguityError(filePath, statementSnippet(code, decl), decl.loc.start.line, `a bare side-effect import with no recognized client-safe asset extension — projection can't tell if it belongs only to the server exports being removed or must ship to the client`, `mark it with an explicit .server/.client file, or move it inside one of the 5 declared server exports if it's server-only`);
+		if (decl.specifiers.length === 0) throw new ProjectionAmbiguityError(filePath, statementSnippet(code, decl), decl.loc.start.line, `a bare side-effect import with no recognized client-safe asset extension — projection can't tell if it belongs only to the server exports being removed or must ship to the client`, `move universal static declarations and their imports into export function register(), or mark it with an explicit .server/.client file; server-only work can instead move inside one of the 6 declared server exports`);
 		if (!decl.specifiers.some((spec) => survivingNames.has(spec.local.name))) removeStatement(s, code, decl);
 	}
 	for (const stmt of removedServerExports) removeStatement(s, code, stmt);
@@ -353,10 +361,24 @@ function isProjectableFile(id) {
 	if (base === "root.tsx") return true;
 	return false;
 }
+const HMR_RUNTIME_SPECIFIER = "@warlock.js/web/client/runtime";
+/**
+* The projected module shares its scope with application source, so the helper
+* import must not redeclare a name the application already owns. A suffix is
+* only needed for the deliberately unlikely collision, but making it
+* deterministic keeps the generated HMR module valid for every page shape.
+*/
+function hmrRegisterModulesBinding(code) {
+	const base = "__warlockRegisterModules";
+	let binding = base;
+	let index = 2;
+	while (new RegExp(`\\b${binding}\\b`).test(code)) binding = `${base}${index++}`;
+	return binding;
+}
 /**
 * The client-build Vite plugin. Scoped to `*.page.tsx`/`layout.tsx`/`root.tsx`
 * and skipped entirely for the SSR build (`options.ssr`) — the server still
-* needs `route`/`middleware`/`validation`/`loader`/`metadata` intact.
+* needs `route`/`middleware`/`validation`/`loader`/`metadata`/`prefix` intact.
 */
 function projection() {
 	return {
@@ -367,8 +389,9 @@ function projection() {
 			if (!isProjectableFile(id)) return null;
 			try {
 				const { code: transformed, map } = projectModule(code, id);
+				const registerModules = hmrRegisterModulesBinding(transformed);
 				return {
-					code: transformed,
+					code: `import { registerModules as ${registerModules} } from "${HMR_RUNTIME_SPECIFIER}";\n${transformed}\nif (import.meta.hot) import.meta.hot.accept((replacement) => { if (replacement) ${registerModules}([replacement]); });\n`,
 					map
 				};
 			} catch (error) {
@@ -380,5 +403,5 @@ function projection() {
 }
 
 //#endregion
-export { ProjectionAmbiguityError, SERVER_EXPORT_NAMES, projection };
+export { ProjectionAmbiguityError, SERVER_EXPORT_NAMES, isProjectableFile, projectModule, projection };
 //# sourceMappingURL=projection.mjs.map

package/esm/vite/projection.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"projection.mjs","names":[],"sources":["../../../../../../../web/src/vite/projection.ts"],"sourcesContent":["/**\n * Projection — the compile-time AST transform that strips a page module's\n * five server exports before the CLIENT graph forms.\n *\n * Removes `export const route/middleware/validation/loader/metadata = ...`\n * (const-arrow form) and `export async function loader(...) {...}`\n * (function-declaration form — a page declares these as separate named\n * exports, not one fused object, so both forms are real), plus any import\n * OR top-level declaration that becomes\n * unreferenced ONLY as a result of that removal. The default export (the\n * page component) and every other non-server-named export survive\n * unconditionally, regardless of what they reference — classification is by\n * FILE, not by what an export does with data (`c604f0bc` §9).\n *\n * ATTRIBUTION APPLIES TO LOCAL DECLARATIONS, NOT JUST IMPORTS. A page or\n * layout hoists things to module scope for two ordinary reasons, and the\n * reference graph tells them apart without guessing:\n *\n *   `const publishCart: Middleware = ...` + `export const middleware =\n *   [publishCart]` (`v5/app/.../products/web/layout.tsx:30,43`) — the only\n *   reader is a server export being removed, so the binding goes with it.\n *\n *   `const COMMON_TIMEZONES = [...]` read by the default export\n *   (`v5/app/.../account/settings.page.tsx:118,129`) — a surviving reader, so\n *   it survives.\n *\n * That is the SAME rule already applied to import bindings, extended to the\n * other binding kind. It is deliberately not a widening of\n * `SERVER_EXPORT_NAMES`, and not \"accept what I don't recognise\": a\n * declaration is kept when something the client keeps reads it, dropped when\n * nothing does AND dropping it cannot delete a side effect, and REFUSED\n * otherwise — see `isDefinitionShapedInit`.\n *\n * This is NOT Gate A (`resolveId` path refusal), Gate B (inline secret\n * reads) or Gate C (emitted-output verification) — those are separate,\n * later slices. Projection runs first; the gates enforce after.\n */\nimport { parse } from \"@babel/parser\";\nimport MagicString from \"magic-string\";\nimport path from \"node:path\";\nimport type { Plugin } from \"vite\";\n\n/**\n * Exported so Gate C (`gate-c-verify.ts`) can re-derive \"does the emitted\n * bundle contain a server export as a top-level binding\" from this exact set\n * rather than hand-typing a second copy that could drift from projection's\n * own list.\n */\nexport const SERVER_EXPORT_NAMES = new Set([\"route\", \"middleware\", \"validation\", \"loader\", \"metadata\"]);\n\n/**\n * Recognized client-safe assets that always survive projection untouched,\n * whether imported bare (`import \"./x.css\"`) or with specifiers\n * (`import styles from \"./x.module.css\"`) — `c604f0bc` §3 names CSS\n * explicitly; the rest of this list is the same \"never guess, but a known\n * asset extension is not ambiguous\" reasoning extended to the other static\n * asset kinds Vite treats as URL/asset imports, not executable code.\n */\nconst ASSET_EXTENSION_RE =\n  /\\.(css|scss|sass|less|styl|stylus|svg|png|jpe?g|gif|webp|avif|ico|woff2?|ttf|eot|otf)(\\?.*)?$/i;\n\n/**\n * Top-level statement types that need no ambiguity check and are never\n * touched by removal: import declarations are handled by their own\n * survives/orphaned logic below, and every export (other than the 5 server\n * names) plus type-only declarations survive unconditionally per\n * `c604f0bc` §9 (\"classify FILES, not the data they touch\").\n */\nconst ALWAYS_SAFE_STATEMENT_TYPES = new Set([\n  \"ExportNamedDeclaration\",\n  \"ExportDefaultDeclaration\",\n  \"ExportAllDeclaration\",\n  \"TSInterfaceDeclaration\",\n  \"TSTypeAliasDeclaration\",\n  \"EmptyStatement\",\n]);\n\n/**\n * Thrown when projection encounters an attribution-ambiguous top-level\n * statement (`c604f0bc` §3: \"the compiler must not guess\"). Carries the\n * file/statement/fix fields the plugin's `transform` hook formats into the\n * build-failure message — never silently kept or silently dropped.\n */\nexport class ProjectionAmbiguityError extends Error {\n  constructor(\n    public readonly file: string,\n    public readonly statement: string,\n    public readonly line: number,\n    public readonly explanation: string,\n    public readonly fix: string,\n  ) {\n    super(\n      [\n        `Projection refused to guess: an ambiguous top-level statement in the client build.`,\n        ``,\n        `File: ${file}:${line}`,\n        `Statement: ${statement}`,\n        `Cause: ${explanation}`,\n        `Fix: ${fix}`,\n      ].join(\"\\n\"),\n    );\n    this.name = \"ProjectionAmbiguityError\";\n  }\n}\n\nexport interface ProjectionResult {\n  code: string;\n  map: ReturnType<MagicString[\"generateMap\"]>;\n}\n\n/** A top-level `const`/`function`/`class` awaiting attribution by reference. */\ninterface LocalDeclaration {\n  stmt: any;\n  /** The module-scope names it binds. */\n  names: Set<string>;\n  /** Whether removing it could delete a side effect — see `isDefinitionShapedInit`. */\n  definitionShaped: boolean;\n  removed: boolean;\n}\n\nfunction hasSurvivingReader(local: LocalDeclaration, survivingNames: Set<string>): boolean {\n  for (const name of local.names) {\n    if (survivingNames.has(name)) return true;\n  }\n  return false;\n}\n\nfunction isKnownSafeAsset(source: string): boolean {\n  return ASSET_EXTENSION_RE.test(source);\n}\n\n/**\n * Matches `export const <name> = ...` only when the declaration has exactly\n * one declarator — every server export in every fixture and v5/app page is\n * written one-const-per-export (`product-details.page.tsx:15-18,42-69,71-74`);\n * a multi-declarator `export const a = 1, b = 2` is left to the ambiguity\n * path below rather than guessing which half is server-only.\n */\nfunction isServerExportDeclaration(stmt: any): boolean {\n  if (stmt.type !== \"ExportNamedDeclaration\" || !stmt.declaration) return false;\n  const decl = stmt.declaration;\n  if (decl.type === \"VariableDeclaration\" && decl.declarations.length === 1) {\n    const id = decl.declarations[0].id;\n    return id?.type === \"Identifier\" && SERVER_EXPORT_NAMES.has(id.name);\n  }\n  if (decl.type === \"FunctionDeclaration\") {\n    return !!decl.id && SERVER_EXPORT_NAMES.has(decl.id.name);\n  }\n  return false;\n}\n\n/**\n * Generic duck-typed AST walk (no `@babel/traverse` dependency — this\n * package only needs `@babel/parser` + `@babel/types`-shaped nodes).\n * Collects every `Identifier`/`JSXIdentifier` name reachable from `node`,\n * used to decide whether an import binding still has a reader once the 5\n * server exports are gone. Over-collecting (e.g. counting an object\n * property key as a \"use\") only ever biases toward KEEPING an import, never\n * toward dropping one that is still needed — the safe direction for a\n * heuristic that must not guess in the removal direction.\n */\nfunction collectIdentifierNames(node: unknown, names: Set<string>): void {\n  if (!node || typeof node !== \"object\") return;\n  if (Array.isArray(node)) {\n    for (const item of node) collectIdentifierNames(item, names);\n    return;\n  }\n  const record = node as Record<string, unknown>;\n  if (typeof record.type !== \"string\") return;\n  if (record.type === \"Identifier\" || record.type === \"JSXIdentifier\") {\n    names.add((record as any).name);\n  }\n  for (const key of Object.keys(record)) {\n    if (key === \"type\" || key === \"start\" || key === \"end\" || key === \"loc\" || key === \"range\") continue;\n    if (key === \"leadingComments\" || key === \"trailingComments\" || key === \"innerComments\" || key === \"extra\") {\n      continue;\n    }\n    collectIdentifierNames(record[key], names);\n  }\n}\n\n/**\n * Top-level statements that BIND a name, and are therefore attributable by the\n * reference graph rather than by guessing. Everything outside this set and\n * `ALWAYS_SAFE_STATEMENT_TYPES` declares nothing — a bare `console.log(\"boot\")`\n * has no binding to trace a reader from, which is why it stays a hard refusal.\n */\nconst DECLARATION_STATEMENT_TYPES = new Set([\n  \"VariableDeclaration\",\n  \"FunctionDeclaration\",\n  \"ClassDeclaration\",\n]);\n\nfunction collectPatternNames(node: any, names: Set<string>): void {\n  if (!node || typeof node !== \"object\") return;\n  switch (node.type) {\n    case \"Identifier\":\n      names.add(node.name);\n      return;\n    case \"ObjectPattern\":\n      for (const property of node.properties) {\n        collectPatternNames(property.type === \"RestElement\" ? property.argument : property.value, names);\n      }\n      return;\n    case \"ArrayPattern\":\n      for (const element of node.elements) collectPatternNames(element, names);\n      return;\n    case \"AssignmentPattern\":\n      collectPatternNames(node.left, names);\n      return;\n    case \"RestElement\":\n      collectPatternNames(node.argument, names);\n      return;\n  }\n}\n\n/** The names a top-level declaration introduces into module scope. */\nfunction declaredNames(stmt: any): Set<string> {\n  const names = new Set<string>();\n  if (stmt.type === \"VariableDeclaration\") {\n    for (const declarator of stmt.declarations) collectPatternNames(declarator.id, names);\n  } else if (stmt.id?.type === \"Identifier\") {\n    names.add(stmt.id.name);\n  }\n  return names;\n}\n\n/**\n * Whether EVALUATING this initializer can run anything.\n *\n * This is the whole safety argument for removing an unreferenced declaration.\n * A function definition or a literal only creates a value, so dropping it can\n * only drop a binding nothing reads. A call, a `new`, an `await`, a member\n * access (a getter) — those can do work, and \"was that work for the server or\n * for the client?\" is precisely the question projection must not answer by\n * guessing (`c604f0bc` §3). `const _ = installPolyfill()` with no reader at all\n * is the shape this predicate exists to refuse rather than silently delete.\n *\n * Conservative by construction: an unrecognized node type is NOT\n * definition-shaped, so a new syntax form arrives as a refusal with a message,\n * never as a silent removal.\n */\nfunction isDefinitionShapedInit(node: any): boolean {\n  // `let x;` — a bare binding with nothing to evaluate.\n  if (!node) return true;\n\n  switch (node.type) {\n    case \"ArrowFunctionExpression\":\n    case \"FunctionExpression\":\n    case \"StringLiteral\":\n    case \"NumericLiteral\":\n    case \"BooleanLiteral\":\n    case \"NullLiteral\":\n    case \"BigIntLiteral\":\n    case \"RegExpLiteral\":\n    // A bare identifier read is a binding lookup, not a computation.\n    case \"Identifier\":\n      return true;\n    case \"TemplateLiteral\":\n      return node.expressions.every((expression: any) => isDefinitionShapedInit(expression));\n    case \"UnaryExpression\":\n      return node.operator !== \"delete\" && isDefinitionShapedInit(node.argument);\n    case \"ArrayExpression\":\n      return node.elements.every(\n        (element: any) =>\n          element === null || (element.type !== \"SpreadElement\" && isDefinitionShapedInit(element)),\n      );\n    case \"ObjectExpression\":\n      // Spread and computed keys both evaluate arbitrary expressions; a getter\n      // or setter defines a body that runs on ACCESS, which the surviving half\n      // could still trigger — none of them are definitions.\n      return node.properties.every(\n        (property: any) =>\n          property.type === \"ObjectProperty\" &&\n          !property.computed &&\n          isDefinitionShapedInit(property.value),\n      );\n    // TS-only wrappers erase at compile time; look through them.\n    case \"TSAsExpression\":\n    case \"TSSatisfiesExpression\":\n    case \"TSNonNullExpression\":\n    case \"TSTypeAssertion\":\n    case \"TSInstantiationExpression\":\n    case \"ParenthesizedExpression\":\n      return isDefinitionShapedInit(node.expression);\n    default:\n      return false;\n  }\n}\n\n/**\n * Statement-level form of the above. A `class` is excluded on purpose: static\n * blocks, decorators and computed member keys all run at class-definition time,\n * so a class is only ever kept or refused, never silently removed.\n */\nfunction isDefinitionShapedStatement(stmt: any): boolean {\n  if (stmt.type === \"FunctionDeclaration\") return true;\n  if (stmt.type !== \"VariableDeclaration\") return false;\n  return stmt.declarations.every((declarator: any) => isDefinitionShapedInit(declarator.init));\n}\n\nfunction removeStatement(s: MagicString, code: string, node: any): void {\n  let end = node.end as number;\n  // Swallow one trailing newline so a removed statement doesn't leave a\n  // blank line behind — cosmetic only, the output's correctness never\n  // depends on it.\n  if (code[end] === \"\\r\" && code[end + 1] === \"\\n\") end += 2;\n  else if (code[end] === \"\\n\") end += 1;\n  s.remove(node.start as number, end);\n}\n\nfunction statementSnippet(code: string, node: any): string {\n  return code.slice(node.start as number, node.end as number).split(\"\\n\")[0].trim();\n}\n\n/**\n * The transform itself: parse, remove the 5 server exports and every import\n * orphaned only by that removal, fail closed on anything attribution-\n * ambiguous. `filePath` is only used for error messages (`c604f0bc` §7 —\n * fence errors must name the file).\n */\nexport function projectModule(code: string, filePath: string): ProjectionResult {\n  const ast = parse(code, {\n    sourceType: \"module\",\n    plugins: [\"typescript\", \"jsx\"],\n  });\n\n  const s = new MagicString(code);\n  const body = ast.program.body as any[];\n\n  const removedServerExports: any[] = [];\n  const importDeclarations: any[] = [];\n  const localDeclarations: LocalDeclaration[] = [];\n\n  for (const stmt of body) {\n    if (stmt.type === \"ImportDeclaration\") {\n      importDeclarations.push(stmt);\n      continue;\n    }\n    if (isServerExportDeclaration(stmt)) {\n      removedServerExports.push(stmt);\n      continue;\n    }\n    if (ALWAYS_SAFE_STATEMENT_TYPES.has(stmt.type)) continue;\n    if (DECLARATION_STATEMENT_TYPES.has(stmt.type)) {\n      // Attributable by the reference graph — decided below, once it is known\n      // which statements survive. NOT accepted here.\n      localDeclarations.push({\n        stmt,\n        names: declaredNames(stmt),\n        definitionShaped: isDefinitionShapedStatement(stmt),\n        removed: false,\n      });\n      continue;\n    }\n\n    // Attribution-IMPOSSIBLE: not an import, not one of the 5 known server\n    // exports, not another export, not a type-only declaration, and it binds\n    // no name for a reader to point at. Fail closed rather than guess which\n    // side of the fence it belongs on (`c604f0bc` §3).\n    throw new ProjectionAmbiguityError(\n      filePath,\n      statementSnippet(code, stmt),\n      stmt.loc.start.line,\n      `top-level executable code that declares nothing — outside the 5 known server exports (route, middleware, validation, loader, metadata), and binding no name, so projection has no reader to attribute it by and can't tell whether it belongs to the server or the client`,\n      `mark it with an explicit .server/.client file, or move it inside one of the 5 declared server exports (if server-only) or the default export/a component (if client-safe)`,\n    );\n  }\n\n  const removedLocals = new Set<any>();\n\n  /**\n   * Every name READ by something that survives projection. Imports are excluded\n   * so an import specifier never counts as a use of itself, and a local\n   * declaration does not count as a use of ITSELF either — otherwise a\n   * self-recursive server-only helper would pin its own binding alive forever.\n   *\n   * Over-collecting (an object property key, a shadowing parameter) only ever\n   * biases toward KEEPING, never toward dropping something still needed — the\n   * safe direction for a heuristic that must not guess in the removal\n   * direction.\n   */\n  function collectSurvivingNames(): Set<string> {\n    const names = new Set<string>();\n    for (const stmt of body) {\n      if (stmt.type === \"ImportDeclaration\") continue;\n      if (removedServerExports.includes(stmt) || removedLocals.has(stmt)) continue;\n      const own = new Set<string>();\n      collectIdentifierNames(stmt, own);\n      if (DECLARATION_STATEMENT_TYPES.has(stmt.type)) {\n        for (const name of declaredNames(stmt)) own.delete(name);\n      }\n      for (const name of own) names.add(name);\n    }\n    return names;\n  }\n\n  // Fixpoint, not one pass: a server-only helper can be reached only through\n  // ANOTHER server-only helper, and dropping the first orphans the second.\n  let survivingNames = collectSurvivingNames();\n  for (let changed = true; changed; ) {\n    changed = false;\n    for (const local of localDeclarations) {\n      if (local.removed || !local.definitionShaped) continue;\n      if (hasSurvivingReader(local, survivingNames)) continue;\n      local.removed = true;\n      removedLocals.add(local.stmt);\n      changed = true;\n    }\n    if (changed) survivingNames = collectSurvivingNames();\n  }\n\n  for (const local of localDeclarations) {\n    if (local.removed || hasSurvivingReader(local, survivingNames)) continue;\n\n    // Nothing the client keeps reads it, so it belongs to the server exports\n    // being removed — but its initializer can RUN, and a side effect is not\n    // attributable by the reference graph. Keeping it ships server work to the\n    // browser; dropping it deletes a side effect the client may depend on.\n    // Refuse rather than pick one (`c604f0bc` §3).\n    throw new ProjectionAmbiguityError(\n      filePath,\n      statementSnippet(code, local.stmt),\n      local.stmt.loc.start.line,\n      `a top-level declaration read only by the server exports being removed, but whose initializer executes code rather than just defining a value — projection can't tell whether that work is server-only or a side effect the client depends on`,\n      `move the initializer inside the server export that reads it, or split it into an explicit .server/.client file`,\n    );\n  }\n\n  for (const decl of importDeclarations) {\n    const source = decl.source.value as string;\n    if (isKnownSafeAsset(source)) continue; // always survives, no orphan check\n\n    if (decl.specifiers.length === 0) {\n      // A bare side-effect import that isn't a recognized asset extension is\n      // just as attribution-ambiguous as an executable statement — could be\n      // a server-only side effect or something the client genuinely needs.\n      throw new ProjectionAmbiguityError(\n        filePath,\n        statementSnippet(code, decl),\n        decl.loc.start.line,\n        `a bare side-effect import with no recognized client-safe asset extension — projection can't tell if it belongs only to the server exports being removed or must ship to the client`,\n        `mark it with an explicit .server/.client file, or move it inside one of the 5 declared server exports if it's server-only`,\n      );\n    }\n\n    const isUsed = decl.specifiers.some((spec: any) => survivingNames.has(spec.local.name));\n    if (!isUsed) removeStatement(s, code, decl);\n  }\n\n  for (const stmt of removedServerExports) {\n    removeStatement(s, code, stmt);\n  }\n\n  for (const stmt of removedLocals) {\n    removeStatement(s, code, stmt);\n  }\n\n  return {\n    code: s.toString(),\n    map: s.generateMap({ hires: true, source: filePath }),\n  };\n}\n\nfunction isProjectableFile(id: string): boolean {\n  const base = path.basename(id.split(\"?\")[0]);\n  if (/\\.page\\.tsx?$/.test(base)) return true;\n  if (base === \"layout.tsx\" || base === \"layout.ts\") return true;\n  // NAMED layouts — `dashboard.layout.tsx` and friends — are subjects too.\n  //\n  // Only the exact name `layout.tsx` is POSITIONAL (discovered by its folder).\n  // A named layout is addressed by import instead, which is a documented part of\n  // the contract: `v5/app/src/web/layouts/dashboard.layout.tsx` says so in its\n  // own header, and modules opt in with two re-export lines.\n  //\n  // Projection did not recognise them, and the consequence was not cosmetic.\n  // `dashboard.layout.tsx` calls `navService.forUser()` INSIDE its `loader` —\n  // exactly where server work belongs. But because the file was not a subject,\n  // the loader was never stripped, so its `navService` import survived into the\n  // client graph and dragged auth, the user model and three Node builtins with\n  // it. The app was right and the subject test was wrong.\n  //\n  // Matching `*.layout.tsx` rather than a list of known layout names is\n  // deliberate: an enumerated list is the shape that has produced every other\n  // boundary defect here (canon `eb0c5ee8`).\n  if (/\\.layout\\.tsx?$/.test(base)) return true;\n  if (base === \"root.tsx\") return true;\n  return false;\n}\n\n/**\n * The client-build Vite plugin. Scoped to `*.page.tsx`/`layout.tsx`/`root.tsx`\n * and skipped entirely for the SSR build (`options.ssr`) — the server still\n * needs `route`/`middleware`/`validation`/`loader`/`metadata` intact.\n */\nexport function projection(): Plugin {\n  return {\n    name: \"warlock:projection\",\n    enforce: \"pre\",\n    transform(code, id, options) {\n      if (options?.ssr) return null;\n      if (!isProjectableFile(id)) return null;\n\n      try {\n        const { code: transformed, map } = projectModule(code, id);\n        return { code: transformed, map };\n      } catch (error) {\n        if (error instanceof ProjectionAmbiguityError) {\n          this.error(error.message);\n        }\n        throw error;\n      }\n    },\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"projection.mjs","names":[],"sources":["C:/Work/Warlock.js/web/src/vite/projection.ts"],"sourcesContent":["/**\n * Projection — the compile-time AST transform that strips a page module's\n * six server exports before the CLIENT graph forms.\n *\n * Removes `export const route/middleware/validation/loader/metadata/prefix = ...`\n * (const-arrow form) and `export async function loader(...) {...}`\n * (function-declaration form — a page declares these as separate named\n * exports, not one fused object, so both forms are real), plus any import\n * OR top-level declaration that becomes\n * unreferenced ONLY as a result of that removal. The default export (the\n * page component) and every other non-server-named export — including the\n * synchronous, no-argument `register()` lifecycle hook — survive\n * unconditionally, regardless of what they reference — classification is by\n * FILE, not by what an export does with data (`c604f0bc` §9).\n *\n * ATTRIBUTION APPLIES TO LOCAL DECLARATIONS, NOT JUST IMPORTS. A page or\n * layout hoists things to module scope for two ordinary reasons, and the\n * reference graph tells them apart without guessing:\n *\n *   `const publishCart: Middleware = ...` + `export const middleware =\n *   [publishCart]` (`v5/app/.../products/web/layout.tsx:30,43`) — the only\n *   reader is a server export being removed, so the binding goes with it.\n *\n *   `const COMMON_TIMEZONES = [...]` read by the default export\n *   (`v5/app/.../account/settings.page.tsx:118,129`) — a surviving reader, so\n *   it survives.\n *\n * That is the SAME rule already applied to import bindings, extended to the\n * other binding kind. It is deliberately not a widening of\n * `SERVER_EXPORT_NAMES`, and not \"accept what I don't recognise\": a\n * declaration is kept when something the client keeps reads it, dropped when\n * nothing does AND dropping it cannot delete a side effect, and REFUSED\n * otherwise — see `isDefinitionShapedInit`.\n *\n * This is NOT Gate A (`resolveId` path refusal), Gate B (inline secret\n * reads) or Gate C (emitted-output verification) — those are separate,\n * later slices. Projection runs first; the gates enforce after.\n */\nimport { parse } from \"@babel/parser\";\nimport MagicString from \"magic-string\";\nimport path from \"node:path\";\nimport type { Plugin } from \"vite\";\n\n/**\n * Exported so Gate C (`gate-c-verify.ts`) can re-derive \"does the emitted\n * bundle contain a server export as a top-level binding\" from this exact set\n * rather than hand-typing a second copy that could drift from projection's\n * own list.\n */\nexport const SERVER_EXPORT_NAMES = new Set([\n  \"route\",\n  \"middleware\",\n  \"validation\",\n  \"loader\",\n  \"metadata\",\n  \"prefix\",\n]);\n\n/**\n * Recognized client-safe assets that always survive projection untouched,\n * whether imported bare (`import \"./x.css\"`) or with specifiers\n * (`import styles from \"./x.module.css\"`) — `c604f0bc` §3 names CSS\n * explicitly; the rest of this list is the same \"never guess, but a known\n * asset extension is not ambiguous\" reasoning extended to the other static\n * asset kinds Vite treats as URL/asset imports, not executable code.\n */\nconst ASSET_EXTENSION_RE =\n  /\\.(css|scss|sass|less|styl|stylus|svg|png|jpe?g|gif|webp|avif|ico|woff2?|ttf|eot|otf)(\\?.*)?$/i;\n\n/**\n * Top-level statement types that need no ambiguity check and are never\n * touched by removal: import declarations are handled by their own\n * survives/orphaned logic below, and every export (other than the 6 server\n * names) plus type-only declarations survive unconditionally per\n * `c604f0bc` §9 (\"classify FILES, not the data they touch\").\n *\n * `ExportAllDeclaration` (`export * from \"./x\"` / `export * as ns from\n * \"./x\"`) is deliberately NOT in this set — it can forward ANY name from its\n * source module, including a server export, and is refused explicitly below\n * rather than assumed safe.\n */\nconst ALWAYS_SAFE_STATEMENT_TYPES = new Set([\n  \"ExportNamedDeclaration\",\n  \"ExportDefaultDeclaration\",\n  \"TSInterfaceDeclaration\",\n  \"TSTypeAliasDeclaration\",\n  \"EmptyStatement\",\n]);\n\n/**\n * Thrown when projection encounters an attribution-ambiguous top-level\n * statement (`c604f0bc` §3: \"the compiler must not guess\"). Carries the\n * file/statement/fix fields the plugin's `transform` hook formats into the\n * build-failure message — never silently kept or silently dropped.\n */\nexport class ProjectionAmbiguityError extends Error {\n  constructor(\n    public readonly file: string,\n    public readonly statement: string,\n    public readonly line: number,\n    public readonly explanation: string,\n    public readonly fix: string,\n  ) {\n    super(\n      [\n        `Projection refused to guess: an ambiguous top-level statement in the client build.`,\n        ``,\n        `File: ${file}:${line}`,\n        `Statement: ${statement}`,\n        `Cause: ${explanation}`,\n        `Fix: ${fix}`,\n      ].join(\"\\n\"),\n    );\n    this.name = \"ProjectionAmbiguityError\";\n  }\n}\n\nexport interface ProjectionResult {\n  code: string;\n  map: ReturnType<MagicString[\"generateMap\"]>;\n}\n\n/** A top-level `const`/`function`/`class` awaiting attribution by reference. */\ninterface LocalDeclaration {\n  stmt: any;\n  /** The module-scope names it binds. */\n  names: Set<string>;\n  /** Whether removing it could delete a side effect — see `isDefinitionShapedInit`. */\n  definitionShaped: boolean;\n  removed: boolean;\n}\n\nfunction hasSurvivingReader(\n  local: LocalDeclaration,\n  survivingNames: Set<string>,\n): boolean {\n  for (const name of local.names) {\n    if (survivingNames.has(name)) return true;\n  }\n  return false;\n}\n\nfunction isKnownSafeAsset(source: string): boolean {\n  return ASSET_EXTENSION_RE.test(source);\n}\n\n/**\n * Matches `export const <name> = ...` only when the declaration has exactly\n * one declarator — every server export in every fixture and v5/app page is\n * written one-const-per-export (`product-details.page.tsx:15-18,42-69,71-74`);\n * a multi-declarator `export const a = 1, b = 2` is left to the ambiguity\n * path below rather than guessing which half is server-only.\n */\nfunction isServerExportDeclaration(stmt: any): boolean {\n  if (stmt.type !== \"ExportNamedDeclaration\" || !stmt.declaration) return false;\n  const decl = stmt.declaration;\n  if (decl.type === \"VariableDeclaration\" && decl.declarations.length === 1) {\n    const id = decl.declarations[0].id;\n    return id?.type === \"Identifier\" && SERVER_EXPORT_NAMES.has(id.name);\n  }\n  if (decl.type === \"FunctionDeclaration\") {\n    return !!decl.id && SERVER_EXPORT_NAMES.has(decl.id.name);\n  }\n  return false;\n}\n\n/**\n * Generic duck-typed AST walk (no `@babel/traverse` dependency — this\n * package only needs `@babel/parser` + `@babel/types`-shaped nodes).\n * Collects every `Identifier`/`JSXIdentifier` name reachable from `node`,\n * used to decide whether an import binding still has a reader once the 6\n * server exports are gone. Over-collecting (e.g. counting an object\n * property key as a \"use\") only ever biases toward KEEPING an import, never\n * toward dropping one that is still needed — the safe direction for a\n * heuristic that must not guess in the removal direction.\n */\nfunction collectIdentifierNames(node: unknown, names: Set<string>): void {\n  if (!node || typeof node !== \"object\") return;\n  if (Array.isArray(node)) {\n    for (const item of node) collectIdentifierNames(item, names);\n    return;\n  }\n  const record = node as Record<string, unknown>;\n  if (typeof record.type !== \"string\") return;\n  if (record.type === \"Identifier\" || record.type === \"JSXIdentifier\") {\n    names.add((record as any).name);\n  }\n  for (const key of Object.keys(record)) {\n    if (\n      key === \"type\" ||\n      key === \"start\" ||\n      key === \"end\" ||\n      key === \"loc\" ||\n      key === \"range\"\n    )\n      continue;\n    if (\n      key === \"leadingComments\" ||\n      key === \"trailingComments\" ||\n      key === \"innerComments\" ||\n      key === \"extra\"\n    ) {\n      continue;\n    }\n    collectIdentifierNames(record[key], names);\n  }\n}\n\n/**\n * Top-level statements that BIND a name, and are therefore attributable by the\n * reference graph rather than by guessing. Everything outside this set and\n * `ALWAYS_SAFE_STATEMENT_TYPES` declares nothing — a bare `console.log(\"boot\")`\n * has no binding to trace a reader from, which is why it stays a hard refusal.\n */\nconst DECLARATION_STATEMENT_TYPES = new Set([\n  \"VariableDeclaration\",\n  \"FunctionDeclaration\",\n  \"ClassDeclaration\",\n]);\n\nfunction collectPatternNames(node: any, names: Set<string>): void {\n  if (!node || typeof node !== \"object\") return;\n  switch (node.type) {\n    case \"Identifier\":\n      names.add(node.name);\n      return;\n    case \"ObjectPattern\":\n      for (const property of node.properties) {\n        collectPatternNames(\n          property.type === \"RestElement\" ? property.argument : property.value,\n          names,\n        );\n      }\n      return;\n    case \"ArrayPattern\":\n      for (const element of node.elements) collectPatternNames(element, names);\n      return;\n    case \"AssignmentPattern\":\n      collectPatternNames(node.left, names);\n      return;\n    case \"RestElement\":\n      collectPatternNames(node.argument, names);\n      return;\n  }\n}\n\n/** The names a top-level declaration introduces into module scope. */\nfunction declaredNames(stmt: any): Set<string> {\n  const names = new Set<string>();\n  if (stmt.type === \"VariableDeclaration\") {\n    for (const declarator of stmt.declarations)\n      collectPatternNames(declarator.id, names);\n  } else if (stmt.id?.type === \"Identifier\") {\n    names.add(stmt.id.name);\n  }\n  return names;\n}\n\n/**\n * Whether EVALUATING this initializer can run anything.\n *\n * This is the whole safety argument for removing an unreferenced declaration.\n * A function definition or a literal only creates a value, so dropping it can\n * only drop a binding nothing reads. A call, a `new`, an `await`, a member\n * access (a getter) — those can do work, and \"was that work for the server or\n * for the client?\" is precisely the question projection must not answer by\n * guessing (`c604f0bc` §3). `const _ = installPolyfill()` with no reader at all\n * is the shape this predicate exists to refuse rather than silently delete.\n *\n * Conservative by construction: an unrecognized node type is NOT\n * definition-shaped, so a new syntax form arrives as a refusal with a message,\n * never as a silent removal.\n */\nfunction isDefinitionShapedInit(node: any): boolean {\n  // `let x;` — a bare binding with nothing to evaluate.\n  if (!node) return true;\n\n  switch (node.type) {\n    case \"ArrowFunctionExpression\":\n    case \"FunctionExpression\":\n    case \"StringLiteral\":\n    case \"NumericLiteral\":\n    case \"BooleanLiteral\":\n    case \"NullLiteral\":\n    case \"BigIntLiteral\":\n    case \"RegExpLiteral\":\n    // A bare identifier read is a binding lookup, not a computation.\n    case \"Identifier\":\n      return true;\n    case \"TemplateLiteral\":\n      return node.expressions.every((expression: any) =>\n        isDefinitionShapedInit(expression),\n      );\n    case \"UnaryExpression\":\n      return (\n        node.operator !== \"delete\" && isDefinitionShapedInit(node.argument)\n      );\n    case \"ArrayExpression\":\n      return node.elements.every(\n        (element: any) =>\n          element === null ||\n          (element.type !== \"SpreadElement\" && isDefinitionShapedInit(element)),\n      );\n    case \"ObjectExpression\":\n      // Spread and computed keys both evaluate arbitrary expressions; a getter\n      // or setter defines a body that runs on ACCESS, which the surviving half\n      // could still trigger — none of them are definitions.\n      return node.properties.every(\n        (property: any) =>\n          property.type === \"ObjectProperty\" &&\n          !property.computed &&\n          isDefinitionShapedInit(property.value),\n      );\n    // TS-only wrappers erase at compile time; look through them.\n    case \"TSAsExpression\":\n    case \"TSSatisfiesExpression\":\n    case \"TSNonNullExpression\":\n    case \"TSTypeAssertion\":\n    case \"TSInstantiationExpression\":\n    case \"ParenthesizedExpression\":\n      return isDefinitionShapedInit(node.expression);\n    default:\n      return false;\n  }\n}\n\n/**\n * Statement-level form of the above. A `class` is excluded on purpose: static\n * blocks, decorators and computed member keys all run at class-definition time,\n * so a class is only ever kept or refused, never silently removed.\n */\nfunction isDefinitionShapedStatement(stmt: any): boolean {\n  if (stmt.type === \"FunctionDeclaration\") return true;\n  if (stmt.type !== \"VariableDeclaration\") return false;\n  return stmt.declarations.every((declarator: any) =>\n    isDefinitionShapedInit(declarator.init),\n  );\n}\n\nfunction removeStatement(s: MagicString, code: string, node: any): void {\n  let end = node.end as number;\n  // Swallow one trailing newline so a removed statement doesn't leave a\n  // blank line behind — cosmetic only, the output's correctness never\n  // depends on it.\n  if (code[end] === \"\\r\" && code[end + 1] === \"\\n\") end += 2;\n  else if (code[end] === \"\\n\") end += 1;\n  s.remove(node.start as number, end);\n}\n\nfunction statementSnippet(code: string, node: any): string {\n  return code\n    .slice(node.start as number, node.end as number)\n    .split(\"\\n\")[0]\n    .trim();\n}\n\n/**\n * The transform itself: parse, remove the 6 server exports and every import\n * orphaned only by that removal, fail closed on anything attribution-\n * ambiguous. `filePath` is only used for error messages (`c604f0bc` §7 —\n * fence errors must name the file).\n */\nexport function projectModule(\n  code: string,\n  filePath: string,\n): ProjectionResult {\n  const ast = parse(code, {\n    sourceType: \"module\",\n    plugins: [\"typescript\", \"jsx\"],\n  });\n\n  const s = new MagicString(code);\n  const body = ast.program.body as any[];\n\n  const removedServerExports: any[] = [];\n  const importDeclarations: any[] = [];\n  const localDeclarations: LocalDeclaration[] = [];\n\n  for (const stmt of body) {\n    if (stmt.type === \"ImportDeclaration\") {\n      importDeclarations.push(stmt);\n      continue;\n    }\n    const isNamespaceReexport =\n      stmt.type === \"ExportNamedDeclaration\" &&\n      stmt.source != null &&\n      (stmt.specifiers as any[] | undefined)?.some(\n        (specifier) => specifier.type === \"ExportNamespaceSpecifier\",\n      );\n\n    if (stmt.type === \"ExportAllDeclaration\" || isNamespaceReexport) {\n      // `export * from \"./source\"` (and `export * as ns from \"./source\"`,\n      // which Babel parses as an `ExportNamedDeclaration` carrying an\n      // `ExportNamespaceSpecifier` rather than as `ExportAllDeclaration` —\n      // hence the second check above) re-exports every name the source\n      // module exports, sight unseen.\n      // Projection classifies by file (`c604f0bc` §9) and never opens a\n      // second file to resolve what a re-export actually forwards — doing so\n      // would mean parsing and walking the source module too, i.e. a second\n      // parser. Whether the source exports one of the 6 server names is\n      // therefore unknowable here, so this is attribution-ambiguous the same\n      // way an unrecognized top-level statement is, and gets the same\n      // refusal rather than an assumption that it is safe.\n      throw new ProjectionAmbiguityError(\n        filePath,\n        statementSnippet(code, stmt),\n        stmt.loc.start.line,\n        `a star re-export forwards every name the source module exports, including possibly one of the 6 known server exports (route, middleware, validation, loader, metadata, prefix) — projection cannot inspect the source module's exports without parsing a second file, so it can't tell whether this leaks a server-only binding into the client bundle`,\n        `replace the star re-export with explicit named re-exports (export { ComponentA, ComponentB } from \"./source\"), listing only the client-safe names`,\n      );\n    }\n    if (isServerExportDeclaration(stmt)) {\n      removedServerExports.push(stmt);\n      continue;\n    }\n    if (ALWAYS_SAFE_STATEMENT_TYPES.has(stmt.type)) continue;\n    if (DECLARATION_STATEMENT_TYPES.has(stmt.type)) {\n      // Attributable by the reference graph — decided below, once it is known\n      // which statements survive. NOT accepted here.\n      localDeclarations.push({\n        stmt,\n        names: declaredNames(stmt),\n        definitionShaped: isDefinitionShapedStatement(stmt),\n        removed: false,\n      });\n      continue;\n    }\n\n    // Attribution-IMPOSSIBLE: not an import, not one of the 6 known server\n    // exports, not another export, not a type-only declaration, and it binds\n    // no name for a reader to point at. Fail closed rather than guess which\n    // side of the fence it belongs on (`c604f0bc` §3).\n    throw new ProjectionAmbiguityError(\n      filePath,\n      statementSnippet(code, stmt),\n      stmt.loc.start.line,\n      `top-level executable code that declares nothing — outside the 6 known server exports (route, middleware, validation, loader, metadata, prefix), and binding no name, so projection has no reader to attribute it by and can't tell whether it belongs to the server or the client`,\n      `move universal static declarations and their imports into export function register(), or mark the code with an explicit .server/.client file; server-only work can instead move inside one of the 6 declared server exports`,\n    );\n  }\n\n  const removedLocals = new Set<any>();\n\n  /**\n   * Every name READ by something that survives projection. Imports are excluded\n   * so an import specifier never counts as a use of itself, and a local\n   * declaration does not count as a use of ITSELF either — otherwise a\n   * self-recursive server-only helper would pin its own binding alive forever.\n   *\n   * Over-collecting (an object property key, a shadowing parameter) only ever\n   * biases toward KEEPING, never toward dropping something still needed — the\n   * safe direction for a heuristic that must not guess in the removal\n   * direction.\n   */\n  function collectSurvivingNames(): Set<string> {\n    const names = new Set<string>();\n    for (const stmt of body) {\n      if (stmt.type === \"ImportDeclaration\") continue;\n      if (removedServerExports.includes(stmt) || removedLocals.has(stmt))\n        continue;\n      const own = new Set<string>();\n      collectIdentifierNames(stmt, own);\n      if (DECLARATION_STATEMENT_TYPES.has(stmt.type)) {\n        for (const name of declaredNames(stmt)) own.delete(name);\n      }\n      for (const name of own) names.add(name);\n    }\n    return names;\n  }\n\n  // Fixpoint, not one pass: a server-only helper can be reached only through\n  // ANOTHER server-only helper, and dropping the first orphans the second.\n  let survivingNames = collectSurvivingNames();\n  for (let changed = true; changed;) {\n    changed = false;\n    for (const local of localDeclarations) {\n      if (local.removed || !local.definitionShaped) continue;\n      if (hasSurvivingReader(local, survivingNames)) continue;\n      local.removed = true;\n      removedLocals.add(local.stmt);\n      changed = true;\n    }\n    if (changed) survivingNames = collectSurvivingNames();\n  }\n\n  for (const local of localDeclarations) {\n    if (local.removed || hasSurvivingReader(local, survivingNames)) continue;\n\n    // Nothing the client keeps reads it, so it belongs to the server exports\n    // being removed — but its initializer can RUN, and a side effect is not\n    // attributable by the reference graph. Keeping it ships server work to the\n    // browser; dropping it deletes a side effect the client may depend on.\n    // Refuse rather than pick one (`c604f0bc` §3).\n    throw new ProjectionAmbiguityError(\n      filePath,\n      statementSnippet(code, local.stmt),\n      local.stmt.loc.start.line,\n      `a top-level declaration read only by the server exports being removed, but whose initializer executes code rather than just defining a value — projection can't tell whether that work is server-only or a side effect the client depends on`,\n      `move universal static declarations and their imports into export function register(), move a server-only initializer inside the export that reads it, or split it into an explicit .server/.client file`,\n    );\n  }\n\n  for (const decl of importDeclarations) {\n    const source = decl.source.value as string;\n    if (isKnownSafeAsset(source)) continue; // always survives, no orphan check\n\n    if (decl.specifiers.length === 0) {\n      // A bare side-effect import that isn't a recognized asset extension is\n      // just as attribution-ambiguous as an executable statement — could be\n      // a server-only side effect or something the client genuinely needs.\n      throw new ProjectionAmbiguityError(\n        filePath,\n        statementSnippet(code, decl),\n        decl.loc.start.line,\n        `a bare side-effect import with no recognized client-safe asset extension — projection can't tell if it belongs only to the server exports being removed or must ship to the client`,\n        `move universal static declarations and their imports into export function register(), or mark it with an explicit .server/.client file; server-only work can instead move inside one of the 6 declared server exports`,\n      );\n    }\n\n    const isUsed = decl.specifiers.some((spec: any) =>\n      survivingNames.has(spec.local.name),\n    );\n    if (!isUsed) removeStatement(s, code, decl);\n  }\n\n  for (const stmt of removedServerExports) {\n    removeStatement(s, code, stmt);\n  }\n\n  for (const stmt of removedLocals) {\n    removeStatement(s, code, stmt);\n  }\n\n  return {\n    code: s.toString(),\n    map: s.generateMap({ hires: true, source: filePath }),\n  };\n}\n\nexport function isProjectableFile(id: string): boolean {\n  const base = path.basename(id.split(\"?\")[0]);\n  if (/\\.page\\.tsx?$/.test(base)) return true;\n  if (base === \"layout.tsx\" || base === \"layout.ts\") return true;\n  // NAMED layouts — `dashboard.layout.tsx` and friends — are subjects too.\n  //\n  // Only the exact name `layout.tsx` is POSITIONAL (discovered by its folder).\n  // A named layout is addressed by import instead, which is a documented part of\n  // the contract: `v5/app/src/web/layouts/dashboard.layout.tsx` says so in its\n  // own header, and modules opt in with two re-export lines.\n  //\n  // Projection did not recognise them, and the consequence was not cosmetic.\n  // `dashboard.layout.tsx` calls `navService.forUser()` INSIDE its `loader` —\n  // exactly where server work belongs. But because the file was not a subject,\n  // the loader was never stripped, so its `navService` import survived into the\n  // client graph and dragged auth, the user model and three Node builtins with\n  // it. The app was right and the subject test was wrong.\n  //\n  // Matching `*.layout.tsx` rather than a list of known layout names is\n  // deliberate: an enumerated list is the shape that has produced every other\n  // boundary defect here (canon `eb0c5ee8`).\n  if (/\\.layout\\.tsx?$/.test(base)) return true;\n  if (base === \"root.tsx\") return true;\n  return false;\n}\n\nconst HMR_RUNTIME_SPECIFIER = \"@warlock.js/web/client/runtime\";\n\n/**\n * The projected module shares its scope with application source, so the helper\n * import must not redeclare a name the application already owns. A suffix is\n * only needed for the deliberately unlikely collision, but making it\n * deterministic keeps the generated HMR module valid for every page shape.\n */\nfunction hmrRegisterModulesBinding(code: string): string {\n  const base = \"__warlockRegisterModules\";\n  let binding = base;\n  let index = 2;\n\n  while (new RegExp(`\\\\b${binding}\\\\b`).test(code)) {\n    binding = `${base}${index++}`;\n  }\n\n  return binding;\n}\n\n/**\n * The client-build Vite plugin. Scoped to `*.page.tsx`/`layout.tsx`/`root.tsx`\n * and skipped entirely for the SSR build (`options.ssr`) — the server still\n * needs `route`/`middleware`/`validation`/`loader`/`metadata`/`prefix` intact.\n */\nexport function projection(): Plugin {\n  return {\n    name: \"warlock:projection\",\n    enforce: \"pre\",\n    transform(code, id, options) {\n      if (options?.ssr) return null;\n      if (!isProjectableFile(id)) return null;\n\n      try {\n        const { code: transformed, map } = projectModule(code, id);\n        const registerModules = hmrRegisterModulesBinding(transformed);\n        return {\n          code:\n            `import { registerModules as ${registerModules} } from \"${HMR_RUNTIME_SPECIFIER}\";\\n` +\n            `${transformed}\\n` +\n            `if (import.meta.hot) import.meta.hot.accept((replacement) => { if (replacement) ${registerModules}([replacement]); });\\n`,\n          map,\n        };\n      } catch (error) {\n        if (error instanceof ProjectionAmbiguityError) {\n          this.error(error.message);\n        }\n        throw error;\n      }\n    },\n  };\n}\n"],"mappings":"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"}