@warlock.js/web 5.5.0 → 5.6.0

package/esm/vite/gate-c-verify.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"gate-c-verify.mjs","names":[],"sources":["../../../../../../../web/src/vite/gate-c-verify.ts"],"sourcesContent":["/**\r\n * Gate C — emitted-output verification.\r\n *\r\n * Projection removes the six server exports before the client graph forms.\r\n * Gate A refuses forbidden import PATHS. Gate B refuses inline secret reads.\r\n * All three act BEFORE or DURING the build, on source or the module graph —\r\n * none of them ever looks at what actually came out the other end. Gate C\r\n * is that check: a build-time assertion on the EMITTED client bundle for\r\n * every page, verifying:\r\n *\r\n *   1. The emitted code contains none of the six server export names\r\n *      (`route`, `middleware`, `validation`, `loader`, `metadata`, `prefix`) as a\r\n *      top-level binding, exported or not — `findLeakedServerExports`.\r\n *   2. The emitted module graph (Rollup's `OutputBundle`, as seen in\r\n *      `generateBundle`) contains no import edge into a\r\n *      `warlock.environment: \"server\"` (or absent-defaulting-to-server)\r\n *      package — re-derived from the exact classifier Gate A uses\r\n *      (`gate-a-resolve.ts`'s `createEnvironmentClassifier`), never a second,\r\n *      independently-drifting classification scheme — `findLeakedServerImportEdges`.\r\n *\r\n * This is defense in depth: if projection or Gate A has a bug that lets\r\n * something through, Gate C is what turns \"shipped a leak\" into \"build\r\n * fails.\" Both check functions are exported as PURE functions over a bundle\r\n * object precisely so a test can construct a bundle where projection/Gate A\r\n * are bypassed entirely (a hand-built leaked chunk, never produced by a real\r\n * pipeline run) and still prove Gate C catches it independently — re-running\r\n * the D.1-D.5 happy-path fixtures through the composed pipeline only proves\r\n * the happy path, never that Gate C itself has teeth.\r\n *\r\n * Gate C also emits the inlined-`PUBLIC_*`-value manifest — see\r\n * `buildPublicEnvManifest` below — and is the only\r\n * one of the three gates that runs exclusively at `generateBundle` time: it\r\n * has nothing to say about source, only about output.\r\n */\r\nimport { parse } from \"@babel/parser\";\r\nimport type { Plugin } from \"vite\";\r\nimport {\r\n  createEnvironmentClassifier,\r\n  type EnvironmentClassifier,\r\n  type EnvironmentClassifierOptions,\r\n} from \"./gate-a-resolve\";\r\nimport { createPublicEnvTracker, type PublicEnvTracker } from \"./gate-b-secrets\";\r\nimport { SERVER_EXPORT_NAMES } from \"./projection\";\r\n\r\nexport interface ServerExportLeak {\r\n  fileName: string;\r\n  exportName: string;\r\n  line?: number;\r\n}\r\n\r\nexport interface ServerImportEdgeLeak {\r\n  fileName: string;\r\n  moduleId: string;\r\n  packageName: string;\r\n}\r\n\r\nexport interface PublicEnvManifestEntry {\r\n  key: string;\r\n  /** `null` when `redacted` is true — see `isSafeToShowValue`. */\r\n  value: string | null;\r\n  redacted: boolean;\r\n}\r\n\r\n/**\r\n * A structurally-minimal view of Rollup's `OutputBundle` — only the fields\r\n * Gate C actually reads. Deliberately NOT the real `OutputBundle`/`OutputChunk`\r\n * types: Part 1's own discipline requires proving Gate C catches a bundle\r\n * that a real pipeline could never produce (a hand-built leaked chunk), and\r\n * forcing every test fixture to satisfy Rollup's full chunk shape would\r\n * fight that requirement for no safety benefit — Vite's real `generateBundle`\r\n * hook still hands Gate C a real `OutputBundle`, which is a structural\r\n * superset of this.\r\n */\r\ntype BundleLike = Record<\r\n  string,\r\n  {\r\n    type?: string;\r\n    fileName?: string;\r\n    code?: string;\r\n    moduleIds?: readonly string[];\r\n  }\r\n>;\r\n\r\n/**\r\n * Recursively collects every top-level statement's bound name(s), matching:\r\n *   - `const route = ...` / `function loader() {}` (exported or not — the\r\n *     check is on top-level BINDINGS, not top-level exports).\r\n *   - `export const route = ...` / `export function loader() {}` (the\r\n *     `ExportNamedDeclaration` wrapper form).\r\n *   - `export { route }` (the bare re-export-specifier form Rollup sometimes\r\n *     emits instead of inlining the declaration itself).\r\n */\r\nfunction collectServerExportNames(stmt: any): Array<{ name: string; line: number }> {\r\n  const matches: Array<{ name: string; line: number }> = [];\r\n  const line = stmt.loc?.start?.line as number | undefined;\r\n\r\n  function record(name: string | undefined) {\r\n    if (name && SERVER_EXPORT_NAMES.has(name)) matches.push({ name, line: line ?? 0 });\r\n  }\r\n\r\n  if (stmt.type === \"VariableDeclaration\") {\r\n    for (const decl of stmt.declarations) {\r\n      if (decl.id?.type === \"Identifier\") record(decl.id.name);\r\n    }\r\n  } else if (stmt.type === \"FunctionDeclaration\") {\r\n    record(stmt.id?.name);\r\n  } else if (stmt.type === \"ExportNamedDeclaration\") {\r\n    if (stmt.declaration) matches.push(...collectServerExportNames(stmt.declaration));\r\n    for (const specifier of stmt.specifiers ?? []) {\r\n      record(specifier.exported?.name ?? specifier.exported?.value);\r\n    }\r\n  }\r\n\r\n  return matches;\r\n}\r\n\r\n/**\r\n * Thrown when an emitted chunk cannot be parsed, which means Gate C could not\r\n * inspect it. A gate that skips what it cannot read reports \"no violation\r\n * found\" on precisely the input it failed to look at — the one input where\r\n * that answer is worthless. So an unreadable chunk fails the build instead.\r\n */\r\nexport class UnverifiableChunkError extends Error {\r\n  readonly fileName: string;\r\n\r\n  constructor(fileName: string, cause?: unknown) {\r\n    super(\r\n      [\r\n        `Warlock stopped this build: a file in your client bundle could not be checked for server-only code.`,\r\n        ``,\r\n        `File: ${fileName}`,\r\n        `Cause: this file could not be parsed as JavaScript, so the client/server boundary check could not be performed on it. Warlock cannot confirm that the server-only exports (route, middleware, validation, loader, metadata, prefix) were kept out of it.`,\r\n        `Fix: the build is being stopped rather than passed, because a file that was never checked is not a file known to be safe. This emitted file is outside the JavaScript syntax Warlock can currently verify. Two things commonly put it there, and this error cannot tell which: the output uses syntax newer than the parser Warlock ships with, or a plugin or loader emitted non-standard syntax into the client bundle. Check the compatibility of whatever produced this file, then build again.`,\r\n      ].join(\"\\n\"),\r\n    );\r\n    this.name = \"UnverifiableChunkError\";\r\n    this.fileName = fileName;\r\n    if (cause !== undefined) (this as { cause?: unknown }).cause = cause;\r\n  }\r\n}\r\n\r\n/**\r\n * Part 1, item 1: parses each emitted chunk's ACTUAL code (never pre-transform\r\n * source) and looks for a top-level binding named one of the five server\r\n * exports. A parse failure on an emitted chunk FAILS the gate\r\n * (`UnverifiableChunkError`) — it is never skipped. Skipping would report the\r\n * bundle clean on the one chunk the gate did not actually inspect, which is a\r\n * safety check failing open; a build stopped on an unreadable chunk is\r\n * recoverable, a boundary silently unenforced is not.\r\n *\r\n * This SURVIVES real minification (pinned by the `gate-c-verify.spec.ts`\r\n * \"D.8\" describe block). A minifier (esbuild,\r\n * Vite's default) is only free to rename LOCAL bindings; the exported name\r\n * itself is part of the module's public interface and is never mangled — a\r\n * minified `export const route = ...` still emits `export { e as route }`,\r\n * with the local identifier renamed (`e`) but `route` intact as the specifier's\r\n * `exported` name, which is exactly the field `collectServerExportNames`\r\n * reads for the `ExportNamedDeclaration` specifier form. No name-independent\r\n * redesign needed here — verified against a real `build.minify: true` output,\r\n * not assumed.\r\n */\r\nexport function findLeakedServerExports(bundle: BundleLike): ServerExportLeak[] {\r\n  const leaks: ServerExportLeak[] = [];\r\n\r\n  for (const file of Object.values(bundle)) {\r\n    if (!file || file.type !== \"chunk\" || typeof file.code !== \"string\") continue;\r\n\r\n    let ast: any;\r\n    try {\r\n      ast = parse(file.code, { sourceType: \"module\", plugins: [\"typescript\", \"jsx\"] });\r\n    } catch (error) {\r\n      throw new UnverifiableChunkError(file.fileName ?? \"(unnamed chunk)\", error);\r\n    }\r\n\r\n    for (const stmt of ast.program.body as any[]) {\r\n      for (const match of collectServerExportNames(stmt)) {\r\n        leaks.push({ fileName: file.fileName as string, exportName: match.name, line: match.line });\r\n      }\r\n    }\r\n  }\r\n\r\n  return leaks;\r\n}\r\n\r\n/**\r\n * Part 1, item 2: walks every emitted chunk's `moduleIds` (the resolved,\r\n * absolute file paths of every source module Rollup actually bundled into\r\n * that chunk) and classifies each one via the SAME `EnvironmentClassifier`\r\n * Gate A's `resolveId` uses, re-derived from `gate-a-resolve.ts` rather than\r\n * hand-rolled a second time. A moduleId that maps to a governed-scope\r\n * package classified `\"server\"` is an import edge Gate A should already\r\n * have refused — if it's here anyway, the earlier gate has a bug.\r\n *\r\n * D.8 verdict: this SURVIVES real minification unconditionally, and for a\r\n * stronger reason than item 1 above — it never reads emitted code text or\r\n * identifier names at all. `moduleIds` is Rollup's own bundling metadata\r\n * (which resolved source files ended up in this chunk), untouched by\r\n * minification, which only rewrites code, not that metadata. Verified\r\n * against a real `build.minify: true` output in `gate-c-verify.spec.ts`.\r\n */\r\nexport function findLeakedServerImportEdges(\r\n  bundle: BundleLike,\r\n  classifier: Pick<EnvironmentClassifier, \"environmentOf\" | \"packageNameForFilePath\">,\r\n): ServerImportEdgeLeak[] {\r\n  const leaks: ServerImportEdgeLeak[] = [];\r\n\r\n  for (const file of Object.values(bundle)) {\r\n    if (!file || file.type !== \"chunk\") continue;\r\n\r\n    for (const moduleId of file.moduleIds ?? []) {\r\n      const packageName = classifier.packageNameForFilePath(moduleId);\r\n      if (!packageName) continue;\r\n      if (classifier.environmentOf(packageName) === \"server\") {\r\n        leaks.push({ fileName: file.fileName as string, moduleId, packageName });\r\n      }\r\n    }\r\n  }\r\n\r\n  return leaks;\r\n}\r\n\r\n/**\r\n * Conservative \"does this PUBLIC_* value look safe to print in the reviewable\r\n * manifest\" heuristic: if genuinely unsure, show the key only — never guess\r\n * that a value is safe. The whole point of this manifest is that the `PUBLIC_`\r\n * prefix rule alone is not trustworthy — someone can and will name an actual\r\n * secret `PUBLIC_STRIPE_KEY` — so a value that LOOKS like a credential is\r\n * redacted regardless of what its key is named. Non-string values (booleans,\r\n * numbers) are never secret-shaped and always shown.\r\n */\r\nconst CREDENTIALED_URL_RE = /:\\/\\/[^/\\s]+:[^/\\s@]+@/; // scheme://user:pass@host\r\nconst KNOWN_SECRET_PREFIX_RES = [\r\n  /^sk_(live|test)_/i, // Stripe secret key (pk_ publishable is a different prefix)\r\n  /^rk_(live|test)_/i, // Stripe restricted key\r\n  /^AKIA[0-9A-Z]{12,}/, // AWS access key id\r\n  /^gh[pousr]_[A-Za-z0-9]{20,}/, // GitHub personal/OAuth/user/server tokens\r\n  /^glpat-[A-Za-z0-9_-]{20,}/, // GitLab personal access token\r\n  /^xox[baprs]-[A-Za-z0-9-]{10,}/, // Slack tokens\r\n  /^eyJ[A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+$/, // JWT (3 base64url segments)\r\n];\r\n// A long opaque token made up only of base64url/hex-ish characters, with both\r\n// letters and digits, and no separators a human-authored public value (a\r\n// URL, a short id) would normally contain — conservatively treated as a\r\n// secret-shaped random token even though it might genuinely be safe.\r\nconst HIGH_ENTROPY_TOKEN_RE = /^[A-Za-z0-9+/_=-]{32,}$/;\r\n\r\nfunction isSafeToShowValue(value: unknown): boolean {\r\n  if (typeof value !== \"string\" || value.length === 0) return true;\r\n  if (CREDENTIALED_URL_RE.test(value)) return false;\r\n  if (KNOWN_SECRET_PREFIX_RES.some((re) => re.test(value))) return false;\r\n  if (HIGH_ENTROPY_TOKEN_RE.test(value) && /[0-9]/.test(value) && /[a-zA-Z]/.test(value)) return false;\r\n  return true;\r\n}\r\n\r\nfunction stringifyEnvValue(value: unknown): string {\r\n  if (typeof value === \"string\") return value;\r\n  return JSON.stringify(value) ?? \"undefined\";\r\n}\r\n\r\n/**\r\n * The enumerated, human-reviewable list of\r\n * every `PUBLIC_*` key actually inlined into the client bundle. Built\r\n * directly from `tracker.referencedKeys` — the exact same `Set` Gate B's own\r\n * `generateBundle` unread-key check (`gate-b-secrets.ts`) reads from — so\r\n * this manifest and that exclusion logic agree BY CONSTRUCTION: they are two\r\n * readers of one Set, not two independent recomputations of \"which keys were\r\n * read\" that could drift apart. A key only reaches `referencedKeys` once\r\n * `findViolation` in `gate-b-secrets.ts` has seen a statically-resolved\r\n * `import.meta.env.PUBLIC_X` read for it, which is also precisely the\r\n * condition under which Gate B allows its value to be inlined at all — an\r\n * unread key that somehow leaked in anyway is a Gate B `generateBundle`\r\n * BUILD FAILURE (see `gate-b-secrets.ts`), never silently listed here.\r\n */\r\nexport function buildPublicEnvManifest(tracker: PublicEnvTracker): PublicEnvManifestEntry[] {\r\n  return [...tracker.referencedKeys]\r\n    .sort()\r\n    .map((key) => {\r\n      const value = tracker.declaredEnv[key];\r\n      const safe = isSafeToShowValue(value);\r\n      return { key, value: safe ? stringifyEnvValue(value) : null, redacted: !safe };\r\n    });\r\n}\r\n\r\nexport interface GateCOptions extends EnvironmentClassifierOptions {\r\n  /**\r\n   * Shared with `gateBSecrets({ tracker })` — required for the manifest to\r\n   * reflect what THIS build's Gate B pass actually saw. Defaults to a\r\n   * private, unshared tracker (always empty) if omitted, which is only ever\r\n   * correct when Gate C runs standalone in a test.\r\n   */\r\n  tracker?: PublicEnvTracker;\r\n  /** Defaults to `\"warlock-env-manifest.json\"` (Suki's suggested name). */\r\n  manifestFileName?: string;\r\n}\r\n\r\n/**\r\n * The client-build Vite plugin. Runs only at `generateBundle` — Gate C has\r\n * nothing to say about source, only about the bundle Rollup actually wrote.\r\n * Skipped for the SSR/server build, same as Gate B (`gate-b-secrets.ts`):\r\n * a page's server exports are meant to survive in that build; only the\r\n * client build is judged.\r\n */\r\nexport function gateCVerify(options: GateCOptions = {}): Plugin {\r\n  const classifier = createEnvironmentClassifier(options);\r\n  const tracker = options.tracker ?? createPublicEnvTracker();\r\n  const manifestFileName = options.manifestFileName ?? \"warlock-env-manifest.json\";\r\n\r\n  return {\r\n    name: \"warlock:gate-c-verify\",\r\n    generateBundle(_outputOptions, bundle) {\r\n      if (this.environment?.config?.consumer === \"server\") return;\r\n\r\n      const exportLeak = findLeakedServerExports(bundle)[0];\r\n      if (exportLeak) {\r\n        this.error(\r\n          [\r\n            `Gate C refused a build: a server export survived into the emitted client bundle.`,\r\n            ``,\r\n            `File: ${exportLeak.fileName}${exportLeak.line ? `:${exportLeak.line}` : \"\"}`,\r\n            `Export: ${exportLeak.exportName}`,\r\n            `Cause: \"${exportLeak.exportName}\" is one of the six server exports (route, middleware, validation, loader, metadata, prefix) and is still present as a top-level binding in the EMITTED client chunk — projection and/or Gate A should have removed or refused it before the bundle was written.`,\r\n            `Fix: this should already be impossible if projection and Gate A ran correctly — investigate why \"${exportLeak.exportName}\" reached the emitted output (a projection bug, a build config that bypasses these plugins, or a plugin ordering change) rather than assuming this build is a one-off; Gate C is defense in depth, not the primary fence.`,\r\n          ].join(\"\\n\"),\r\n        );\r\n      }\r\n\r\n      const importEdgeLeak = findLeakedServerImportEdges(bundle, classifier)[0];\r\n      if (importEdgeLeak) {\r\n        this.error(\r\n          [\r\n            `Gate C refused a build: a server-only import edge survived into the emitted client bundle's module graph.`,\r\n            ``,\r\n            `File: ${importEdgeLeak.fileName}`,\r\n            `Module: ${importEdgeLeak.moduleId}`,\r\n            `Cause: \"${importEdgeLeak.moduleId}\" belongs to ${importEdgeLeak.packageName}, a server-only package (it declares \"warlock\": { \"environment\": \"server\" } in its package.json), and is present among the bundled modules of the emitted client chunk \"${importEdgeLeak.fileName}\" — Gate A's resolveId should have refused this import before it ever reached the bundle.`,\r\n            `Fix: this should already be impossible if Gate A ran on this build — investigate why ${importEdgeLeak.packageName} reached the emitted output (a Gate A bypass, a custom resolveId/external override, or a plugin ordering change) rather than assuming this build is a one-off; Gate C is defense in depth, not the primary fence.`,\r\n          ].join(\"\\n\"),\r\n        );\r\n      }\r\n\r\n      const manifest = buildPublicEnvManifest(tracker);\r\n\r\n      // EMITTED through `this.emitFile`, not written into `bundle` by hand.\r\n      //\r\n      // This used to assign a hand-built record directly:\r\n      //\r\n      //     bundle[manifestFileName] = { type: \"asset\", fileName, name, source } as any;\r\n      //\r\n      // and the `as any` was load-bearing, which was the warning sign. A Rollup\r\n      // asset record carries `names` and `originalFileNames` ARRAYS; that object\r\n      // had neither, so it was not the shape Rollup produces — it merely\r\n      // type-asserted its way into the bundle.\r\n      //\r\n      // Nothing noticed until the production build got far enough to render\r\n      // chunks, at which point Vite's own `vite:manifest` plugin read\r\n      // `chunk.names.length` on every asset and died on `undefined`:\r\n      //\r\n      //     [vite:manifest] Cannot read properties of undefined (reading 'length')\r\n      //\r\n      // `emitFile` makes Rollup construct the record, so the shape is correct by\r\n      // construction and stays correct when Rollup adds fields. Hand-building a\r\n      // bundle entry is signing up to track someone else's internal type forever.\r\n      this.emitFile({\r\n        type: \"asset\",\r\n        fileName: manifestFileName,\r\n        source: JSON.stringify(manifest, null, 2),\r\n      });\r\n    },\r\n  };\r\n}\r\n"],"mappings":"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"}
+{"version":3,"file":"gate-c-verify.mjs","names":[],"sources":["../../../../../../../web/src/vite/gate-c-verify.ts"],"sourcesContent":["/**\r\n * Gate C — emitted-output verification.\r\n *\r\n * Projection removes the six server exports before the client graph forms.\r\n * Gate A refuses forbidden import PATHS. Gate B refuses inline secret reads.\r\n * All three act BEFORE or DURING the build, on source or the module graph —\r\n * none of them ever looks at what actually came out the other end. Gate C\r\n * is that check: a build-time assertion on the EMITTED client bundle for\r\n * every page, verifying:\r\n *\r\n *   1. The emitted code contains none of the six server export names\r\n *      (`route`, `middleware`, `validation`, `loader`, `metadata`, `prefix`) as a\r\n *      top-level binding, exported or not — `findLeakedServerExports`.\r\n *   2. The emitted module graph (Rollup's `OutputBundle`, as seen in\r\n *      `generateBundle`) contains no import edge into a\r\n *      `warlock.environment: \"server\"` (or absent-defaulting-to-server)\r\n *      package — re-derived from the exact classifier Gate A uses\r\n *      (`gate-a-resolve.ts`'s `createEnvironmentClassifier`), never a second,\r\n *      independently-drifting classification scheme — `findLeakedServerImportEdges`.\r\n *\r\n * This is defense in depth: if projection or Gate A has a bug that lets\r\n * something through, Gate C is what turns \"shipped a leak\" into \"build\r\n * fails.\" Both check functions are exported as PURE functions over a bundle\r\n * object precisely so a test can construct a bundle where projection/Gate A\r\n * are bypassed entirely (a hand-built leaked chunk, never produced by a real\r\n * pipeline run) and still prove Gate C catches it independently — re-running\r\n * the D.1-D.5 happy-path fixtures through the composed pipeline only proves\r\n * the happy path, never that Gate C itself has teeth.\r\n *\r\n * Gate C also emits the inlined-`PUBLIC_*`-value manifest — see\r\n * `buildPublicEnvManifest` below — and is the only\r\n * one of the three gates that runs exclusively at `generateBundle` time: it\r\n * has nothing to say about source, only about output.\r\n */\r\nimport { parse } from \"@babel/parser\";\r\nimport type { Plugin } from \"vite\";\r\nimport {\r\n  createEnvironmentClassifier,\r\n  type EnvironmentClassifier,\r\n  type EnvironmentClassifierOptions,\r\n} from \"./gate-a-resolve\";\r\nimport { createPublicEnvTracker, type PublicEnvTracker } from \"./gate-b-secrets\";\r\nimport { SERVER_EXPORT_NAMES } from \"./projection\";\r\n\r\nexport interface ServerExportLeak {\r\n  fileName: string;\r\n  exportName: string;\r\n  line?: number;\r\n}\r\n\r\nexport interface ServerImportEdgeLeak {\r\n  fileName: string;\r\n  moduleId: string;\r\n  packageName: string;\r\n}\r\n\r\nexport interface PublicEnvManifestEntry {\r\n  key: string;\r\n  /** `null` when `redacted` is true — see `isSafeToShowValue`. */\r\n  value: string | null;\r\n  redacted: boolean;\r\n}\r\n\r\n/**\r\n * A structurally-minimal view of Rollup's `OutputBundle` — only the fields\r\n * Gate C actually reads. Deliberately NOT the real `OutputBundle`/`OutputChunk`\r\n * types: Part 1's own discipline requires proving Gate C catches a bundle\r\n * that a real pipeline could never produce (a hand-built leaked chunk), and\r\n * forcing every test fixture to satisfy Rollup's full chunk shape would\r\n * fight that requirement for no safety benefit — Vite's real `generateBundle`\r\n * hook still hands Gate C a real `OutputBundle`, which is a structural\r\n * superset of this.\r\n */\r\ntype BundleLike = Record<\r\n  string,\r\n  {\r\n    type?: string;\r\n    fileName?: string;\r\n    code?: string;\r\n    moduleIds?: readonly string[];\r\n  }\r\n>;\r\n\r\n/**\r\n * Recursively collects every top-level statement's bound name(s), matching:\r\n *   - `const route = ...` / `function loader() {}` (exported or not — the\r\n *     check is on top-level BINDINGS, not top-level exports).\r\n *   - `export const route = ...` / `export function loader() {}` (the\r\n *     `ExportNamedDeclaration` wrapper form).\r\n *   - `export { route }` (the bare re-export-specifier form Rollup sometimes\r\n *     emits instead of inlining the declaration itself).\r\n */\r\nfunction collectServerExportNames(stmt: any): Array<{ name: string; line: number }> {\r\n  const matches: Array<{ name: string; line: number }> = [];\r\n  const line = stmt.loc?.start?.line as number | undefined;\r\n\r\n  function record(name: string | undefined) {\r\n    if (name && SERVER_EXPORT_NAMES.has(name)) matches.push({ name, line: line ?? 0 });\r\n  }\r\n\r\n  if (stmt.type === \"VariableDeclaration\") {\r\n    for (const decl of stmt.declarations) {\r\n      if (decl.id?.type === \"Identifier\") record(decl.id.name);\r\n    }\r\n  } else if (stmt.type === \"FunctionDeclaration\") {\r\n    record(stmt.id?.name);\r\n  } else if (stmt.type === \"ExportNamedDeclaration\") {\r\n    if (stmt.declaration) matches.push(...collectServerExportNames(stmt.declaration));\r\n    for (const specifier of stmt.specifiers ?? []) {\r\n      record(specifier.exported?.name ?? specifier.exported?.value);\r\n    }\r\n  }\r\n\r\n  return matches;\r\n}\r\n\r\n/**\r\n * Thrown when an emitted chunk cannot be parsed, which means Gate C could not\r\n * inspect it. A gate that skips what it cannot read reports \"no violation\r\n * found\" on precisely the input it failed to look at — the one input where\r\n * that answer is worthless. So an unreadable chunk fails the build instead.\r\n */\r\nexport class UnverifiableChunkError extends Error {\r\n  readonly fileName: string;\r\n\r\n  constructor(fileName: string, cause?: unknown) {\r\n    super(\r\n      [\r\n        `Warlock stopped this build: a file in your client bundle could not be checked for server-only code.`,\r\n        ``,\r\n        `File: ${fileName}`,\r\n        `Cause: this file could not be parsed as JavaScript, so the client/server boundary check could not be performed on it. Warlock cannot confirm that the server-only exports (route, middleware, validation, loader, metadata, prefix) were kept out of it.`,\r\n        `Fix: the build is being stopped rather than passed, because a file that was never checked is not a file known to be safe. This emitted file is outside the JavaScript syntax Warlock can currently verify. Two things commonly put it there, and this error cannot tell which: the output uses syntax newer than the parser Warlock ships with, or a plugin or loader emitted non-standard syntax into the client bundle. Check the compatibility of whatever produced this file, then build again.`,\r\n      ].join(\"\\n\"),\r\n    );\r\n    this.name = \"UnverifiableChunkError\";\r\n    this.fileName = fileName;\r\n    if (cause !== undefined) (this as { cause?: unknown }).cause = cause;\r\n  }\r\n}\r\n\r\n/**\r\n * Part 1, item 1: parses each emitted chunk's ACTUAL code (never pre-transform\r\n * source) and looks for a top-level binding named one of the six server\r\n * exports. A parse failure on an emitted chunk FAILS the gate\r\n * (`UnverifiableChunkError`) — it is never skipped. Skipping would report the\r\n * bundle clean on the one chunk the gate did not actually inspect, which is a\r\n * safety check failing open; a build stopped on an unreadable chunk is\r\n * recoverable, a boundary silently unenforced is not.\r\n *\r\n * This SURVIVES real minification (pinned by the `gate-c-verify.spec.ts`\r\n * \"D.8\" describe block). A minifier (esbuild,\r\n * Vite's default) is only free to rename LOCAL bindings; the exported name\r\n * itself is part of the module's public interface and is never mangled — a\r\n * minified `export const route = ...` still emits `export { e as route }`,\r\n * with the local identifier renamed (`e`) but `route` intact as the specifier's\r\n * `exported` name, which is exactly the field `collectServerExportNames`\r\n * reads for the `ExportNamedDeclaration` specifier form. No name-independent\r\n * redesign needed here — verified against a real `build.minify: true` output,\r\n * not assumed.\r\n */\r\nexport function findLeakedServerExports(bundle: BundleLike): ServerExportLeak[] {\r\n  const leaks: ServerExportLeak[] = [];\r\n\r\n  for (const file of Object.values(bundle)) {\r\n    if (!file || file.type !== \"chunk\" || typeof file.code !== \"string\") continue;\r\n\r\n    let ast: any;\r\n    try {\r\n      ast = parse(file.code, { sourceType: \"module\", plugins: [\"typescript\", \"jsx\"] });\r\n    } catch (error) {\r\n      throw new UnverifiableChunkError(file.fileName ?? \"(unnamed chunk)\", error);\r\n    }\r\n\r\n    for (const stmt of ast.program.body as any[]) {\r\n      for (const match of collectServerExportNames(stmt)) {\r\n        leaks.push({ fileName: file.fileName as string, exportName: match.name, line: match.line });\r\n      }\r\n    }\r\n  }\r\n\r\n  return leaks;\r\n}\r\n\r\n/**\r\n * Part 1, item 2: walks every emitted chunk's `moduleIds` (the resolved,\r\n * absolute file paths of every source module Rollup actually bundled into\r\n * that chunk) and classifies each one via the SAME `EnvironmentClassifier`\r\n * Gate A's `resolveId` uses, re-derived from `gate-a-resolve.ts` rather than\r\n * hand-rolled a second time. A moduleId that maps to a governed-scope\r\n * package classified `\"server\"` is an import edge Gate A should already\r\n * have refused — if it's here anyway, the earlier gate has a bug.\r\n *\r\n * D.8 verdict: this SURVIVES real minification unconditionally, and for a\r\n * stronger reason than item 1 above — it never reads emitted code text or\r\n * identifier names at all. `moduleIds` is Rollup's own bundling metadata\r\n * (which resolved source files ended up in this chunk), untouched by\r\n * minification, which only rewrites code, not that metadata. Verified\r\n * against a real `build.minify: true` output in `gate-c-verify.spec.ts`.\r\n */\r\nexport function findLeakedServerImportEdges(\r\n  bundle: BundleLike,\r\n  classifier: Pick<EnvironmentClassifier, \"environmentOf\" | \"packageNameForFilePath\">,\r\n): ServerImportEdgeLeak[] {\r\n  const leaks: ServerImportEdgeLeak[] = [];\r\n\r\n  for (const file of Object.values(bundle)) {\r\n    if (!file || file.type !== \"chunk\") continue;\r\n\r\n    for (const moduleId of file.moduleIds ?? []) {\r\n      const packageName = classifier.packageNameForFilePath(moduleId);\r\n      if (!packageName) continue;\r\n      if (classifier.environmentOf(packageName) === \"server\") {\r\n        leaks.push({ fileName: file.fileName as string, moduleId, packageName });\r\n      }\r\n    }\r\n  }\r\n\r\n  return leaks;\r\n}\r\n\r\n/**\r\n * Conservative \"does this PUBLIC_* value look safe to print in the reviewable\r\n * manifest\" heuristic: if genuinely unsure, show the key only — never guess\r\n * that a value is safe. The whole point of this manifest is that the `PUBLIC_`\r\n * prefix rule alone is not trustworthy — someone can and will name an actual\r\n * secret `PUBLIC_STRIPE_KEY` — so a value that LOOKS like a credential is\r\n * redacted regardless of what its key is named. Non-string values (booleans,\r\n * numbers) are never secret-shaped and always shown.\r\n */\r\nconst CREDENTIALED_URL_RE = /:\\/\\/[^/\\s]+:[^/\\s@]+@/; // scheme://user:pass@host\r\nconst KNOWN_SECRET_PREFIX_RES = [\r\n  /^sk_(live|test)_/i, // Stripe secret key (pk_ publishable is a different prefix)\r\n  /^rk_(live|test)_/i, // Stripe restricted key\r\n  /^AKIA[0-9A-Z]{12,}/, // AWS access key id\r\n  /^gh[pousr]_[A-Za-z0-9]{20,}/, // GitHub personal/OAuth/user/server tokens\r\n  /^glpat-[A-Za-z0-9_-]{20,}/, // GitLab personal access token\r\n  /^xox[baprs]-[A-Za-z0-9-]{10,}/, // Slack tokens\r\n  /^eyJ[A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+$/, // JWT (3 base64url segments)\r\n];\r\n// A long opaque token made up only of base64url/hex-ish characters, with both\r\n// letters and digits, and no separators a human-authored public value (a\r\n// URL, a short id) would normally contain — conservatively treated as a\r\n// secret-shaped random token even though it might genuinely be safe.\r\nconst HIGH_ENTROPY_TOKEN_RE = /^[A-Za-z0-9+/_=-]{32,}$/;\r\n\r\nfunction isSafeToShowValue(value: unknown): boolean {\r\n  if (typeof value !== \"string\" || value.length === 0) return true;\r\n  if (CREDENTIALED_URL_RE.test(value)) return false;\r\n  if (KNOWN_SECRET_PREFIX_RES.some((re) => re.test(value))) return false;\r\n  if (HIGH_ENTROPY_TOKEN_RE.test(value) && /[0-9]/.test(value) && /[a-zA-Z]/.test(value))\r\n    return false;\r\n  return true;\r\n}\r\n\r\nfunction stringifyEnvValue(value: unknown): string {\r\n  if (typeof value === \"string\") return value;\r\n  return JSON.stringify(value) ?? \"undefined\";\r\n}\r\n\r\n/**\r\n * The enumerated, human-reviewable list of\r\n * every `PUBLIC_*` key actually inlined into the client bundle. Built\r\n * directly from `tracker.referencedKeys` — the exact same `Set` Gate B's own\r\n * `generateBundle` unread-key check (`gate-b-secrets.ts`) reads from — so\r\n * this manifest and that exclusion logic agree BY CONSTRUCTION: they are two\r\n * readers of one Set, not two independent recomputations of \"which keys were\r\n * read\" that could drift apart. A key only reaches `referencedKeys` once\r\n * `findViolation` in `gate-b-secrets.ts` has seen a statically-resolved\r\n * `import.meta.env.PUBLIC_X` read for it, which is also precisely the\r\n * condition under which Gate B allows its value to be inlined at all — an\r\n * unread key that somehow leaked in anyway is a Gate B `generateBundle`\r\n * BUILD FAILURE (see `gate-b-secrets.ts`), never silently listed here.\r\n */\r\nexport function buildPublicEnvManifest(tracker: PublicEnvTracker): PublicEnvManifestEntry[] {\r\n  return [...tracker.referencedKeys].sort().map((key) => {\r\n    const value = tracker.declaredEnv[key];\r\n    const safe = isSafeToShowValue(value);\r\n    return { key, value: safe ? stringifyEnvValue(value) : null, redacted: !safe };\r\n  });\r\n}\r\n\r\nexport interface GateCOptions extends EnvironmentClassifierOptions {\r\n  /**\r\n   * Shared with `gateBSecrets({ tracker })` — required for the manifest to\r\n   * reflect what THIS build's Gate B pass actually saw. Defaults to a\r\n   * private, unshared tracker (always empty) if omitted, which is only ever\r\n   * correct when Gate C runs standalone in a test.\r\n   */\r\n  tracker?: PublicEnvTracker;\r\n  /** Defaults to `\"warlock-env-manifest.json\"` (Suki's suggested name). */\r\n  manifestFileName?: string;\r\n}\r\n\r\n/**\r\n * The client-build Vite plugin. Runs only at `generateBundle` — Gate C has\r\n * nothing to say about source, only about the bundle Rollup actually wrote.\r\n * Skipped for the SSR/server build, same as Gate B (`gate-b-secrets.ts`):\r\n * a page's server exports are meant to survive in that build; only the\r\n * client build is judged.\r\n */\r\nexport function gateCVerify(options: GateCOptions = {}): Plugin {\r\n  const classifier = createEnvironmentClassifier(options);\r\n  const tracker = options.tracker ?? createPublicEnvTracker();\r\n  const manifestFileName = options.manifestFileName ?? \"warlock-env-manifest.json\";\r\n\r\n  return {\r\n    name: \"warlock:gate-c-verify\",\r\n    generateBundle(_outputOptions, bundle) {\r\n      if (this.environment?.config?.consumer === \"server\") return;\r\n\r\n      const exportLeak = findLeakedServerExports(bundle)[0];\r\n      if (exportLeak) {\r\n        this.error(\r\n          [\r\n            `Gate C refused a build: a server export survived into the emitted client bundle.`,\r\n            ``,\r\n            `File: ${exportLeak.fileName}${exportLeak.line ? `:${exportLeak.line}` : \"\"}`,\r\n            `Export: ${exportLeak.exportName}`,\r\n            `Cause: \"${exportLeak.exportName}\" is one of the six server exports (route, middleware, validation, loader, metadata, prefix) and is still present as a top-level binding in the EMITTED client chunk — projection and/or Gate A should have removed or refused it before the bundle was written.`,\r\n            `Fix: this should already be impossible if projection and Gate A ran correctly — investigate why \"${exportLeak.exportName}\" reached the emitted output (a projection bug, a build config that bypasses these plugins, or a plugin ordering change) rather than assuming this build is a one-off; Gate C is defense in depth, not the primary fence.`,\r\n          ].join(\"\\n\"),\r\n        );\r\n      }\r\n\r\n      const importEdgeLeak = findLeakedServerImportEdges(bundle, classifier)[0];\r\n      if (importEdgeLeak) {\r\n        this.error(\r\n          [\r\n            `Gate C refused a build: a server-only import edge survived into the emitted client bundle's module graph.`,\r\n            ``,\r\n            `File: ${importEdgeLeak.fileName}`,\r\n            `Module: ${importEdgeLeak.moduleId}`,\r\n            `Cause: \"${importEdgeLeak.moduleId}\" belongs to ${importEdgeLeak.packageName}, a server-only package (it declares \"warlock\": { \"environment\": \"server\" } in its package.json), and is present among the bundled modules of the emitted client chunk \"${importEdgeLeak.fileName}\" — Gate A's resolveId should have refused this import before it ever reached the bundle.`,\r\n            `Fix: this should already be impossible if Gate A ran on this build — investigate why ${importEdgeLeak.packageName} reached the emitted output (a Gate A bypass, a custom resolveId/external override, or a plugin ordering change) rather than assuming this build is a one-off; Gate C is defense in depth, not the primary fence.`,\r\n          ].join(\"\\n\"),\r\n        );\r\n      }\r\n\r\n      const manifest = buildPublicEnvManifest(tracker);\r\n\r\n      // EMITTED through `this.emitFile`, not written into `bundle` by hand.\r\n      //\r\n      // This used to assign a hand-built record directly:\r\n      //\r\n      //     bundle[manifestFileName] = { type: \"asset\", fileName, name, source } as any;\r\n      //\r\n      // and the `as any` was load-bearing, which was the warning sign. A Rollup\r\n      // asset record carries `names` and `originalFileNames` ARRAYS; that object\r\n      // had neither, so it was not the shape Rollup produces — it merely\r\n      // type-asserted its way into the bundle.\r\n      //\r\n      // Nothing noticed until the production build got far enough to render\r\n      // chunks, at which point Vite's own `vite:manifest` plugin read\r\n      // `chunk.names.length` on every asset and died on `undefined`:\r\n      //\r\n      //     [vite:manifest] Cannot read properties of undefined (reading 'length')\r\n      //\r\n      // `emitFile` makes Rollup construct the record, so the shape is correct by\r\n      // construction and stays correct when Rollup adds fields. Hand-building a\r\n      // bundle entry is signing up to track someone else's internal type forever.\r\n      this.emitFile({\r\n        type: \"asset\",\r\n        fileName: manifestFileName,\r\n        source: JSON.stringify(manifest, null, 2),\r\n      });\r\n    },\r\n  };\r\n}\r\n"],"mappings":"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"}

package/esm/vite/hydration-entries.mjs

@@ -1,12 +1,10 @@
+import { toPosix } from "../shared/to-posix.mjs";
 import { existsSync } from "node:fs";
 import path from "node:path";
 
 //#region ../web/src/vite/hydration-entries.ts
 /** Stable Rollup/Vite entry name shared by development and production wiring. */
 const HYDRATION_CLIENT_ENTRY_NAME = "hydration";
-function normalizeFileSystemPath(filePath) {
-	return filePath.replace(/\\/g, "/");
-}
 /**
 * Where the hydration entry lives inside an INSTALLED `@warlock.js/web`, and
 * where it lives inside this checkout — in that order of preference.
@@ -16,7 +14,7 @@ function normalizeFileSystemPath(filePath) {
 * `@warlock.js/web@5.0.2`: 191 files, none under `src/`. Note the published
 * `package.json` carries no `files` key at all; the release tooling rewrites
 * the manifest, so do not treat this repo's `files` field as the mechanism.)
-* Resolving the entry to `<webRoot>/src/hydration/index.ts` unconditionally
+* Resolving the entry to `<webRoot>/src/entry/index.ts` unconditionally
 * therefore worked in this monorepo and failed for every consumer, with
 * `warlock build` unable to emit a client bundle at all.
 *
@@ -26,8 +24,8 @@ function normalizeFileSystemPath(filePath) {
 * through `esm/`, the hydration entry's relative imports through `src/`.
 * `publishRouteTable()` would write to one and `<Link>` would read the other.
 */
-const PACKAGED_ENTRY = "esm/hydration/index.mjs";
-const CHECKOUT_ENTRY = "src/hydration/index.ts";
+const PACKAGED_ENTRY = "esm/entry/index.mjs";
+const CHECKOUT_ENTRY = "src/entry/index.ts";
 /**
 * Describes the single framework hydration entry without importing Vite.
 * Vite's `/@fs/` prefix accepts an absolute normalized file-system path;
@@ -36,7 +34,7 @@ const CHECKOUT_ENTRY = "src/hydration/index.ts";
 function createHydrationClientEntry(webRoot) {
 	if (typeof webRoot !== "string" || webRoot.trim().length === 0) throw new TypeError("Cannot create the hydration client entry: webRoot must be a non-empty path.");
 	const packagedPath = path.resolve(webRoot, PACKAGED_ENTRY);
-	const sourcePath = normalizeFileSystemPath(existsSync(packagedPath) ? packagedPath : path.resolve(webRoot, CHECKOUT_ENTRY));
+	const sourcePath = toPosix(existsSync(packagedPath) ? packagedPath : path.resolve(webRoot, CHECKOUT_ENTRY));
 	return {
 		name: HYDRATION_CLIENT_ENTRY_NAME,
 		sourcePath,

package/esm/vite/hydration-entries.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"hydration-entries.mjs","names":[],"sources":["../../../../../../../web/src/vite/hydration-entries.ts"],"sourcesContent":["import { existsSync } from \"node:fs\";\nimport path from \"node:path\";\n\n/** Stable Rollup/Vite entry name shared by development and production wiring. */\nexport const HYDRATION_CLIENT_ENTRY_NAME = \"hydration\";\n\nexport type HydrationClientEntry = Readonly<{\n  name: typeof HYDRATION_CLIENT_ENTRY_NAME;\n  sourcePath: string;\n  devUrl: string;\n}>;\n\nfunction normalizeFileSystemPath(filePath: string): string {\n  return filePath.replace(/\\\\/g, \"/\");\n}\n\n/**\n * Where the hydration entry lives inside an INSTALLED `@warlock.js/web`, and\n * where it lives inside this checkout — in that order of preference.\n *\n * The published tarball ships `esm/`, `skills/` and the docs files — no `src/`\n * — so `src/` is absent from every real install. (Verified against\n * `@warlock.js/web@5.0.2`: 191 files, none under `src/`. Note the published\n * `package.json` carries no `files` key at all; the release tooling rewrites\n * the manifest, so do not treat this repo's `files` field as the mechanism.)\n * Resolving the entry to `<webRoot>/src/hydration/index.ts` unconditionally\n * therefore worked in this monorepo and failed for every consumer, with\n * `warlock build` unable to emit a client bundle at all.\n *\n * The built artifact is preferred rather than the source being published,\n * because shipping `src/` beside `esm/` would put TWO instances of\n * `routing/route-table` in one client bundle — the app's own imports resolve\n * through `esm/`, the hydration entry's relative imports through `src/`.\n * `publishRouteTable()` would write to one and `<Link>` would read the other.\n */\nconst PACKAGED_ENTRY = \"esm/hydration/index.mjs\";\nconst CHECKOUT_ENTRY = \"src/hydration/index.ts\";\n\n/**\n * Describes the single framework hydration entry without importing Vite.\n * Vite's `/@fs/` prefix accepts an absolute normalized file-system path;\n * keeping the drive colon produces `/@fs/D:/...` consistently on Windows.\n */\nexport function createHydrationClientEntry(webRoot: string): HydrationClientEntry {\n  if (typeof webRoot !== \"string\" || webRoot.trim().length === 0) {\n    throw new TypeError(\"Cannot create the hydration client entry: webRoot must be a non-empty path.\");\n  }\n\n  const packagedPath = path.resolve(webRoot, PACKAGED_ENTRY);\n  const sourcePath = normalizeFileSystemPath(\n    existsSync(packagedPath) ? packagedPath : path.resolve(webRoot, CHECKOUT_ENTRY),\n  );\n\n  return {\n    name: HYDRATION_CLIENT_ENTRY_NAME,\n    sourcePath,\n    devUrl: `/@fs/${sourcePath}`,\n  };\n}\n"],"mappings":";;;;;AAIA,MAAa,8BAA8B;AAQ3C,SAAS,wBAAwB,UAA0B;CACzD,OAAO,SAAS,QAAQ,OAAO,GAAG;AACpC;;;;;;;;;;;;;;;;;;;;AAqBA,MAAM,iBAAiB;AACvB,MAAM,iBAAiB;;;;;;AAOvB,SAAgB,2BAA2B,SAAuC;CAChF,IAAI,OAAO,YAAY,YAAY,QAAQ,KAAK,CAAC,CAAC,WAAW,GAC3D,MAAM,IAAI,UAAU,6EAA6E;CAGnG,MAAM,eAAe,KAAK,QAAQ,SAAS,cAAc;CACzD,MAAM,aAAa,wBACjB,WAAW,YAAY,IAAI,eAAe,KAAK,QAAQ,SAAS,cAAc,CAChF;CAEA,OAAO;EACL,MAAM;EACN;EACA,QAAQ,QAAQ;CAClB;AACF"}
+{"version":3,"file":"hydration-entries.mjs","names":[],"sources":["../../../../../../../web/src/vite/hydration-entries.ts"],"sourcesContent":["import { existsSync } from \"node:fs\";\nimport path from \"node:path\";\nimport { toPosix } from \"../shared/to-posix\";\n\n/** Stable Rollup/Vite entry name shared by development and production wiring. */\nexport const HYDRATION_CLIENT_ENTRY_NAME = \"hydration\";\n\nexport type HydrationClientEntry = Readonly<{\n  name: typeof HYDRATION_CLIENT_ENTRY_NAME;\n  sourcePath: string;\n  devUrl: string;\n}>;\n\n/**\n * Where the hydration entry lives inside an INSTALLED `@warlock.js/web`, and\n * where it lives inside this checkout — in that order of preference.\n *\n * The published tarball ships `esm/`, `skills/` and the docs files — no `src/`\n * — so `src/` is absent from every real install. (Verified against\n * `@warlock.js/web@5.0.2`: 191 files, none under `src/`. Note the published\n * `package.json` carries no `files` key at all; the release tooling rewrites\n * the manifest, so do not treat this repo's `files` field as the mechanism.)\n * Resolving the entry to `<webRoot>/src/entry/index.ts` unconditionally\n * therefore worked in this monorepo and failed for every consumer, with\n * `warlock build` unable to emit a client bundle at all.\n *\n * The built artifact is preferred rather than the source being published,\n * because shipping `src/` beside `esm/` would put TWO instances of\n * `routing/route-table` in one client bundle — the app's own imports resolve\n * through `esm/`, the hydration entry's relative imports through `src/`.\n * `publishRouteTable()` would write to one and `<Link>` would read the other.\n */\nconst PACKAGED_ENTRY = \"esm/entry/index.mjs\";\nconst CHECKOUT_ENTRY = \"src/entry/index.ts\";\n\n/**\n * Describes the single framework hydration entry without importing Vite.\n * Vite's `/@fs/` prefix accepts an absolute normalized file-system path;\n * keeping the drive colon produces `/@fs/D:/...` consistently on Windows.\n */\nexport function createHydrationClientEntry(webRoot: string): HydrationClientEntry {\n  if (typeof webRoot !== \"string\" || webRoot.trim().length === 0) {\n    throw new TypeError(\n      \"Cannot create the hydration client entry: webRoot must be a non-empty path.\",\n    );\n  }\n\n  const packagedPath = path.resolve(webRoot, PACKAGED_ENTRY);\n  const sourcePath = toPosix(\n    existsSync(packagedPath) ? packagedPath : path.resolve(webRoot, CHECKOUT_ENTRY),\n  );\n\n  return {\n    name: HYDRATION_CLIENT_ENTRY_NAME,\n    sourcePath,\n    devUrl: `/@fs/${sourcePath}`,\n  };\n}\n"],"mappings":";;;;;;AAKA,MAAa,8BAA8B;;;;;;;;;;;;;;;;;;;;AA2B3C,MAAM,iBAAiB;AACvB,MAAM,iBAAiB;;;;;;AAOvB,SAAgB,2BAA2B,SAAuC;CAChF,IAAI,OAAO,YAAY,YAAY,QAAQ,KAAK,CAAC,CAAC,WAAW,GAC3D,MAAM,IAAI,UACR,6EACF;CAGF,MAAM,eAAe,KAAK,QAAQ,SAAS,cAAc;CACzD,MAAM,aAAa,QACjB,WAAW,YAAY,IAAI,eAAe,KAAK,QAAQ,SAAS,cAAc,CAChF;CAEA,OAAO;EACL,MAAM;EACN;EACA,QAAQ,QAAQ;CAClB;AACF"}

package/esm/vite/index.d.mts

@@ -21,7 +21,7 @@ type BuildWarlockHydrationClientOptions = Readonly<{
 }>;
 /**
  * The composed client-build pipeline: projection
- * strips the 5 server exports first, THEN Gate B's `transform` checks
+ * strips the 6 server exports first, THEN Gate B's `transform` checks
  * whatever source remains for inline secret reads, THEN Gate A's
  * `resolveId` judges whatever imports remain. Array order here is
  * `[projection(), gateBSecrets(), gateAResolve()]` to match Vite's own

package/esm/vite/index.mjs

@@ -1,12 +1,12 @@
 import { HYDRATION_CLIENT_ENTRY_NAME, createHydrationClientEntry } from "./hydration-entries.mjs";
 import { buildHydrationClient } from "./build-client.mjs";
-import { gateAResolve, isAppSourcePath, isRecognizedUniversalSurface, isServerFile, isWithinModuleWebFolder } from "./gate-a-resolve.mjs";
+import { gateAResolve } from "./gate-a-resolve.mjs";
 import { createPublicEnvTracker, gateBSecrets } from "./gate-b-secrets.mjs";
-import { ProjectionAmbiguityError, isProjectableFile, projectModule, projection } from "./projection.mjs";
+import { ProjectionAmbiguityError, projection } from "./projection.mjs";
 import { buildPublicEnvManifest, findLeakedServerExports, findLeakedServerImportEdges, gateCVerify } from "./gate-c-verify.mjs";
 import { CLIENT_PAGE_REGISTRY_ID, RESOLVED_CLIENT_PAGE_REGISTRY_ID, clientPageRegistry, invalidateClientPageRegistry } from "./page-registry-plugin.mjs";
+import { clientEnvironmentOnly } from "./ssr-client-view.mjs";
 import path from "node:path";
-import { parse } from "@babel/parser";
 
 //#region ../web/src/vite/index.ts
 /**
@@ -14,115 +14,9 @@ import { parse } from "@babel/parser";
 * runtime barrel (`@warlock.js/web`) so importing it never pulls `vite` into
 * a project that doesn't build with Vite.
 */
-function moduleKey(id) {
-	return id.split("?")[0].replace(/\\/g, "/");
-}
-const CODE_MODULE_EXTENSION = /\.([cm]?[jt]sx?)$/;
-function isStatelessClientSurface(id, appRoot) {
-	const bare = moduleKey(id);
-	if (!isAppSourcePath(bare, appRoot)) return false;
-	if (isServerFile(bare, appRoot)) return false;
-	return isProjectableFile(bare) || isRecognizedUniversalSurface(bare) || isWithinModuleWebFolder(bare, appRoot);
-}
-function collectImportSpecifiers(code) {
-	const ast = parse(code, {
-		sourceType: "module",
-		plugins: ["typescript", "jsx"]
-	});
-	const imports = /* @__PURE__ */ new Set();
-	function walk(node) {
-		if (!node || typeof node !== "object") return;
-		if (Array.isArray(node)) {
-			for (const child of node) walk(child);
-			return;
-		}
-		const record = node;
-		if ((record.type === "ImportDeclaration" || record.type === "ExportNamedDeclaration" || record.type === "ExportAllDeclaration") && record.source?.type === "StringLiteral") imports.add(record.source.value);
-		if (record.type === "CallExpression" && record.callee?.type === "Import" && record.arguments?.[0]?.type === "StringLiteral") imports.add(record.arguments[0].value);
-		if (record.type === "ImportExpression" && record.source?.type === "StringLiteral") imports.add(record.source.value);
-		for (const [key, child] of Object.entries(record)) {
-			if (key === "type" || key === "start" || key === "end" || key === "loc" || key === "range" || key.endsWith("Comments") || key === "extra") continue;
-			walk(child);
-		}
-	}
-	walk(ast.program);
-	return imports;
-}
-function clientViewOf(state, code, id) {
-	const key = moduleKey(id);
-	if (!state.clientBoundModules.has(key) && !isStatelessClientSurface(key, state.appRoot)) return;
-	state.clientBoundModules.add(key);
-	if (!CODE_MODULE_EXTENSION.test(key)) {
-		state.clientImportsByModule.set(key, /* @__PURE__ */ new Set());
-		return code;
-	}
-	const clientCode = isProjectableFile(key) ? projectModule(code, key).code : code;
-	state.clientImportsByModule.set(key, collectImportSpecifiers(clientCode));
-	return clientCode;
-}
-function markResolvedClientModule(state, resolved) {
-	if (!resolved) return;
-	const id = typeof resolved === "string" ? resolved : resolved.id;
-	if (!id.includes("\0")) state.clientBoundModules.add(moduleKey(id));
-}
-function isServerEnvironment(context) {
-	return context.environment?.config.consumer === "server";
-}
-/**
-* Keeps the production/client pipeline byte-identical, while giving Gate A
-* and Gate B a validation-only view in Vite's development SSR environment.
-* SSR still evaluates the original source: only the gates receive the
-* projected client view, so loader/server exports retain their legitimate
-* server access while component-visible code is refused before evaluation.
-*/
-function clientEnvironmentOnly(plugin, ssrState) {
-	const validatesDevSsr = plugin.name === "warlock:gate-a-resolve" || plugin.name === "warlock:gate-b-secrets";
-	const originalTransform = typeof plugin.transform === "function" ? plugin.transform : plugin.transform?.handler;
-	const originalResolveId = typeof plugin.resolveId === "function" ? plugin.resolveId : plugin.resolveId?.handler;
-	const originalBuildStart = typeof plugin.buildStart === "function" ? plugin.buildStart : plugin.buildStart?.handler;
-	return {
-		...plugin,
-		applyToEnvironment(environment) {
-			return environment.config.consumer === "client" || validatesDevSsr && environment.config.consumer === "server";
-		},
-		buildStart: originalBuildStart ? function(...args) {
-			if (isServerEnvironment(this)) return;
-			return originalBuildStart.apply(this, args);
-		} : void 0,
-		transform: originalTransform ? async function(code, id, options) {
-			if (!isServerEnvironment(this)) return originalTransform.call(this, code, id, options);
-			const clientCode = clientViewOf(ssrState, code, id);
-			if (clientCode === void 0) return null;
-			const transformed = await originalTransform.call(this, clientCode, id, {
-				...options,
-				ssr: false
-			});
-			if (plugin.name === "warlock:gate-a-resolve" && originalResolveId) for (const source of ssrState.clientImportsByModule.get(moduleKey(id)) ?? []) markResolvedClientModule(ssrState, await originalResolveId.call(this, source, id, {
-				attributes: {},
-				isEntry: false,
-				ssr: false
-			}));
-			return transformed;
-		} : void 0,
-		resolveId: originalResolveId ? async function(source, importer, options) {
-			if (!isServerEnvironment(this)) return originalResolveId.call(this, source, importer, options);
-			if (!importer) return null;
-			const importerKey = moduleKey(importer);
-			if (!(ssrState.clientBoundModules.has(importerKey) || isStatelessClientSurface(importerKey, ssrState.appRoot))) return null;
-			const survivingImports = ssrState.clientImportsByModule.get(importerKey);
-			if (survivingImports && !survivingImports.has(source)) return null;
-			const resolved = await originalResolveId.call(this, source, importer, {
-				...options,
-				ssr: false
-			});
-			markResolvedClientModule(ssrState, resolved);
-			return resolved;
-		} : void 0
-	};
-}
 /**
 * The composed client-build pipeline: projection
-* strips the 5 server exports first, THEN Gate B's `transform` checks
+* strips the 6 server exports first, THEN Gate B's `transform` checks
 * whatever source remains for inline secret reads, THEN Gate A's
 * `resolveId` judges whatever imports remain. Array order here is
 * `[projection(), gateBSecrets(), gateAResolve()]` to match Vite's own

package/esm/vite/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../../../../../../web/src/vite/index.ts"],"sourcesContent":["/**\n * `@warlock.js/web/vite` — build-tooling subpath, kept separate from the\n * runtime barrel (`@warlock.js/web`) so importing it never pulls `vite` into\n * a project that doesn't build with Vite.\n */\nimport { parse } from \"@babel/parser\";\nimport path from \"node:path\";\nimport type { Plugin } from \"vite\";\nimport {\n  buildHydrationClient,\n  type BuildHydrationClientOptions,\n  type BuildHydrationClientResult,\n} from \"./build-client\";\nimport {\n  gateAResolve,\n  isAppSourcePath,\n  isRecognizedUniversalSurface,\n  isServerFile,\n  isWithinModuleWebFolder,\n} from \"./gate-a-resolve\";\nimport { createPublicEnvTracker, gateBSecrets } from \"./gate-b-secrets\";\nimport { gateCVerify } from \"./gate-c-verify\";\nimport {\n  clientPageRegistry,\n  type ClientPageRegistryPluginOptions,\n} from \"./page-registry-plugin\";\nimport { isProjectableFile, projectModule, projection } from \"./projection\";\n\nexport { buildHydrationClient } from \"./build-client\";\nexport type {\n  BuildHydrationClientOptions,\n  BuildHydrationClientResult,\n  HydrationClientBuildOutput,\n} from \"./build-client\";\nexport { gateAResolve } from \"./gate-a-resolve\";\nexport type {\n  EnvironmentClassifier,\n  EnvironmentClassifierOptions,\n  WarlockEnvironment,\n} from \"./gate-a-resolve\";\nexport { createPublicEnvTracker, gateBSecrets } from \"./gate-b-secrets\";\nexport type { PublicEnvTracker } from \"./gate-b-secrets\";\nexport {\n  buildPublicEnvManifest,\n  findLeakedServerExports,\n  findLeakedServerImportEdges,\n  gateCVerify,\n} from \"./gate-c-verify\";\nexport type {\n  GateCOptions,\n  PublicEnvManifestEntry,\n  ServerExportLeak,\n  ServerImportEdgeLeak,\n} from \"./gate-c-verify\";\nexport {\n  HYDRATION_CLIENT_ENTRY_NAME,\n  createHydrationClientEntry,\n} from \"./hydration-entries\";\nexport type { HydrationClientEntry } from \"./hydration-entries\";\nexport {\n  CLIENT_PAGE_REGISTRY_ID,\n  clientPageRegistry,\n  invalidateClientPageRegistry,\n  RESOLVED_CLIENT_PAGE_REGISTRY_ID,\n} from \"./page-registry-plugin\";\nexport type { ClientPageRegistryPluginOptions } from \"./page-registry-plugin\";\nexport { projection, ProjectionAmbiguityError } from \"./projection\";\nexport type { ProjectionResult } from \"./projection\";\n\nexport type WarlockClientBoundaryOptions = Parameters<\n  typeof gateAResolve\n>[0] & {\n  beforePageHotUpdate?: ClientPageRegistryPluginOptions[\"beforePageHotUpdate\"];\n};\n\nexport type BuildWarlockHydrationClientOptions = Readonly<{\n  appRoot: string;\n  webRoot: string;\n  /** Absolute client output dir — threaded to `buildHydrationClient` (`<outdir>/client`). */\n  outDir: string;\n  resolveAliases: BuildHydrationClientOptions[\"resolveAliases\"];\n  external?: BuildHydrationClientOptions[\"external\"];\n  /** App-configured plugins, appended after Warlock's client-boundary pipeline. */\n  plugins?: BuildHydrationClientOptions[\"plugins\"];\n}>;\n\ntype SsrBoundaryState = {\n  readonly appRoot: string;\n  readonly clientBoundModules: Set<string>;\n  readonly clientImportsByModule: Map<string, Set<string>>;\n};\n\nfunction moduleKey(id: string): string {\n  return id.split(\"?\")[0].replace(/\\\\/g, \"/\");\n}\n\nconst CODE_MODULE_EXTENSION = /\\.([cm]?[jt]sx?)$/;\n\nfunction isStatelessClientSurface(id: string, appRoot: string): boolean {\n  const bare = moduleKey(id);\n  if (!isAppSourcePath(bare, appRoot)) return false;\n  if (isServerFile(bare, appRoot)) return false;\n\n  return (\n    isProjectableFile(bare) ||\n    isRecognizedUniversalSurface(bare) ||\n    isWithinModuleWebFolder(bare, appRoot)\n  );\n}\n\nfunction collectImportSpecifiers(code: string): Set<string> {\n  const ast = parse(code, {\n    sourceType: \"module\",\n    plugins: [\"typescript\", \"jsx\"],\n  });\n  const imports = new Set<string>();\n\n  function walk(node: unknown): void {\n    if (!node || typeof node !== \"object\") return;\n    if (Array.isArray(node)) {\n      for (const child of node) walk(child);\n      return;\n    }\n\n    const record = node as Record<string, any>;\n    if (\n      (record.type === \"ImportDeclaration\" ||\n        record.type === \"ExportNamedDeclaration\" ||\n        record.type === \"ExportAllDeclaration\") &&\n      record.source?.type === \"StringLiteral\"\n    ) {\n      imports.add(record.source.value);\n    }\n    if (\n      record.type === \"CallExpression\" &&\n      record.callee?.type === \"Import\" &&\n      record.arguments?.[0]?.type === \"StringLiteral\"\n    ) {\n      imports.add(record.arguments[0].value);\n    }\n    if (\n      record.type === \"ImportExpression\" &&\n      record.source?.type === \"StringLiteral\"\n    ) {\n      imports.add(record.source.value);\n    }\n\n    for (const [key, child] of Object.entries(record)) {\n      if (\n        key === \"type\" ||\n        key === \"start\" ||\n        key === \"end\" ||\n        key === \"loc\" ||\n        key === \"range\" ||\n        key.endsWith(\"Comments\") ||\n        key === \"extra\"\n      ) {\n        continue;\n      }\n      walk(child);\n    }\n  }\n\n  walk(ast.program);\n  return imports;\n}\n\nfunction clientViewOf(\n  state: SsrBoundaryState,\n  code: string,\n  id: string,\n): string | undefined {\n  const key = moduleKey(id);\n  if (\n    !state.clientBoundModules.has(key) &&\n    !isStatelessClientSurface(key, state.appRoot)\n  ) {\n    return undefined;\n  }\n\n  state.clientBoundModules.add(key);\n  if (!CODE_MODULE_EXTENSION.test(key)) {\n    state.clientImportsByModule.set(key, new Set());\n    return code;\n  }\n\n  const clientCode = isProjectableFile(key)\n    ? projectModule(code, key).code\n    : code;\n  state.clientImportsByModule.set(key, collectImportSpecifiers(clientCode));\n  return clientCode;\n}\n\nfunction markResolvedClientModule(\n  state: SsrBoundaryState,\n  resolved: { id: string } | string | null | false | void,\n): void {\n  if (!resolved) return;\n  const id = typeof resolved === \"string\" ? resolved : resolved.id;\n  if (!id.includes(\"\\0\")) state.clientBoundModules.add(moduleKey(id));\n}\n\nfunction isServerEnvironment(context: {\n  environment?: { config: { consumer?: string } };\n}): boolean {\n  return context.environment?.config.consumer === \"server\";\n}\n\n/**\n * Keeps the production/client pipeline byte-identical, while giving Gate A\n * and Gate B a validation-only view in Vite's development SSR environment.\n * SSR still evaluates the original source: only the gates receive the\n * projected client view, so loader/server exports retain their legitimate\n * server access while component-visible code is refused before evaluation.\n */\nfunction clientEnvironmentOnly(\n  plugin: Plugin,\n  ssrState: SsrBoundaryState,\n): Plugin {\n  const validatesDevSsr =\n    plugin.name === \"warlock:gate-a-resolve\" ||\n    plugin.name === \"warlock:gate-b-secrets\";\n  const originalTransform =\n    typeof plugin.transform === \"function\"\n      ? plugin.transform\n      : plugin.transform?.handler;\n  const originalResolveId =\n    typeof plugin.resolveId === \"function\"\n      ? plugin.resolveId\n      : plugin.resolveId?.handler;\n  const originalBuildStart =\n    typeof plugin.buildStart === \"function\"\n      ? plugin.buildStart\n      : plugin.buildStart?.handler;\n\n  return {\n    ...plugin,\n    applyToEnvironment(environment) {\n      return (\n        environment.config.consumer === \"client\" ||\n        (validatesDevSsr && environment.config.consumer === \"server\")\n      );\n    },\n    buildStart: originalBuildStart\n      ? function (...args) {\n          if (isServerEnvironment(this)) return;\n          return originalBuildStart.apply(this, args);\n        }\n      : undefined,\n    transform: originalTransform\n      ? async function (code, id, options) {\n          if (!isServerEnvironment(this)) {\n            return originalTransform.call(this, code, id, options);\n          }\n\n          const clientCode = clientViewOf(ssrState, code, id);\n          if (clientCode === undefined) return null;\n\n          const transformed = await originalTransform.call(\n            this,\n            clientCode,\n            id,\n            {\n              ...options,\n              ssr: false,\n            },\n          );\n\n          // Vite can externalize a package in the SSR environment before its\n          // normal resolver walk offers that edge to a plugin. Gate A cannot\n          // wait for that walk: validate every import that survived projection\n          // now, while the original TypeScript source and importer are known.\n          if (plugin.name === \"warlock:gate-a-resolve\" && originalResolveId) {\n            for (const source of ssrState.clientImportsByModule.get(\n              moduleKey(id),\n            ) ?? []) {\n              const resolved = await originalResolveId.call(this, source, id, {\n                attributes: {},\n                isEntry: false,\n                ssr: false,\n              });\n              markResolvedClientModule(ssrState, resolved);\n            }\n          }\n\n          return transformed;\n        }\n      : undefined,\n    resolveId: originalResolveId\n      ? async function (source, importer, options) {\n          if (!isServerEnvironment(this)) {\n            return originalResolveId.call(this, source, importer, options);\n          }\n\n          if (!importer) return null;\n          const importerKey = moduleKey(importer);\n          const isClientBound =\n            ssrState.clientBoundModules.has(importerKey) ||\n            isStatelessClientSurface(importerKey, ssrState.appRoot);\n          if (!isClientBound) return null;\n\n          const survivingImports =\n            ssrState.clientImportsByModule.get(importerKey);\n          if (survivingImports && !survivingImports.has(source)) return null;\n\n          const resolved = await originalResolveId.call(\n            this,\n            source,\n            importer,\n            {\n              ...options,\n              ssr: false,\n            },\n          );\n          markResolvedClientModule(ssrState, resolved);\n          return resolved;\n        }\n      : undefined,\n  };\n}\n\n/**\n * The composed client-build pipeline: projection\n * strips the 5 server exports first, THEN Gate B's `transform` checks\n * whatever source remains for inline secret reads, THEN Gate A's\n * `resolveId` judges whatever imports remain. Array order here is\n * `[projection(), gateBSecrets(), gateAResolve()]` to match Vite's own\n * pipeline shape (`transform` before `resolveId`), but array order alone\n * does not guarantee this — see the hook-ordering fact below, which is what\n * actually makes the composition correct.\n *\n * Empirically observed fact (via an instrumented real `vite.build()`, not\n * assumed from plugin array order): for a given module M, Vite/Rollup calls\n * `transform(M)` BEFORE it calls `resolveId` for any of M's own import\n * specifiers — because Rollup must parse M's post-transform source to even\n * discover which specifiers to resolve next. Concretely: `transform` ran on\n * `entry.page.tsx` first, and only after that did `resolveId(\"./dep\", ...)`\n * fire for the import statement still present in the transformed code. A\n * consequence follows directly: if projection's `transform` removes an\n * import statement from a page module entirely (e.g. `loader`'s\n * `@warlock.js/core` import, stripped because `loader` itself is removed),\n * `resolveId` is never invoked for that specifier at all — Gate A doesn't\n * \"let it pass\", it never sees it. Gate A's `resolveId` only fires for\n * imports that survive projection's `transform`, which is exactly why a\n * component-level `@warlock.js/core` import (never touched by projection)\n * still reaches and is refused by Gate A.\n *\n * This is OBSERVED Rollup behavior, not a documented contract — a future\n * Vite/Rollup upgrade could invert it. Pinned by a\n * regression test (`index.spec.ts`, \"D.3 hook ordering pin\") that fails\n * loudly if the ordering ever inverts, and by the `vite` peer floor in\n * `web/package.json` (`>=7.3.5`, the version this was verified against). If\n * that test ever fails after a Vite bump: the failure mode of the ordering\n * assumption breaking is SAFE — projection would stop removing an import\n * statement Gate A still sees, so Gate A would refuse an import it used to\n * silently let a stripped server export take with it. That is a loud build\n * failure (\"Gate A refused an import\"), never a silent client-bundle leak.\n * Do NOT \"fix\" an apparent Gate A false-positive after a Vite upgrade by\n * weakening Gate A (e.g. widening what it lets through) — investigate\n * whether this ordering assumption broke instead; loosening Gate A to work\n * around it would turn a loud failure into the exact silent leak this\n * pipeline exists to prevent.\n *\n * Gate B is placed between the two for the same reason, but for a `transform`\n * hook rather than `resolveId`: within a plugin array, Rollup runs each\n * module's registered `transform` hooks in array order, each one receiving\n * the PREVIOUS plugin's output. Running Gate B after projection means it\n * inspects the POST-projection source — a `process.env.SECRET` read inside\n * `loader` (a server export, legitimately reading a real secret server-side)\n * is invisible to Gate B once projection has already removed `loader`\n * entirely, exactly as it should be: Gate B's job is to fence client-bound\n * code, and projection is what decides what counts as client-bound. A\n * component-level secret read is untouched by projection and still reaches\n * Gate B, which refuses it. Gate B does not depend on Gate A's `resolveId`\n * output at all (orthogonal concern, raw source vs. import paths), so its\n * position relative to Gate A is not load-bearing — it is placed before Gate\n * A only to keep both `transform` hooks adjacent in the array.\n *\n * Gate C (`gate-c-verify.ts`) runs last and only at `generateBundle` — after\n * the entire `transform`/`resolveId` build phase has completed for every\n * plugin, regardless of array position (a Rollup lifecycle fact, not\n * something this array order enforces). It verifies the EMITTED output the\n * other three produced: no server export survived as a top-level binding, no\n * import edge into a server-only package survived into the module graph, and\n * it emits the reviewable `PUBLIC_*` inlined-value manifest. `gateBSecrets` and `gateCVerify` share\n * one `PublicEnvTracker` instance so the manifest and Gate B's own unread-key\n * exclusion check agree by construction, not by coincidence.\n *\n * `clientPageRegistry()` is FIRST, ahead of projection. It contributes no\n * `transform` at all — only a `resolveId`/`load` pair for one synthetic id —\n * so it cannot displace or pre-empt any gate's inspection of any real file.\n * Two reasons for the position, one of which is not load-bearing and is\n * labelled as such:\n *\n * 1. Load-bearing: it must own `virtual:warlock/pages` before Gate A's\n *    `resolveId` (also `enforce: \"pre\"`) reaches its `this.resolve(...)` call\n *    for that specifier. Gate A's nested resolve would find it anyway, but\n *    routing the id through Gate A's importer-chain bookkeeping only to have\n *    it come back means a synthetic id can surface in a user-facing \"Import\n *    chain:\" message. Resolving it first keeps ownership of the id in one\n *    place.\n * 2. NOT load-bearing: the position relative to `projection()`. Projection is\n *    `enforce: \"pre\"` and selects by file BASENAME (`projection.ts:242-248`),\n *    so it transforms every `*.page.tsx` / `layout.tsx` / `root.tsx` that\n *    enters the graph regardless of who imported it or where this plugin sits.\n *    The registry emits absolute POSIX specifiers that Rollup resolves and\n *    loads as ORDINARY file modules — they are not inlined into the virtual\n *    module — so each one is transformed exactly as a page imported from a\n *    real file would be. Projection declines the virtual module itself\n *    (`\\0virtual:warlock/pages` has no matching basename), which is correct:\n *    generated code has no server exports to strip.\n *\n * Point 2 is asserted, not assumed, by a real `vite.build()` in\n * `page-registry-plugin.spec.ts`: a fixture page whose `loader` — and only its\n * `loader` — imports a marker module that Gate A independently PERMITS, built\n * through this exact array, with the marker proven absent from every emitted\n * chunk while the page's own component text is proven present. Inspecting this\n * array's order would prove nothing about what reaches the browser.\n */\nexport function warlockClientBoundary(\n  options: WarlockClientBoundaryOptions = {},\n): Plugin[] {\n  const tracker = createPublicEnvTracker();\n  const ssrState: SsrBoundaryState = {\n    appRoot: path.resolve(options.appRoot ?? process.cwd()),\n    clientBoundModules: new Set(),\n    clientImportsByModule: new Map(),\n  };\n  return [\n    clientPageRegistry({\n      appRoot: options.appRoot,\n      beforePageHotUpdate: options.beforePageHotUpdate,\n    }),\n    projection(),\n    gateBSecrets({ tracker }),\n    gateAResolve(options),\n    gateCVerify({ ...options, tracker }),\n  ].map((plugin) => clientEnvironmentOnly(plugin, ssrState));\n}\n\n/**\n * Callable production seam: callers own their exact source aliases and the\n * app-root classification boundary, while this module owns the one canonical\n * projection/Gate B/Gate A/Gate C composition.\n */\nexport async function buildWarlockHydrationClient(\n  options: BuildWarlockHydrationClientOptions,\n): Promise<BuildHydrationClientResult> {\n  return buildHydrationClient({\n    webRoot: options.webRoot,\n    outDir: options.outDir,\n    resolveAliases: options.resolveAliases,\n    external: options.external,\n    plugins: [\n      ...warlockClientBoundary({ appRoot: options.appRoot }),\n      ...(options.plugins ?? []),\n    ],\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;AA4FA,SAAS,UAAU,IAAoB;CACrC,OAAO,GAAG,MAAM,GAAG,CAAC,CAAC,EAAE,CAAC,QAAQ,OAAO,GAAG;AAC5C;AAEA,MAAM,wBAAwB;AAE9B,SAAS,yBAAyB,IAAY,SAA0B;CACtE,MAAM,OAAO,UAAU,EAAE;CACzB,IAAI,CAAC,gBAAgB,MAAM,OAAO,GAAG,OAAO;CAC5C,IAAI,aAAa,MAAM,OAAO,GAAG,OAAO;CAExC,OACE,kBAAkB,IAAI,KACtB,6BAA6B,IAAI,KACjC,wBAAwB,MAAM,OAAO;AAEzC;AAEA,SAAS,wBAAwB,MAA2B;CAC1D,MAAM,MAAM,MAAM,MAAM;EACtB,YAAY;EACZ,SAAS,CAAC,cAAc,KAAK;CAC/B,CAAC;CACD,MAAM,0BAAU,IAAI,IAAY;CAEhC,SAAS,KAAK,MAAqB;EACjC,IAAI,CAAC,QAAQ,OAAO,SAAS,UAAU;EACvC,IAAI,MAAM,QAAQ,IAAI,GAAG;GACvB,KAAK,MAAM,SAAS,MAAM,KAAK,KAAK;GACpC;EACF;EAEA,MAAM,SAAS;EACf,KACG,OAAO,SAAS,uBACf,OAAO,SAAS,4BAChB,OAAO,SAAS,2BAClB,OAAO,QAAQ,SAAS,iBAExB,QAAQ,IAAI,OAAO,OAAO,KAAK;EAEjC,IACE,OAAO,SAAS,oBAChB,OAAO,QAAQ,SAAS,YACxB,OAAO,YAAY,EAAE,EAAE,SAAS,iBAEhC,QAAQ,IAAI,OAAO,UAAU,EAAE,CAAC,KAAK;EAEvC,IACE,OAAO,SAAS,sBAChB,OAAO,QAAQ,SAAS,iBAExB,QAAQ,IAAI,OAAO,OAAO,KAAK;EAGjC,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,GAAG;GACjD,IACE,QAAQ,UACR,QAAQ,WACR,QAAQ,SACR,QAAQ,SACR,QAAQ,WACR,IAAI,SAAS,UAAU,KACvB,QAAQ,SAER;GAEF,KAAK,KAAK;EACZ;CACF;CAEA,KAAK,IAAI,OAAO;CAChB,OAAO;AACT;AAEA,SAAS,aACP,OACA,MACA,IACoB;CACpB,MAAM,MAAM,UAAU,EAAE;CACxB,IACE,CAAC,MAAM,mBAAmB,IAAI,GAAG,KACjC,CAAC,yBAAyB,KAAK,MAAM,OAAO,GAE5C;CAGF,MAAM,mBAAmB,IAAI,GAAG;CAChC,IAAI,CAAC,sBAAsB,KAAK,GAAG,GAAG;EACpC,MAAM,sBAAsB,IAAI,qBAAK,IAAI,IAAI,CAAC;EAC9C,OAAO;CACT;CAEA,MAAM,aAAa,kBAAkB,GAAG,IACpC,cAAc,MAAM,GAAG,CAAC,CAAC,OACzB;CACJ,MAAM,sBAAsB,IAAI,KAAK,wBAAwB,UAAU,CAAC;CACxE,OAAO;AACT;AAEA,SAAS,yBACP,OACA,UACM;CACN,IAAI,CAAC,UAAU;CACf,MAAM,KAAK,OAAO,aAAa,WAAW,WAAW,SAAS;CAC9D,IAAI,CAAC,GAAG,SAAS,IAAI,GAAG,MAAM,mBAAmB,IAAI,UAAU,EAAE,CAAC;AACpE;AAEA,SAAS,oBAAoB,SAEjB;CACV,OAAO,QAAQ,aAAa,OAAO,aAAa;AAClD;;;;;;;;AASA,SAAS,sBACP,QACA,UACQ;CACR,MAAM,kBACJ,OAAO,SAAS,4BAChB,OAAO,SAAS;CAClB,MAAM,oBACJ,OAAO,OAAO,cAAc,aACxB,OAAO,YACP,OAAO,WAAW;CACxB,MAAM,oBACJ,OAAO,OAAO,cAAc,aACxB,OAAO,YACP,OAAO,WAAW;CACxB,MAAM,qBACJ,OAAO,OAAO,eAAe,aACzB,OAAO,aACP,OAAO,YAAY;CAEzB,OAAO;EACL,GAAG;EACH,mBAAmB,aAAa;GAC9B,OACE,YAAY,OAAO,aAAa,YAC/B,mBAAmB,YAAY,OAAO,aAAa;EAExD;EACA,YAAY,qBACR,SAAU,GAAG,MAAM;GACjB,IAAI,oBAAoB,IAAI,GAAG;GAC/B,OAAO,mBAAmB,MAAM,MAAM,IAAI;EAC5C,IACA;EACJ,WAAW,oBACP,eAAgB,MAAM,IAAI,SAAS;GACjC,IAAI,CAAC,oBAAoB,IAAI,GAC3B,OAAO,kBAAkB,KAAK,MAAM,MAAM,IAAI,OAAO;GAGvD,MAAM,aAAa,aAAa,UAAU,MAAM,EAAE;GAClD,IAAI,eAAe,QAAW,OAAO;GAErC,MAAM,cAAc,MAAM,kBAAkB,KAC1C,MACA,YACA,IACA;IACE,GAAG;IACH,KAAK;GACP,CACF;GAMA,IAAI,OAAO,SAAS,4BAA4B,mBAC9C,KAAK,MAAM,UAAU,SAAS,sBAAsB,IAClD,UAAU,EAAE,CACd,KAAK,CAAC,GAMJ,yBAAyB,UAAU,MALZ,kBAAkB,KAAK,MAAM,QAAQ,IAAI;IAC9D,YAAY,CAAC;IACb,SAAS;IACT,KAAK;GACP,CAAC,CAC0C;GAI/C,OAAO;EACT,IACA;EACJ,WAAW,oBACP,eAAgB,QAAQ,UAAU,SAAS;GACzC,IAAI,CAAC,oBAAoB,IAAI,GAC3B,OAAO,kBAAkB,KAAK,MAAM,QAAQ,UAAU,OAAO;GAG/D,IAAI,CAAC,UAAU,OAAO;GACtB,MAAM,cAAc,UAAU,QAAQ;GAItC,IAAI,EAFF,SAAS,mBAAmB,IAAI,WAAW,KAC3C,yBAAyB,aAAa,SAAS,OAAO,IACpC,OAAO;GAE3B,MAAM,mBACJ,SAAS,sBAAsB,IAAI,WAAW;GAChD,IAAI,oBAAoB,CAAC,iBAAiB,IAAI,MAAM,GAAG,OAAO;GAE9D,MAAM,WAAW,MAAM,kBAAkB,KACvC,MACA,QACA,UACA;IACE,GAAG;IACH,KAAK;GACP,CACF;GACA,yBAAyB,UAAU,QAAQ;GAC3C,OAAO;EACT,IACA;CACN;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoGA,SAAgB,sBACd,UAAwC,CAAC,GAC/B;CACV,MAAM,UAAU,uBAAuB;CACvC,MAAM,WAA6B;EACjC,SAAS,KAAK,QAAQ,QAAQ,WAAW,QAAQ,IAAI,CAAC;EACtD,oCAAoB,IAAI,IAAI;EAC5B,uCAAuB,IAAI,IAAI;CACjC;CACA,OAAO;EACL,mBAAmB;GACjB,SAAS,QAAQ;GACjB,qBAAqB,QAAQ;EAC/B,CAAC;EACD,WAAW;EACX,aAAa,EAAE,QAAQ,CAAC;EACxB,aAAa,OAAO;EACpB,YAAY;GAAE,GAAG;GAAS;EAAQ,CAAC;CACrC,CAAC,CAAC,KAAK,WAAW,sBAAsB,QAAQ,QAAQ,CAAC;AAC3D;;;;;;AAOA,eAAsB,4BACpB,SACqC;CACrC,OAAO,qBAAqB;EAC1B,SAAS,QAAQ;EACjB,QAAQ,QAAQ;EAChB,gBAAgB,QAAQ;EACxB,UAAU,QAAQ;EAClB,SAAS,CACP,GAAG,sBAAsB,EAAE,SAAS,QAAQ,QAAQ,CAAC,GACrD,GAAI,QAAQ,WAAW,CAAC,CAC1B;CACF,CAAC;AACH"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../../../../../web/src/vite/index.ts"],"sourcesContent":["/**\r\n * `@warlock.js/web/vite` — build-tooling subpath, kept separate from the\r\n * runtime barrel (`@warlock.js/web`) so importing it never pulls `vite` into\r\n * a project that doesn't build with Vite.\r\n */\r\nimport path from \"node:path\";\r\nimport type { Plugin } from \"vite\";\r\nimport {\r\n  buildHydrationClient,\r\n  type BuildHydrationClientOptions,\r\n  type BuildHydrationClientResult,\r\n} from \"./build-client\";\r\nimport { gateAResolve } from \"./gate-a-resolve\";\r\nimport { createPublicEnvTracker, gateBSecrets } from \"./gate-b-secrets\";\r\nimport { gateCVerify } from \"./gate-c-verify\";\r\nimport { clientPageRegistry, type ClientPageRegistryPluginOptions } from \"./page-registry-plugin\";\r\nimport { projection } from \"./projection\";\r\nimport { clientEnvironmentOnly, type SsrBoundaryState } from \"./ssr-client-view\";\r\n\r\nexport { buildHydrationClient } from \"./build-client\";\r\nexport type {\r\n  BuildHydrationClientOptions,\r\n  BuildHydrationClientResult,\r\n  HydrationClientBuildOutput,\r\n} from \"./build-client\";\r\nexport { gateAResolve } from \"./gate-a-resolve\";\r\nexport type {\r\n  EnvironmentClassifier,\r\n  EnvironmentClassifierOptions,\r\n  WarlockEnvironment,\r\n} from \"./gate-a-resolve\";\r\nexport { createPublicEnvTracker, gateBSecrets } from \"./gate-b-secrets\";\r\nexport type { PublicEnvTracker } from \"./gate-b-secrets\";\r\nexport {\r\n  buildPublicEnvManifest,\r\n  findLeakedServerExports,\r\n  findLeakedServerImportEdges,\r\n  gateCVerify,\r\n} from \"./gate-c-verify\";\r\nexport type {\r\n  GateCOptions,\r\n  PublicEnvManifestEntry,\r\n  ServerExportLeak,\r\n  ServerImportEdgeLeak,\r\n} from \"./gate-c-verify\";\r\nexport { HYDRATION_CLIENT_ENTRY_NAME, createHydrationClientEntry } from \"./hydration-entries\";\r\nexport type { HydrationClientEntry } from \"./hydration-entries\";\r\nexport {\r\n  CLIENT_PAGE_REGISTRY_ID,\r\n  clientPageRegistry,\r\n  invalidateClientPageRegistry,\r\n  RESOLVED_CLIENT_PAGE_REGISTRY_ID,\r\n} from \"./page-registry-plugin\";\r\nexport type { ClientPageRegistryPluginOptions } from \"./page-registry-plugin\";\r\nexport { projection, ProjectionAmbiguityError } from \"./projection\";\r\nexport type { ProjectionResult } from \"./projection\";\r\n\r\nexport type WarlockClientBoundaryOptions = Parameters<typeof gateAResolve>[0] & {\r\n  beforePageHotUpdate?: ClientPageRegistryPluginOptions[\"beforePageHotUpdate\"];\r\n};\r\n\r\nexport type BuildWarlockHydrationClientOptions = Readonly<{\r\n  appRoot: string;\r\n  webRoot: string;\r\n  /** Absolute client output dir — threaded to `buildHydrationClient` (`<outdir>/client`). */\r\n  outDir: string;\r\n  resolveAliases: BuildHydrationClientOptions[\"resolveAliases\"];\r\n  external?: BuildHydrationClientOptions[\"external\"];\r\n  /** App-configured plugins, appended after Warlock's client-boundary pipeline. */\r\n  plugins?: BuildHydrationClientOptions[\"plugins\"];\r\n}>;\r\n\r\n/**\r\n * The composed client-build pipeline: projection\r\n * strips the 6 server exports first, THEN Gate B's `transform` checks\r\n * whatever source remains for inline secret reads, THEN Gate A's\r\n * `resolveId` judges whatever imports remain. Array order here is\r\n * `[projection(), gateBSecrets(), gateAResolve()]` to match Vite's own\r\n * pipeline shape (`transform` before `resolveId`), but array order alone\r\n * does not guarantee this — see the hook-ordering fact below, which is what\r\n * actually makes the composition correct.\r\n *\r\n * Empirically observed fact (via an instrumented real `vite.build()`, not\r\n * assumed from plugin array order): for a given module M, Vite/Rollup calls\r\n * `transform(M)` BEFORE it calls `resolveId` for any of M's own import\r\n * specifiers — because Rollup must parse M's post-transform source to even\r\n * discover which specifiers to resolve next. Concretely: `transform` ran on\r\n * `entry.page.tsx` first, and only after that did `resolveId(\"./dep\", ...)`\r\n * fire for the import statement still present in the transformed code. A\r\n * consequence follows directly: if projection's `transform` removes an\r\n * import statement from a page module entirely (e.g. `loader`'s\r\n * `@warlock.js/core` import, stripped because `loader` itself is removed),\r\n * `resolveId` is never invoked for that specifier at all — Gate A doesn't\r\n * \"let it pass\", it never sees it. Gate A's `resolveId` only fires for\r\n * imports that survive projection's `transform`, which is exactly why a\r\n * component-level `@warlock.js/core` import (never touched by projection)\r\n * still reaches and is refused by Gate A.\r\n *\r\n * This is OBSERVED Rollup behavior, not a documented contract — a future\r\n * Vite/Rollup upgrade could invert it. Pinned by a\r\n * regression test (`index.spec.ts`, \"D.3 hook ordering pin\") that fails\r\n * loudly if the ordering ever inverts, and by the `vite` peer floor in\r\n * `web/package.json` (`>=7.3.5`, the version this was verified against). If\r\n * that test ever fails after a Vite bump: the failure mode of the ordering\r\n * assumption breaking is SAFE — projection would stop removing an import\r\n * statement Gate A still sees, so Gate A would refuse an import it used to\r\n * silently let a stripped server export take with it. That is a loud build\r\n * failure (\"Gate A refused an import\"), never a silent client-bundle leak.\r\n * Do NOT \"fix\" an apparent Gate A false-positive after a Vite upgrade by\r\n * weakening Gate A (e.g. widening what it lets through) — investigate\r\n * whether this ordering assumption broke instead; loosening Gate A to work\r\n * around it would turn a loud failure into the exact silent leak this\r\n * pipeline exists to prevent.\r\n *\r\n * Gate B is placed between the two for the same reason, but for a `transform`\r\n * hook rather than `resolveId`: within a plugin array, Rollup runs each\r\n * module's registered `transform` hooks in array order, each one receiving\r\n * the PREVIOUS plugin's output. Running Gate B after projection means it\r\n * inspects the POST-projection source — a `process.env.SECRET` read inside\r\n * `loader` (a server export, legitimately reading a real secret server-side)\r\n * is invisible to Gate B once projection has already removed `loader`\r\n * entirely, exactly as it should be: Gate B's job is to fence client-bound\r\n * code, and projection is what decides what counts as client-bound. A\r\n * component-level secret read is untouched by projection and still reaches\r\n * Gate B, which refuses it. Gate B does not depend on Gate A's `resolveId`\r\n * output at all (orthogonal concern, raw source vs. import paths), so its\r\n * position relative to Gate A is not load-bearing — it is placed before Gate\r\n * A only to keep both `transform` hooks adjacent in the array.\r\n *\r\n * Gate C (`gate-c-verify.ts`) runs last and only at `generateBundle` — after\r\n * the entire `transform`/`resolveId` build phase has completed for every\r\n * plugin, regardless of array position (a Rollup lifecycle fact, not\r\n * something this array order enforces). It verifies the EMITTED output the\r\n * other three produced: no server export survived as a top-level binding, no\r\n * import edge into a server-only package survived into the module graph, and\r\n * it emits the reviewable `PUBLIC_*` inlined-value manifest. `gateBSecrets` and `gateCVerify` share\r\n * one `PublicEnvTracker` instance so the manifest and Gate B's own unread-key\r\n * exclusion check agree by construction, not by coincidence.\r\n *\r\n * `clientPageRegistry()` is FIRST, ahead of projection. It contributes no\r\n * `transform` at all — only a `resolveId`/`load` pair for one synthetic id —\r\n * so it cannot displace or pre-empt any gate's inspection of any real file.\r\n * Two reasons for the position, one of which is not load-bearing and is\r\n * labelled as such:\r\n *\r\n * 1. Load-bearing: it must own `virtual:warlock/pages` before Gate A's\r\n *    `resolveId` (also `enforce: \"pre\"`) reaches its `this.resolve(...)` call\r\n *    for that specifier. Gate A's nested resolve would find it anyway, but\r\n *    routing the id through Gate A's importer-chain bookkeeping only to have\r\n *    it come back means a synthetic id can surface in a user-facing \"Import\r\n *    chain:\" message. Resolving it first keeps ownership of the id in one\r\n *    place.\r\n * 2. NOT load-bearing: the position relative to `projection()`. Projection is\r\n *    `enforce: \"pre\"` and selects by file BASENAME (`projection.ts:242-248`),\r\n *    so it transforms every `*.page.tsx` / `layout.tsx` / `root.tsx` that\r\n *    enters the graph regardless of who imported it or where this plugin sits.\r\n *    The registry emits absolute POSIX specifiers that Rollup resolves and\r\n *    loads as ORDINARY file modules — they are not inlined into the virtual\r\n *    module — so each one is transformed exactly as a page imported from a\r\n *    real file would be. Projection declines the virtual module itself\r\n *    (`\\0virtual:warlock/pages` has no matching basename), which is correct:\r\n *    generated code has no server exports to strip.\r\n *\r\n * Point 2 is asserted, not assumed, by a real `vite.build()` in\r\n * `page-registry-plugin.spec.ts`: a fixture page whose `loader` — and only its\r\n * `loader` — imports a marker module that Gate A independently PERMITS, built\r\n * through this exact array, with the marker proven absent from every emitted\r\n * chunk while the page's own component text is proven present. Inspecting this\r\n * array's order would prove nothing about what reaches the browser.\r\n */\r\nexport function warlockClientBoundary(options: WarlockClientBoundaryOptions = {}): Plugin[] {\r\n  const tracker = createPublicEnvTracker();\r\n  const ssrState: SsrBoundaryState = {\r\n    appRoot: path.resolve(options.appRoot ?? process.cwd()),\r\n    clientBoundModules: new Set(),\r\n    clientImportsByModule: new Map(),\r\n  };\r\n  return [\r\n    clientPageRegistry({\r\n      appRoot: options.appRoot,\r\n      beforePageHotUpdate: options.beforePageHotUpdate,\r\n    }),\r\n    projection(),\r\n    gateBSecrets({ tracker }),\r\n    gateAResolve(options),\r\n    gateCVerify({ ...options, tracker }),\r\n  ].map((plugin) => clientEnvironmentOnly(plugin, ssrState));\r\n}\r\n\r\n/**\r\n * Callable production seam: callers own their exact source aliases and the\r\n * app-root classification boundary, while this module owns the one canonical\r\n * projection/Gate B/Gate A/Gate C composition.\r\n */\r\nexport async function buildWarlockHydrationClient(\r\n  options: BuildWarlockHydrationClientOptions,\r\n): Promise<BuildHydrationClientResult> {\r\n  return buildHydrationClient({\r\n    webRoot: options.webRoot,\r\n    outDir: options.outDir,\r\n    resolveAliases: options.resolveAliases,\r\n    external: options.external,\r\n    plugins: [...warlockClientBoundary({ appRoot: options.appRoot }), ...(options.plugins ?? [])],\r\n  });\r\n}\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0KA,SAAgB,sBAAsB,UAAwC,CAAC,GAAa;CAC1F,MAAM,UAAU,uBAAuB;CACvC,MAAM,WAA6B;EACjC,SAAS,KAAK,QAAQ,QAAQ,WAAW,QAAQ,IAAI,CAAC;EACtD,oCAAoB,IAAI,IAAI;EAC5B,uCAAuB,IAAI,IAAI;CACjC;CACA,OAAO;EACL,mBAAmB;GACjB,SAAS,QAAQ;GACjB,qBAAqB,QAAQ;EAC/B,CAAC;EACD,WAAW;EACX,aAAa,EAAE,QAAQ,CAAC;EACxB,aAAa,OAAO;EACpB,YAAY;GAAE,GAAG;GAAS;EAAQ,CAAC;CACrC,CAAC,CAAC,KAAK,WAAW,sBAAsB,QAAQ,QAAQ,CAAC;AAC3D;;;;;;AAOA,eAAsB,4BACpB,SACqC;CACrC,OAAO,qBAAqB;EAC1B,SAAS,QAAQ;EACjB,QAAQ,QAAQ;EAChB,gBAAgB,QAAQ;EACxB,UAAU,QAAQ;EAClB,SAAS,CAAC,GAAG,sBAAsB,EAAE,SAAS,QAAQ,QAAQ,CAAC,GAAG,GAAI,QAAQ,WAAW,CAAC,CAAE;CAC9F,CAAC;AACH"}

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

@@ -1,5 +1,6 @@
-import { discoverPages, toPosix } from "../build/discover-pages.mjs";
-import { SERVER_EXPORT_NAMES } from "./projection.mjs";
+import { toPosix } from "../shared/to-posix.mjs";
+import { discoverPages } from "../build/discover-pages.mjs";
+import { SERVER_EXPORT_NAMES, isProjectableFile } from "./projection.mjs";
 import { generateClientRegistry } from "../build/generate-client-registry.mjs";
 import path from "node:path";
 import { parse } from "@babel/parser";
@@ -59,11 +60,9 @@ function invalidateClientPageRegistry(vite) {
 * directory. `./blog.page.tsx` from that importer resolves to nonsense that
 * fails at bundle time with a path no user authored and no user can act on.
 *
-* Separator normalization is `hydration-entries.ts`'s
-* (`hydration-entries.ts:12-14`) and `discover-pages.ts`'s single
-* `.replace(/\\/g, "/")` rule, reused via the already-exported `toPosix` rather
-* than spelled a third time — keeping the drive colon (`D:/...`) is exactly
-* what Vite's resolver wants on Windows.
+* Separator normalization goes through the one shared `toPosix`
+* (`../shared/to-posix`) — keeping the drive colon (`D:/...`) is exactly what
+* Vite's resolver wants on Windows.
 */
 function toImportSpecifier(absoluteFilePath) {
 	return toPosix(path.resolve(absoluteFilePath));
@@ -113,22 +112,6 @@ function eraseTypes(source) {
 	return magic.toString();
 }
 /**
-* The four file shapes that carry SERVER data (`metadata` chief among them)
-* and are therefore projected before the client graph forms — the exact set
-* `projection.ts`'s `isProjectableFile` matches, spelled here by BASENAME so
-* the two agree by construction on what "a server-side page module" is. A
-* change to one of these is the only kind of change whose SERVER half
-* (`metadata`, `loader`, …) can move without the client half moving at all.
-*/
-function isServerPageModule(file) {
-	const base = path.basename(file.split("?")[0]);
-	if (/\.page\.tsx?$/.test(base)) return true;
-	if (base === "layout.tsx" || base === "layout.ts") return true;
-	if (/\.layout\.tsx?$/.test(base)) return true;
-	if (base === "root.tsx") return true;
-	return false;
-}
-/**
 * What replaces a refresh-safe body in the skeleton. Its content is irrelevant —
 * only that it is CONSTANT, so two sources that differ solely inside a masked
 * body serialise identically.
@@ -336,7 +319,7 @@ function clientPageRegistry(options = {}) {
 		*/
 		transform(code, id) {
 			if (this.environment?.mode !== "dev") return void 0;
-			if (!isServerPageModule(id)) return void 0;
+			if (!isProjectableFile(id)) return void 0;
 			const skeleton = captureSkeleton(code);
 			if (skeleton !== void 0) skeletonCache.set(id, skeleton);
 		},
@@ -355,14 +338,14 @@ function clientPageRegistry(options = {}) {
 		* construction.
 		*/
 		async hotUpdate(context) {
-			if (isServerPageModule(context.file)) {
+			if (isProjectableFile(context.file)) {
 				if (await options.beforePageHotUpdate?.({
 					file: context.file,
 					type: context.type
 				})) return [];
 			}
 			if (context.type !== "update") return void 0;
-			if (!isServerPageModule(context.file)) return void 0;
+			if (!isProjectableFile(context.file)) return void 0;
 			const next = captureSkeleton(await context.read());
 			const prev = skeletonCache.get(context.file);
 			if (next !== void 0) skeletonCache.set(context.file, next);