@warlock.js/web 5.0.0

package/esm/vite/projection.mjs

@@ -0,0 +1,384 @@
+import path from "node:path";
+import { parse } from "@babel/parser";
+import MagicString from "magic-string";
+
+//#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.
+*
+* Removes `export const route/middleware/validation/loader/metadata = ...`
+* (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
+* unconditionally, regardless of what they reference — classification is by
+* FILE, not by what an export does with data (`c604f0bc` §9).
+*
+* ATTRIBUTION APPLIES TO LOCAL DECLARATIONS, NOT JUST IMPORTS. A page or
+* layout hoists things to module scope for two ordinary reasons, and the
+* reference graph tells them apart without guessing:
+*
+*   `const publishCart: Middleware = ...` + `export const middleware =
+*   [publishCart]` (`v5/app/.../products/web/layout.tsx:30,43`) — the only
+*   reader is a server export being removed, so the binding goes with it.
+*
+*   `const COMMON_TIMEZONES = [...]` read by the default export
+*   (`v5/app/.../account/settings.page.tsx:118,129`) — a surviving reader, so
+*   it survives.
+*
+* That is the SAME rule already applied to import bindings, extended to the
+* other binding kind. It is deliberately not a widening of
+* `SERVER_EXPORT_NAMES`, and not "accept what I don't recognise": a
+* declaration is kept when something the client keeps reads it, dropped when
+* nothing does AND dropping it cannot delete a side effect, and REFUSED
+* otherwise — see `isDefinitionShapedInit`.
+*
+* This is NOT Gate A (`resolveId` path refusal), Gate B (inline secret
+* reads) or Gate C (emitted-output verification) — those are separate,
+* later slices. Projection runs first; the gates enforce after.
+*/
+/**
+* Exported so Gate C (`gate-c-verify.ts`) can re-derive "does the emitted
+* bundle contain a server export as a top-level binding" from this exact set
+* rather than hand-typing a second copy that could drift from projection's
+* own list.
+*/
+const SERVER_EXPORT_NAMES = new Set([
+	"route",
+	"middleware",
+	"validation",
+	"loader",
+	"metadata"
+]);
+/**
+* Recognized client-safe assets that always survive projection untouched,
+* whether imported bare (`import "./x.css"`) or with specifiers
+* (`import styles from "./x.module.css"`) — `c604f0bc` §3 names CSS
+* explicitly; the rest of this list is the same "never guess, but a known
+* asset extension is not ambiguous" reasoning extended to the other static
+* asset kinds Vite treats as URL/asset imports, not executable code.
+*/
+const ASSET_EXTENSION_RE = /\.(css|scss|sass|less|styl|stylus|svg|png|jpe?g|gif|webp|avif|ico|woff2?|ttf|eot|otf)(\?.*)?$/i;
+/**
+* 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
+* names) plus type-only declarations survive unconditionally per
+* `c604f0bc` §9 ("classify FILES, not the data they touch").
+*/
+const ALWAYS_SAFE_STATEMENT_TYPES = new Set([
+	"ExportNamedDeclaration",
+	"ExportDefaultDeclaration",
+	"ExportAllDeclaration",
+	"TSInterfaceDeclaration",
+	"TSTypeAliasDeclaration",
+	"EmptyStatement"
+]);
+/**
+* Thrown when projection encounters an attribution-ambiguous top-level
+* statement (`c604f0bc` §3: "the compiler must not guess"). Carries the
+* file/statement/fix fields the plugin's `transform` hook formats into the
+* build-failure message — never silently kept or silently dropped.
+*/
+var ProjectionAmbiguityError = class extends Error {
+	file;
+	statement;
+	line;
+	explanation;
+	fix;
+	constructor(file, statement, line, explanation, fix) {
+		super([
+			`Projection refused to guess: an ambiguous top-level statement in the client build.`,
+			``,
+			`File: ${file}:${line}`,
+			`Statement: ${statement}`,
+			`Cause: ${explanation}`,
+			`Fix: ${fix}`
+		].join("\n"));
+		this.file = file;
+		this.statement = statement;
+		this.line = line;
+		this.explanation = explanation;
+		this.fix = fix;
+		this.name = "ProjectionAmbiguityError";
+	}
+};
+function hasSurvivingReader(local, survivingNames) {
+	for (const name of local.names) if (survivingNames.has(name)) return true;
+	return false;
+}
+function isKnownSafeAsset(source) {
+	return ASSET_EXTENSION_RE.test(source);
+}
+/**
+* Matches `export const <name> = ...` only when the declaration has exactly
+* one declarator — every server export in every fixture and v5/app page is
+* written one-const-per-export (`product-details.page.tsx:15-18,42-69,71-74`);
+* a multi-declarator `export const a = 1, b = 2` is left to the ambiguity
+* path below rather than guessing which half is server-only.
+*/
+function isServerExportDeclaration(stmt) {
+	if (stmt.type !== "ExportNamedDeclaration" || !stmt.declaration) return false;
+	const decl = stmt.declaration;
+	if (decl.type === "VariableDeclaration" && decl.declarations.length === 1) {
+		const id = decl.declarations[0].id;
+		return id?.type === "Identifier" && SERVER_EXPORT_NAMES.has(id.name);
+	}
+	if (decl.type === "FunctionDeclaration") return !!decl.id && SERVER_EXPORT_NAMES.has(decl.id.name);
+	return false;
+}
+/**
+* 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
+* 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
+* heuristic that must not guess in the removal direction.
+*/
+function collectIdentifierNames(node, names) {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const item of node) collectIdentifierNames(item, names);
+		return;
+	}
+	const record = node;
+	if (typeof record.type !== "string") return;
+	if (record.type === "Identifier" || record.type === "JSXIdentifier") names.add(record.name);
+	for (const key of Object.keys(record)) {
+		if (key === "type" || key === "start" || key === "end" || key === "loc" || key === "range") continue;
+		if (key === "leadingComments" || key === "trailingComments" || key === "innerComments" || key === "extra") continue;
+		collectIdentifierNames(record[key], names);
+	}
+}
+/**
+* Top-level statements that BIND a name, and are therefore attributable by the
+* reference graph rather than by guessing. Everything outside this set and
+* `ALWAYS_SAFE_STATEMENT_TYPES` declares nothing — a bare `console.log("boot")`
+* has no binding to trace a reader from, which is why it stays a hard refusal.
+*/
+const DECLARATION_STATEMENT_TYPES = new Set([
+	"VariableDeclaration",
+	"FunctionDeclaration",
+	"ClassDeclaration"
+]);
+function collectPatternNames(node, names) {
+	if (!node || typeof node !== "object") return;
+	switch (node.type) {
+		case "Identifier":
+			names.add(node.name);
+			return;
+		case "ObjectPattern":
+			for (const property of node.properties) collectPatternNames(property.type === "RestElement" ? property.argument : property.value, names);
+			return;
+		case "ArrayPattern":
+			for (const element of node.elements) collectPatternNames(element, names);
+			return;
+		case "AssignmentPattern":
+			collectPatternNames(node.left, names);
+			return;
+		case "RestElement":
+			collectPatternNames(node.argument, names);
+			return;
+	}
+}
+/** The names a top-level declaration introduces into module scope. */
+function declaredNames(stmt) {
+	const names = /* @__PURE__ */ new Set();
+	if (stmt.type === "VariableDeclaration") for (const declarator of stmt.declarations) collectPatternNames(declarator.id, names);
+	else if (stmt.id?.type === "Identifier") names.add(stmt.id.name);
+	return names;
+}
+/**
+* Whether EVALUATING this initializer can run anything.
+*
+* This is the whole safety argument for removing an unreferenced declaration.
+* A function definition or a literal only creates a value, so dropping it can
+* only drop a binding nothing reads. A call, a `new`, an `await`, a member
+* access (a getter) — those can do work, and "was that work for the server or
+* for the client?" is precisely the question projection must not answer by
+* guessing (`c604f0bc` §3). `const _ = installPolyfill()` with no reader at all
+* is the shape this predicate exists to refuse rather than silently delete.
+*
+* Conservative by construction: an unrecognized node type is NOT
+* definition-shaped, so a new syntax form arrives as a refusal with a message,
+* never as a silent removal.
+*/
+function isDefinitionShapedInit(node) {
+	if (!node) return true;
+	switch (node.type) {
+		case "ArrowFunctionExpression":
+		case "FunctionExpression":
+		case "StringLiteral":
+		case "NumericLiteral":
+		case "BooleanLiteral":
+		case "NullLiteral":
+		case "BigIntLiteral":
+		case "RegExpLiteral":
+		case "Identifier": return true;
+		case "TemplateLiteral": return node.expressions.every((expression) => isDefinitionShapedInit(expression));
+		case "UnaryExpression": return node.operator !== "delete" && isDefinitionShapedInit(node.argument);
+		case "ArrayExpression": return node.elements.every((element) => element === null || element.type !== "SpreadElement" && isDefinitionShapedInit(element));
+		case "ObjectExpression": return node.properties.every((property) => property.type === "ObjectProperty" && !property.computed && isDefinitionShapedInit(property.value));
+		case "TSAsExpression":
+		case "TSSatisfiesExpression":
+		case "TSNonNullExpression":
+		case "TSTypeAssertion":
+		case "TSInstantiationExpression":
+		case "ParenthesizedExpression": return isDefinitionShapedInit(node.expression);
+		default: return false;
+	}
+}
+/**
+* Statement-level form of the above. A `class` is excluded on purpose: static
+* blocks, decorators and computed member keys all run at class-definition time,
+* so a class is only ever kept or refused, never silently removed.
+*/
+function isDefinitionShapedStatement(stmt) {
+	if (stmt.type === "FunctionDeclaration") return true;
+	if (stmt.type !== "VariableDeclaration") return false;
+	return stmt.declarations.every((declarator) => isDefinitionShapedInit(declarator.init));
+}
+function removeStatement(s, code, node) {
+	let end = node.end;
+	if (code[end] === "\r" && code[end + 1] === "\n") end += 2;
+	else if (code[end] === "\n") end += 1;
+	s.remove(node.start, end);
+}
+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
+* 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).
+*/
+function projectModule(code, filePath) {
+	const ast = parse(code, {
+		sourceType: "module",
+		plugins: ["typescript", "jsx"]
+	});
+	const s = new MagicString(code);
+	const body = ast.program.body;
+	const removedServerExports = [];
+	const importDeclarations = [];
+	const localDeclarations = [];
+	for (const stmt of body) {
+		if (stmt.type === "ImportDeclaration") {
+			importDeclarations.push(stmt);
+			continue;
+		}
+		if (isServerExportDeclaration(stmt)) {
+			removedServerExports.push(stmt);
+			continue;
+		}
+		if (ALWAYS_SAFE_STATEMENT_TYPES.has(stmt.type)) continue;
+		if (DECLARATION_STATEMENT_TYPES.has(stmt.type)) {
+			localDeclarations.push({
+				stmt,
+				names: declaredNames(stmt),
+				definitionShaped: isDefinitionShapedStatement(stmt),
+				removed: false
+			});
+			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)`);
+	}
+	const removedLocals = /* @__PURE__ */ new Set();
+	/**
+	* Every name READ by something that survives projection. Imports are excluded
+	* so an import specifier never counts as a use of itself, and a local
+	* declaration does not count as a use of ITSELF either — otherwise a
+	* self-recursive server-only helper would pin its own binding alive forever.
+	*
+	* Over-collecting (an object property key, a shadowing parameter) only ever
+	* biases toward KEEPING, never toward dropping something still needed — the
+	* safe direction for a heuristic that must not guess in the removal
+	* direction.
+	*/
+	function collectSurvivingNames() {
+		const names = /* @__PURE__ */ new Set();
+		for (const stmt of body) {
+			if (stmt.type === "ImportDeclaration") continue;
+			if (removedServerExports.includes(stmt) || removedLocals.has(stmt)) continue;
+			const own = /* @__PURE__ */ new Set();
+			collectIdentifierNames(stmt, own);
+			if (DECLARATION_STATEMENT_TYPES.has(stmt.type)) for (const name of declaredNames(stmt)) own.delete(name);
+			for (const name of own) names.add(name);
+		}
+		return names;
+	}
+	let survivingNames = collectSurvivingNames();
+	for (let changed = true; changed;) {
+		changed = false;
+		for (const local of localDeclarations) {
+			if (local.removed || !local.definitionShaped) continue;
+			if (hasSurvivingReader(local, survivingNames)) continue;
+			local.removed = true;
+			removedLocals.add(local.stmt);
+			changed = true;
+		}
+		if (changed) survivingNames = collectSurvivingNames();
+	}
+	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`);
+	}
+	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.some((spec) => survivingNames.has(spec.local.name))) removeStatement(s, code, decl);
+	}
+	for (const stmt of removedServerExports) removeStatement(s, code, stmt);
+	for (const stmt of removedLocals) removeStatement(s, code, stmt);
+	return {
+		code: s.toString(),
+		map: s.generateMap({
+			hires: true,
+			source: filePath
+		})
+	};
+}
+function isProjectableFile(id) {
+	const base = path.basename(id.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;
+}
+/**
+* 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.
+*/
+function projection() {
+	return {
+		name: "warlock:projection",
+		enforce: "pre",
+		transform(code, id, options) {
+			if (options?.ssr) return null;
+			if (!isProjectableFile(id)) return null;
+			try {
+				const { code: transformed, map } = projectModule(code, id);
+				return {
+					code: transformed,
+					map
+				};
+			} catch (error) {
+				if (error instanceof ProjectionAmbiguityError) this.error(error.message);
+				throw error;
+			}
+		}
+	};
+}
+
+//#endregion
+export { ProjectionAmbiguityError, SERVER_EXPORT_NAMES, projection };
+//# sourceMappingURL=projection.mjs.map

package/esm/vite/projection.mjs.map

@@ -0,0 +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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"}