zod-compiler 1.23.7 → 1.24.0

package/dist/turbopack.js

@@ -0,0 +1,200 @@
+import { getFirstPartyModulePaths, invalidateModuleCache } from "./loader.js";
+import { RUNTIME_PACKAGE_ID } from "./unplugin/virtual.js";
+import { log, shouldTransform, transformCodeWithMap } from "./unplugin/transform.js";
+import { resetDepGraphMemo, transformDependencies } from "./unplugin/dep-graph.js";
+import remapping from "@jridgewell/remapping";
+import fs from "node:fs";
+//#region src/turbopack.ts
+/**
+* Webpack-loader entry point, for Turbopack (Next.js) and any other host that
+* runs webpack loaders but not webpack plugins.
+*
+* Turbopack deliberately supports no webpack plugins, so the unplugin build
+* plugins cannot reach it. Loaders it does run, through the real `loader-runner`
+* library, and that is enough: this module is the whole zod-compiler transform
+* behind `this.async()`.
+*
+* It emits TypeScript, not JavaScript. A `turbopack.rules` entry that sets no
+* `as`/`type` leaves the loader's output to be parsed as whatever the file
+* already was, so Turbopack's own SWC pass handles the syntax — there is no
+* second transpile here and no @swc/core dependency.
+*
+* `codegenMode: "lean"` is available here — it imports the shared helpers from
+* `zod-compiler/runtime`, a real package subpath, rather than the `virtual:` id
+* the build plugins answer from a resolve hook that a loader does not have. It
+* is opt-in; see the option's doc for why.
+*
+*   // next.config.ts
+*   export default {
+*     turbopack: {
+*       rules: {
+*         "*.{ts,tsx}": {
+*           condition: { all: [{ not: "foreign" }, { content: /[Zz]od/ }] },
+*           loaders: ["zod-compiler/turbopack"],
+*         },
+*       },
+*     },
+*   };
+*
+* The `content` condition is the Turbopack equivalent of the plugins' own code
+* filter and must stay as loose as ZOD_MENTION: narrowing it to the literal
+* specifier `"zod"` would silently skip `zod/v4`, `zod/mini` and the
+* `zod-compiler` import that drives `schemas: "explicit"` — no error, those
+* schemas just quietly stay uncompiled.
+*/
+/**
+* Disk stamps of every module the shared execution cache is currently holding.
+*
+* Discovery executes schema files from DISK through a module cache that outlives
+* loader calls. The bundler plugins evict it from `watchChange`; a loader has no
+* such hook, so staleness has to be detected here or compiled validators keep
+* reflecting whatever the files said when they were first executed.
+*
+* Diffing the entry's own content is NOT enough, and the gap is exactly the case
+* `addDependency` exists to handle: when an imported constant changes, the host
+* re-runs the loader for a schema file whose content is UNCHANGED.
+*
+* Tracked GLOBALLY rather than per file, because that is what it describes: one
+* process-wide module cache, stale the moment any file behind it changes. A
+* per-file dependency list cannot express that — a file being transformed for
+* the FIRST time has no list yet, but the cache it is about to read from is
+* already warm and may already be stale. Keying on the cache's own inventory
+* also means one edit costs one eviction rather than one per dependent file.
+*
+* `getFirstPartyModulePaths()` is that inventory, which is why it is sound here
+* while being unsound as a per-file dependency list (see transformDependencies):
+* the question is "what is cached", not "what does this file need". It covers
+* dependencies the host never feeds through this loader at all — a constants
+* file that never mentions zod, or one a rule's `exclude` skips — but only the
+* ones jiti holds, so the two known gaps are its gaps:
+*
+* - `.js`/`.mjs` deps go through native `import()` (see loader.ts), which has no
+*   evictable cache. The build plugins are equally stale there; on Bun and Deno
+*   that is every module, and this whole mechanism is inert.
+* - A file being CREATED changes nothing's stamp, so a new module that shadows
+*   an existing resolution (`limits.ts` beside `limits/index.ts`) keeps serving
+*   the old one until some stamped file also changes. `watchChange` gives the
+*   plugins a signal for this that a loader host has no equivalent of.
+*
+* mtime+size like the disk cache's fast path, minus its content hashes: those
+* exist to survive checkouts across processes, and this map dies with the
+* process.
+*/
+const executedModuleStamps = /* @__PURE__ */ new Map();
+function stampOf(file) {
+	try {
+		const stat = fs.statSync(file, { throwIfNoEntry: false });
+		return stat === void 0 ? "" : `${stat.mtimeMs}:${stat.size}`;
+	} catch {
+		return "";
+	}
+}
+/**
+* Drop cached module executions when any file behind them changed on disk.
+*
+* Eviction is global (see invalidateModuleCache), so it is deliberately paired
+* with the dep-graph memos the plugin also resets in `watchChange`: a resolution
+* memoized before a file existed would otherwise pin that importer to an
+* unanalyzable graph for the life of the process.
+*
+* Costs one stat per executed module, paid by every file that reaches the
+* transform — ~3 ms per file against the 1,900-module project dep-graph.ts
+* cites, the same order as the closure walk `transformDependencies` does a few
+* lines later, and far below the discovery it is protecting.
+*/
+function invalidateStaleExecutions() {
+	let stale = false;
+	for (const [file, stamp] of executedModuleStamps) if (stampOf(file) !== stamp) {
+		stale = true;
+		break;
+	}
+	if (!stale) return;
+	invalidateModuleCache();
+	resetDepGraphMemo();
+	executedModuleStamps.clear();
+}
+/**
+* Stamp whatever discovery just executed.
+*
+* Keeps the FIRST stamp for a file rather than refreshing: a file edited between
+* its execution and this call must keep its pre-edit stamp, or the next run
+* would see it as fresh and pin the stale execution permanently.
+*
+* `null` means no jiti instance exists — a runtime whose module cache cannot be
+* evicted at all (loader.ts), so there is nothing to track and nothing to fix.
+*/
+function recordExecutedModules() {
+	for (const file of getFirstPartyModulePaths() ?? []) if (!executedModuleStamps.has(file)) executedModuleStamps.set(file, stampOf(file));
+}
+function readOptions(context) {
+	const options = context.getOptions?.();
+	if (options !== void 0) return options;
+	return typeof context.query === "object" && context.query !== null ? context.query : {};
+}
+/**
+* Declare what a rebuild must watch. The host caches this file's output keyed on
+* its own content, but discovery executed the whole import graph — without these
+* an edit to an imported constant leaves a stale validator in the bundle.
+*/
+function declareDependencies(context, id, verbose) {
+	const { files, complete } = transformDependencies(id);
+	for (const file of files) context.addDependency?.(file);
+	if (complete) return;
+	context.cacheable?.(false);
+	if (verbose) log(`Cannot analyze the import graph of ${id} — re-running its transform every build`);
+}
+/** The transform itself, split out so the loader shell stays callback-only. */
+async function run(context, source, inputMap) {
+	const id = context.resourcePath;
+	const options = readOptions(context);
+	if (!shouldTransform(id, options)) return {
+		code: source,
+		map: inputMap
+	};
+	invalidateStaleExecutions();
+	const output = options.output ?? "schema";
+	let discoveryRan = false;
+	const result = await transformCodeWithMap(source, id, {
+		mode: options.codegenMode ?? "inline",
+		runtimeId: RUNTIME_PACKAGE_ID,
+		verbose: options.verbose,
+		zodCompat: output === "schema" || output === "compact",
+		compact: output === "compact",
+		autoDiscover: (options.schemas ?? "auto") === "auto",
+		hoist: options.hoist,
+		onDiscovery: () => {
+			discoveryRan = true;
+		},
+		onUncacheableResult: () => {
+			context.cacheable?.(false);
+		}
+	});
+	if (discoveryRan) {
+		recordExecutedModules();
+		declareDependencies(context, id, options.verbose === true);
+	}
+	if (result === null) return {
+		code: source,
+		map: inputMap
+	};
+	return {
+		code: result.code,
+		map: composeMaps(result.map, inputMap)
+	};
+}
+/** Chain this transform's map onto an earlier loader's, newest first. */
+function composeMaps(map, inputMap) {
+	if (map === null) return inputMap;
+	if (inputMap === void 0) return map;
+	return remapping([map, inputMap], () => null);
+}
+function zodCompilerLoader(source, inputMap) {
+	const callback = this.async();
+	const succeed = (result) => callback(null, result.code, result.map);
+	const fail = (error) => callback(error instanceof Error ? error : new Error(String(error)));
+	run(this, source, inputMap).then(succeed, fail);
+}
+//#endregion
+export { zodCompilerLoader as default };
+
+//# sourceMappingURL=turbopack.js.map

package/dist/turbopack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"turbopack.js","names":[],"sources":["../src/turbopack.ts"],"sourcesContent":["/**\n * Webpack-loader entry point, for Turbopack (Next.js) and any other host that\n * runs webpack loaders but not webpack plugins.\n *\n * Turbopack deliberately supports no webpack plugins, so the unplugin build\n * plugins cannot reach it. Loaders it does run, through the real `loader-runner`\n * library, and that is enough: this module is the whole zod-compiler transform\n * behind `this.async()`.\n *\n * It emits TypeScript, not JavaScript. A `turbopack.rules` entry that sets no\n * `as`/`type` leaves the loader's output to be parsed as whatever the file\n * already was, so Turbopack's own SWC pass handles the syntax — there is no\n * second transpile here and no @swc/core dependency.\n *\n * `codegenMode: \"lean\"` is available here — it imports the shared helpers from\n * `zod-compiler/runtime`, a real package subpath, rather than the `virtual:` id\n * the build plugins answer from a resolve hook that a loader does not have. It\n * is opt-in; see the option's doc for why.\n *\n *   // next.config.ts\n *   export default {\n *     turbopack: {\n *       rules: {\n *         \"*.{ts,tsx}\": {\n *           condition: { all: [{ not: \"foreign\" }, { content: /[Zz]od/ }] },\n *           loaders: [\"zod-compiler/turbopack\"],\n *         },\n *       },\n *     },\n *   };\n *\n * The `content` condition is the Turbopack equivalent of the plugins' own code\n * filter and must stay as loose as ZOD_MENTION: narrowing it to the literal\n * specifier `\"zod\"` would silently skip `zod/v4`, `zod/mini` and the\n * `zod-compiler` import that drives `schemas: \"explicit\"` — no error, those\n * schemas just quietly stay uncompiled.\n */\n\nimport fs from \"node:fs\";\nimport remapping from \"@jridgewell/remapping\";\nimport { getFirstPartyModulePaths, invalidateModuleCache } from \"./loader.js\";\nimport { resetDepGraphMemo, transformDependencies } from \"./unplugin/dep-graph.js\";\nimport {\n  log,\n  shouldTransform,\n  type TransformSourceMap,\n  transformCodeWithMap,\n} from \"./unplugin/transform.js\";\nimport type { ZodCompilerPluginOptions } from \"./unplugin/types.js\";\nimport { RUNTIME_PACKAGE_ID } from \"./unplugin/virtual.js\";\n\n/**\n * Plugin options minus the ones a loader host cannot express.\n *\n * Turbopack serializes loader options through `next.config`, so they have to be\n * plain JSON — hence no `apply` (a Vite lifecycle function) and a string-only\n * `schemaNamePattern` where the plugin also accepts a RegExp.\n *\n * No `cache` either: the disk cache's dependency bookkeeping leans on a\n * `buildEnd` flush that a loader has no equivalent for, and loader hosts keep\n * their own persistent result cache — Turbopack's is keyed on content plus the\n * dependencies declared below, which is what this would have re-implemented.\n */\nexport type ZodCompilerTurbopackOptions = Omit<\n  ZodCompilerPluginOptions,\n  \"apply\" | \"cache\" | \"codegenMode\" | \"hoist\"\n> & {\n  hoist?: boolean | { schemaNamePattern?: string | null | undefined } | undefined;\n  /**\n   * `\"inline\"` (default) emits the shared helpers into every transformed file.\n   *\n   * `\"lean\"` imports them from `zod-compiler/runtime` instead, so a bundle\n   * carries one copy however many files were transformed. That specifier is a\n   * real package subpath, which is what makes it usable from a loader at all —\n   * the `virtual:` id the build plugins emit needs a `resolveId` hook, and a\n   * loader has none.\n   *\n   * Opt-in rather than the default because it only holds when the host BUNDLES\n   * the import. Next.js does for client and App Router server code, but Pages\n   * Router server code externalizes node_modules imports unless\n   * `bundlePagesRouterDependencies` is set — and `zod-compiler` is normally a\n   * devDependency, so a production install prunes it and the route throws\n   * ERR_MODULE_NOT_FOUND on the first request. A bigger bundle is the better\n   * default than a runtime failure that no build step reports.\n   * @default \"inline\"\n   */\n  codegenMode?: \"lean\" | \"inline\" | undefined;\n};\n\n/**\n * The slice of webpack's loader context this uses. Structural rather than\n * imported from webpack: the package must not take a webpack dependency to\n * serve a host that is not webpack.\n */\nexport interface ZodCompilerLoaderContext {\n  resourcePath: string;\n  async(): (error: Error | null, code?: string, map?: TransformSourceMap) => void;\n  getOptions?(): ZodCompilerTurbopackOptions | undefined;\n  addDependency?(file: string): void;\n  cacheable?(flag: boolean): void;\n  query?: unknown;\n}\n\n/**\n * Disk stamps of every module the shared execution cache is currently holding.\n *\n * Discovery executes schema files from DISK through a module cache that outlives\n * loader calls. The bundler plugins evict it from `watchChange`; a loader has no\n * such hook, so staleness has to be detected here or compiled validators keep\n * reflecting whatever the files said when they were first executed.\n *\n * Diffing the entry's own content is NOT enough, and the gap is exactly the case\n * `addDependency` exists to handle: when an imported constant changes, the host\n * re-runs the loader for a schema file whose content is UNCHANGED.\n *\n * Tracked GLOBALLY rather than per file, because that is what it describes: one\n * process-wide module cache, stale the moment any file behind it changes. A\n * per-file dependency list cannot express that — a file being transformed for\n * the FIRST time has no list yet, but the cache it is about to read from is\n * already warm and may already be stale. Keying on the cache's own inventory\n * also means one edit costs one eviction rather than one per dependent file.\n *\n * `getFirstPartyModulePaths()` is that inventory, which is why it is sound here\n * while being unsound as a per-file dependency list (see transformDependencies):\n * the question is \"what is cached\", not \"what does this file need\". It covers\n * dependencies the host never feeds through this loader at all — a constants\n * file that never mentions zod, or one a rule's `exclude` skips — but only the\n * ones jiti holds, so the two known gaps are its gaps:\n *\n * - `.js`/`.mjs` deps go through native `import()` (see loader.ts), which has no\n *   evictable cache. The build plugins are equally stale there; on Bun and Deno\n *   that is every module, and this whole mechanism is inert.\n * - A file being CREATED changes nothing's stamp, so a new module that shadows\n *   an existing resolution (`limits.ts` beside `limits/index.ts`) keeps serving\n *   the old one until some stamped file also changes. `watchChange` gives the\n *   plugins a signal for this that a loader host has no equivalent of.\n *\n * mtime+size like the disk cache's fast path, minus its content hashes: those\n * exist to survive checkouts across processes, and this map dies with the\n * process.\n */\nconst executedModuleStamps = new Map<string, string>();\n\nfunction stampOf(file: string): string {\n  try {\n    const stat = fs.statSync(file, { throwIfNoEntry: false });\n    return stat === undefined ? \"\" : `${stat.mtimeMs}:${stat.size}`;\n  } catch {\n    // Non-ENOENT (EACCES, ELOOP, ENOTDIR): unreadable is indistinguishable from\n    // changed, and must never fail the build.\n    return \"\";\n  }\n}\n\n/**\n * Drop cached module executions when any file behind them changed on disk.\n *\n * Eviction is global (see invalidateModuleCache), so it is deliberately paired\n * with the dep-graph memos the plugin also resets in `watchChange`: a resolution\n * memoized before a file existed would otherwise pin that importer to an\n * unanalyzable graph for the life of the process.\n *\n * Costs one stat per executed module, paid by every file that reaches the\n * transform — ~3 ms per file against the 1,900-module project dep-graph.ts\n * cites, the same order as the closure walk `transformDependencies` does a few\n * lines later, and far below the discovery it is protecting.\n */\nfunction invalidateStaleExecutions(): void {\n  let stale = false;\n  for (const [file, stamp] of executedModuleStamps) {\n    if (stampOf(file) !== stamp) {\n      stale = true;\n      break;\n    }\n  }\n  if (!stale) return;\n  invalidateModuleCache();\n  resetDepGraphMemo();\n  executedModuleStamps.clear();\n}\n\n/**\n * Stamp whatever discovery just executed.\n *\n * Keeps the FIRST stamp for a file rather than refreshing: a file edited between\n * its execution and this call must keep its pre-edit stamp, or the next run\n * would see it as fresh and pin the stale execution permanently.\n *\n * `null` means no jiti instance exists — a runtime whose module cache cannot be\n * evicted at all (loader.ts), so there is nothing to track and nothing to fix.\n */\nfunction recordExecutedModules(): void {\n  for (const file of getFirstPartyModulePaths() ?? []) {\n    if (!executedModuleStamps.has(file)) executedModuleStamps.set(file, stampOf(file));\n  }\n}\n\nfunction readOptions(context: ZodCompilerLoaderContext): ZodCompilerTurbopackOptions {\n  const options = context.getOptions?.();\n  if (options !== undefined) return options;\n  // `getOptions` is standard but not universal; `query` is the older shape.\n  return typeof context.query === \"object\" && context.query !== null\n    ? (context.query as ZodCompilerTurbopackOptions)\n    : {};\n}\n\n/**\n * Declare what a rebuild must watch. The host caches this file's output keyed on\n * its own content, but discovery executed the whole import graph — without these\n * an edit to an imported constant leaves a stale validator in the bundle.\n */\nfunction declareDependencies(\n  context: ZodCompilerLoaderContext,\n  id: string,\n  verbose: boolean,\n): void {\n  const { files, complete } = transformDependencies(id);\n  for (const file of files) context.addDependency?.(file);\n  if (complete) return;\n  // The graph could not be analyzed (a non-literal dynamic import anywhere in\n  // the closure), so the list above is just this file — not enough for the host\n  // to know when to re-run us. Asking to be re-run every build is the only\n  // answer left. Freshness itself does not depend on this: whether the loader\n  // is re-invoked once or every time, invalidateStaleExecutions decides what\n  // discovery may reuse.\n  context.cacheable?.(false);\n  if (verbose) {\n    log(`Cannot analyze the import graph of ${id} — re-running its transform every build`);\n  }\n}\n\ninterface LoaderResult {\n  code: string;\n  map?: TransformSourceMap | undefined;\n}\n\n/** The transform itself, split out so the loader shell stays callback-only. */\nasync function run(\n  context: ZodCompilerLoaderContext,\n  source: string,\n  inputMap: TransformSourceMap | undefined,\n): Promise<LoaderResult> {\n  const id = context.resourcePath;\n  const options = readOptions(context);\n\n  if (!shouldTransform(id, options)) return { code: source, map: inputMap };\n\n  // Before discovery can read a stale execution. Note this covers an edit to\n  // THIS file too: discovery executed it, so it carries a stamp of its own —\n  // there is no separate host-content diff, which would only ever fire for\n  // content that differs from the disk discovery actually reads.\n  invalidateStaleExecutions();\n\n  const output = options.output ?? \"schema\";\n  let discoveryRan = false;\n  const result = await transformCodeWithMap(source, id, {\n    mode: options.codegenMode ?? \"inline\",\n    runtimeId: RUNTIME_PACKAGE_ID,\n    verbose: options.verbose,\n    // \"compact\" keeps the Zod schema (its safeParse IS the cold error path), so\n    // only \"bag\" drops Zod compatibility.\n    zodCompat: output === \"schema\" || output === \"compact\",\n    compact: output === \"compact\",\n    autoDiscover: (options.schemas ?? \"auto\") === \"auto\",\n    hoist: options.hoist,\n    onDiscovery: () => {\n      discoveryRan = true;\n    },\n    onUncacheableResult: () => {\n      // Discovery recovered from a process.exit (an env guard in a secret-less\n      // build): the result is a function of the ENVIRONMENT, not the file, so it\n      // must not be cached against this content.\n      context.cacheable?.(false);\n    },\n  });\n\n  // Only discovery reads other files. A hoist-only or bailed-out transform is a\n  // pure function of this file's content, which the host already keys on.\n  if (discoveryRan) {\n    recordExecutedModules();\n    declareDependencies(context, id, options.verbose === true);\n  }\n\n  if (result === null) return { code: source, map: inputMap };\n  return { code: result.code, map: composeMaps(result.map, inputMap) };\n}\n\n/** Chain this transform's map onto an earlier loader's, newest first. */\nfunction composeMaps(\n  map: TransformSourceMap | null,\n  inputMap: TransformSourceMap | undefined,\n): TransformSourceMap | undefined {\n  if (map === null) return inputMap;\n  if (inputMap === undefined) return map;\n  return remapping(\n    [map, inputMap] as Parameters<typeof remapping>[0],\n    () => null,\n  ) as unknown as TransformSourceMap;\n}\n\nexport default function zodCompilerLoader(\n  this: ZodCompilerLoaderContext,\n  source: string,\n  inputMap?: TransformSourceMap,\n): void {\n  const callback = this.async();\n  const succeed = (result: LoaderResult): void => callback(null, result.code, result.map);\n  const fail = (error: unknown): void =>\n    callback(error instanceof Error ? error : new Error(String(error)));\n\n  // Two `then` handlers rather than one plus a try/catch: loader-runner invokes\n  // the host's continuation synchronously from `callback`, so a throw inside it\n  // would re-enter a catch and call back a second time. As rejection handlers of\n  // the SAME promise, exactly one of these can ever run.\n  run(this, source, inputMap).then(succeed, fail);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6IA,MAAM,uCAAuB,IAAI,IAAoB;AAErD,SAAS,QAAQ,MAAsB;CACrC,IAAI;EACF,MAAM,OAAO,GAAG,SAAS,MAAM,EAAE,gBAAgB,MAAM,CAAC;EACxD,OAAO,SAAS,KAAA,IAAY,KAAK,GAAG,KAAK,QAAQ,GAAG,KAAK;CAC3D,QAAQ;EAGN,OAAO;CACT;AACF;;;;;;;;;;;;;;AAeA,SAAS,4BAAkC;CACzC,IAAI,QAAQ;CACZ,KAAK,MAAM,CAAC,MAAM,UAAU,sBAC1B,IAAI,QAAQ,IAAI,MAAM,OAAO;EAC3B,QAAQ;EACR;CACF;CAEF,IAAI,CAAC,OAAO;CACZ,sBAAsB;CACtB,kBAAkB;CAClB,qBAAqB,MAAM;AAC7B;;;;;;;;;;;AAYA,SAAS,wBAA8B;CACrC,KAAK,MAAM,QAAQ,yBAAyB,KAAK,CAAC,GAChD,IAAI,CAAC,qBAAqB,IAAI,IAAI,GAAG,qBAAqB,IAAI,MAAM,QAAQ,IAAI,CAAC;AAErF;AAEA,SAAS,YAAY,SAAgE;CACnF,MAAM,UAAU,QAAQ,aAAa;CACrC,IAAI,YAAY,KAAA,GAAW,OAAO;CAElC,OAAO,OAAO,QAAQ,UAAU,YAAY,QAAQ,UAAU,OACzD,QAAQ,QACT,CAAC;AACP;;;;;;AAOA,SAAS,oBACP,SACA,IACA,SACM;CACN,MAAM,EAAE,OAAO,aAAa,sBAAsB,EAAE;CACpD,KAAK,MAAM,QAAQ,OAAO,QAAQ,gBAAgB,IAAI;CACtD,IAAI,UAAU;CAOd,QAAQ,YAAY,KAAK;CACzB,IAAI,SACF,IAAI,sCAAsC,GAAG,wCAAwC;AAEzF;;AAQA,eAAe,IACb,SACA,QACA,UACuB;CACvB,MAAM,KAAK,QAAQ;CACnB,MAAM,UAAU,YAAY,OAAO;CAEnC,IAAI,CAAC,gBAAgB,IAAI,OAAO,GAAG,OAAO;EAAE,MAAM;EAAQ,KAAK;CAAS;CAMxE,0BAA0B;CAE1B,MAAM,SAAS,QAAQ,UAAU;CACjC,IAAI,eAAe;CACnB,MAAM,SAAS,MAAM,qBAAqB,QAAQ,IAAI;EACpD,MAAM,QAAQ,eAAe;EAC7B,WAAW;EACX,SAAS,QAAQ;EAGjB,WAAW,WAAW,YAAY,WAAW;EAC7C,SAAS,WAAW;EACpB,eAAe,QAAQ,WAAW,YAAY;EAC9C,OAAO,QAAQ;EACf,mBAAmB;GACjB,eAAe;EACjB;EACA,2BAA2B;GAIzB,QAAQ,YAAY,KAAK;EAC3B;CACF,CAAC;CAID,IAAI,cAAc;EAChB,sBAAsB;EACtB,oBAAoB,SAAS,IAAI,QAAQ,YAAY,IAAI;CAC3D;CAEA,IAAI,WAAW,MAAM,OAAO;EAAE,MAAM;EAAQ,KAAK;CAAS;CAC1D,OAAO;EAAE,MAAM,OAAO;EAAM,KAAK,YAAY,OAAO,KAAK,QAAQ;CAAE;AACrE;;AAGA,SAAS,YACP,KACA,UACgC;CAChC,IAAI,QAAQ,MAAM,OAAO;CACzB,IAAI,aAAa,KAAA,GAAW,OAAO;CACnC,OAAO,UACL,CAAC,KAAK,QAAQ,SACR,IACR;AACF;AAEA,SAAwB,kBAEtB,QACA,UACM;CACN,MAAM,WAAW,KAAK,MAAM;CAC5B,MAAM,WAAW,WAA+B,SAAS,MAAM,OAAO,MAAM,OAAO,GAAG;CACtF,MAAM,QAAQ,UACZ,SAAS,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC,CAAC;CAMpE,IAAI,MAAM,QAAQ,QAAQ,CAAC,CAAC,KAAK,SAAS,IAAI;AAChD"}

package/dist/unplugin/dep-graph.d.ts

@@ -1,6 +1,7 @@
 //#region src/unplugin/dep-graph.d.ts
 /**
- * Static per-file dependency graphs for disk-cache invalidation.
+ * Static per-file dependency graphs, for disk-cache invalidation and for the
+ * watch dependencies a loader host has to declare (see transformDependencies).
  *
  * The disk cache used to record `getFirstPartyModulePaths()` — the superset
  * of EVERY first-party module the loader had executed so far — as each
@@ -50,6 +51,48 @@ declare function resetDepGraphMemo(): void;
  * The entry itself is excluded (its content is part of the cache key).
  */
 declare function collectStaticDeps(entryFile: string): StaticDeps;
+interface TransformDependencies {
+  /**
+   * Files to declare as watch dependencies, entry first and deduped. Complete
+   * only when `complete` is true — otherwise it is just the entry.
+   */
+  files: string[];
+  /**
+   * False when the import graph could not be fully analyzed. `files` is then
+   * NOT sufficient, and the host has to reach for a coarser signal (a context
+   * dependency over the project, or refusing to cache the result) instead of
+   * trusting it.
+   */
+  complete: boolean;
+}
+/**
+ * Files whose contents can change what `id`'s transform produces — the set a
+ * host must declare as watch dependencies.
+ *
+ * Discovery EXECUTES the file's import graph, so a compiled validator reflects
+ * every constant, enum and helper that graph contributed. A host that keys its
+ * cache on `id`'s own content alone therefore serves a stale validator after an
+ * edit to any of them.
+ *
+ * Bundler plugins do not need this: their `watchChange` hook fires for every
+ * file in the project, so the plugin invalidates wholesale. Loader hosts
+ * (Turbopack, plain webpack loaders) have no such hook — their only lever is
+ * declaring dependencies per file, which is what this returns.
+ *
+ * The entry is always included, for the reason the disk cache records it too: a
+ * host keys on the content it PASSED, but discovery executed the file from disk.
+ *
+ * Deliberately NOT backed by `getFirstPartyModulePaths()` when the crawl comes
+ * up incomplete, unlike the disk cache's fallback. That superset is
+ * point-in-time, not cumulative — `invalidateModuleCache()` empties it — so
+ * after an unrelated file's discovery repopulates it, it describes THAT file's
+ * graph and can silently omit this one's. The disk cache survives that because
+ * `watchChange` invalidates wholesale and deferred entries flush against one
+ * end-of-build snapshot; a loader host has neither backstop, so a plausible but
+ * wrong list would go undetected. Reporting `complete: false` lets the caller
+ * do the sound thing instead.
+ */
+declare function transformDependencies(id: string): TransformDependencies;
 //#endregion
-export { StaticDeps, collectStaticDeps, resetDepGraphMemo };
+export { StaticDeps, TransformDependencies, collectStaticDeps, resetDepGraphMemo, transformDependencies };
 //# sourceMappingURL=dep-graph.d.ts.map

package/dist/unplugin/dep-graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dep-graph.d.ts","names":[],"sources":["../../src/unplugin/dep-graph.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA4CiB;;EAEf;;EAEA;;;iBA0Cc;;;;;iBAsMA,kBAAkB,oBAAoB"}
+{"version":3,"file":"dep-graph.d.ts","names":[],"sources":["../../src/unplugin/dep-graph.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA6CiB;;EAEf;;EAEA;;;iBA0Cc;;;;;iBAsMA,kBAAkB,oBAAoB;UA0BrC;;;;;EAKf;;;;;;;EAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8Bc,sBAAsB,aAAa"}

package/dist/unplugin/dep-graph.js

@@ -4,7 +4,8 @@ import * as path$1 from "node:path";
 import * as fs$1 from "node:fs";
 //#region src/unplugin/dep-graph.ts
 /**
-* Static per-file dependency graphs for disk-cache invalidation.
+* Static per-file dependency graphs, for disk-cache invalidation and for the
+* watch dependencies a loader host has to declare (see transformDependencies).
 *
 * The disk cache used to record `getFirstPartyModulePaths()` — the superset
 * of EVERY first-party module the loader had executed so far — as each
@@ -247,7 +248,46 @@ function collectStaticDeps(entryFile) {
 		complete: true
 	};
 }
+/**
+* Files whose contents can change what `id`'s transform produces — the set a
+* host must declare as watch dependencies.
+*
+* Discovery EXECUTES the file's import graph, so a compiled validator reflects
+* every constant, enum and helper that graph contributed. A host that keys its
+* cache on `id`'s own content alone therefore serves a stale validator after an
+* edit to any of them.
+*
+* Bundler plugins do not need this: their `watchChange` hook fires for every
+* file in the project, so the plugin invalidates wholesale. Loader hosts
+* (Turbopack, plain webpack loaders) have no such hook — their only lever is
+* declaring dependencies per file, which is what this returns.
+*
+* The entry is always included, for the reason the disk cache records it too: a
+* host keys on the content it PASSED, but discovery executed the file from disk.
+*
+* Deliberately NOT backed by `getFirstPartyModulePaths()` when the crawl comes
+* up incomplete, unlike the disk cache's fallback. That superset is
+* point-in-time, not cumulative — `invalidateModuleCache()` empties it — so
+* after an unrelated file's discovery repopulates it, it describes THAT file's
+* graph and can silently omit this one's. The disk cache survives that because
+* `watchChange` invalidates wholesale and deferred entries flush against one
+* end-of-build snapshot; a loader host has neither backstop, so a plausible but
+* wrong list would go undetected. Reporting `complete: false` lets the caller
+* do the sound thing instead.
+*/
+function transformDependencies(id) {
+	const entry = realpathOf(path$1.resolve(id));
+	const staticDeps = collectStaticDeps(entry);
+	if (!staticDeps.complete) return {
+		files: [entry],
+		complete: false
+	};
+	return {
+		files: [entry, ...staticDeps.deps.filter((d) => d !== entry)],
+		complete: true
+	};
+}
 //#endregion
-export { collectStaticDeps, resetDepGraphMemo };
+export { collectStaticDeps, resetDepGraphMemo, transformDependencies };
 
 //# sourceMappingURL=dep-graph.js.map

package/dist/unplugin/dep-graph.js.map

@@ -1 +1 @@
-{"version":3,"file":"dep-graph.js","names":["path","fs"],"sources":["../../src/unplugin/dep-graph.ts"],"sourcesContent":["/**\n * Static per-file dependency graphs for disk-cache invalidation.\n *\n * The disk cache used to record `getFirstPartyModulePaths()` — the superset\n * of EVERY first-party module the loader had executed so far — as each\n * entry's dependency set. Supersets never serve stale results, but in a\n * large codebase every entry ends up recording the whole project (~1,900\n * deps, ~400KB JSON per entry in the field report), so ANY commit\n * invalidates essentially the entire cache and CI re-pays full discovery\n * every run.\n *\n * This module computes the file's ACTUAL import graph statically: scan\n * import/export/require specifiers, resolve them (relative paths with\n * extension probing, tsconfig path aliases via the loader's config, bare\n * specifiers through node resolution), and BFS across first-party files.\n * No file is executed. Type-only imports are included (over-approximation\n * only over-invalidates).\n *\n * Soundness rule: when anything cannot be analyzed — a non-literal dynamic\n * import, an unresolvable relative specifier — the crawl reports\n * `complete: false` and the caller falls back to the superset. A static\n * crawl may only replace the superset when it provably covers everything\n * the file can load.\n *\n * Cost discipline (this runs serialized on the bundler's main process, once\n * per discovery file, over closures that reach thousands of files):\n * - every existence probe uses `statSync(p, { throwIfNoEntry: false })` —\n *   a thrown ENOENT pays V8 error-plus-stack construction, and a cold crawl\n *   issues these probes by the million (the dominant cost in field samples);\n * - resolution is memoized at every level: realpath per path, createRequire\n *   per directory, resolved specifier per (directory, specifier), and the\n *   full edge list per file (mtime-validated) — repeat crawls over the\n *   shared core graph are Map lookups plus one cheap stat per file;\n * - the BFS aborts the moment the graph becomes unanalyzable: the caller\n *   discards an incomplete result for the superset anyway, so finishing the\n *   crawl would be pure waste (and incomplete is the COMMON outcome on\n *   large graphs — one dynamic import anywhere poisons the whole closure).\n */\n\nimport * as fs from \"node:fs\";\nimport { createRequire } from \"node:module\";\nimport * as path from \"node:path\";\nimport { resolveTsconfigPathCandidates } from \"../loader.js\";\n\nexport interface StaticDeps {\n  /** Absolute real paths of first-party files reachable from the entry. */\n  deps: string[];\n  /** False when the graph could not be fully analyzed — use the superset. */\n  complete: boolean;\n}\n\nconst SOURCE_EXTENSIONS = [\".ts\", \".tsx\", \".mts\", \".cts\", \".js\", \".jsx\", \".mjs\", \".cjs\"];\nconst NODE_MODULES_SEGMENT = `${path.sep}node_modules${path.sep}`;\n/** Specifier schemes that never resolve to project files. */\n// oxlint-disable-next-line no-control-regex -- rollup-convention virtual module ids begin with NUL\nconst SKIP_SPECIFIER = /^(?:node:|data:|virtual:|\\u0000)/;\n/** Runaway guard — graphs larger than this fall back to the superset. */\nconst MAX_FILES = 10_000;\n\nconst INCOMPLETE: StaticDeps = { deps: [], complete: false };\n\n/**\n * Resolution-failure sentinel. A unique symbol rather than a string literal:\n * `\"incomplete\" | string` collapses to `string`, so the type system could\n * not distinguish a resolved path from the failure marker.\n */\nconst UNRESOLVED = Symbol(\"unresolved\");\n\ninterface FileNode {\n  mtimeMs: number;\n  /** Resolved first-party imports (absolute real paths), deduped. */\n  edges: string[];\n  /** Non-literal dynamic import/require or unresolvable specifier. */\n  incomplete: boolean;\n}\n\n/**\n * Per-process memos. The file node memo is revalidated by mtime on every\n * visit; the resolution memos (specifier, realpath, require) depend on the\n * filesystem layout rather than file contents and are only dropped by\n * resetDepGraphMemo() — the same wholesale invalidation watch mode already\n * applies to the module cache (a memoized resolution can only go stale when\n * files appear/move, which fires watchChange).\n */\nconst nodeMemo = new Map<string, FileNode | null>();\nconst resolveMemo = new Map<string, string | null | typeof UNRESOLVED>();\nconst realpathMemo = new Map<string, string>();\nconst requireMemo = new Map<string, ReturnType<typeof createRequire>>();\n\n/** Reset the per-process dep-graph memos (watch-mode file changes). */\nexport function resetDepGraphMemo(): void {\n  nodeMemo.clear();\n  resolveMemo.clear();\n  realpathMemo.clear();\n  requireMemo.clear();\n}\n\nconst STATIC_SPECIFIER =\n  /(?:\\bfrom\\s*|\\bimport\\s+|\\bimport\\s*\\(\\s*|\\brequire\\s*\\(\\s*)[\"']([^\"'\\n]+)[\"']/g;\n// No /g flag: `.test()` on a global regex resumes from lastIndex of the\n// PREVIOUS file's match, silently missing dynamic imports (a missed\n// detection records a falsely-complete dep set — stale cache).\nconst DYNAMIC_CALL = /\\b(?:import|require)\\s*\\(\\s*(?![\"'])[^)\\s]/;\n\n/** statSync that reports ENOENT as undefined instead of an exception. */\nfunction tryStat(p: string): fs.Stats | undefined {\n  try {\n    return fs.statSync(p, { throwIfNoEntry: false });\n  } catch {\n    // Non-ENOENT errors (ENOTDIR from probing `file.ts/index.ts`, EACCES):\n    // treat as absent.\n    return undefined;\n  }\n}\n\nfunction tryFile(p: string): string | null {\n  return tryStat(p)?.isFile() ? p : null;\n}\n\n/** Probe a path (possibly extensionless) to an existing file. */\nfunction probeFile(base: string): string | null {\n  const hasExtension = path.extname(base) !== \"\";\n  if (hasExtension) {\n    if (tryFile(base)) return base;\n    // Extensioned path that doesn't exist as-is: TS source referenced with a\n    // .js specifier (nodenext style). Probe the extension-family swap before\n    // the append/index probes — in nodenext codebases this is the common hit\n    // and skips ~16 dead probes per import.\n    if (/\\.[cm]?js$/.test(base)) {\n      const hit =\n        tryFile(base.replace(/\\.([cm]?)js$/, \".$1ts\")) ??\n        tryFile(base.replace(/\\.[cm]?js$/, \".tsx\"));\n      if (hit) return hit;\n    }\n  }\n  for (const ext of SOURCE_EXTENSIONS) {\n    const hit = tryFile(base + ext);\n    if (hit) return hit;\n  }\n  for (const ext of SOURCE_EXTENSIONS) {\n    const hit = tryFile(path.join(base, `index${ext}`));\n    if (hit) return hit;\n  }\n  // Extensionless path that exists exactly (e.g. ./bin/cli).\n  return hasExtension ? null : tryFile(base);\n}\n\nfunction realpathOf(p: string): string {\n  let real = realpathMemo.get(p);\n  if (real === undefined) {\n    try {\n      real = fs.realpathSync(p);\n    } catch {\n      real = p; // keep the unresolved path\n    }\n    realpathMemo.set(p, real);\n  }\n  return real;\n}\n\nfunction firstPartyOrNull(resolved: string): string | null {\n  const real = realpathOf(resolved);\n  return real.includes(NODE_MODULES_SEGMENT) ? null : real;\n}\n\n/** Node resolution is a function of the importing DIRECTORY, not the file. */\nfunction requireFor(dir: string): ReturnType<typeof createRequire> {\n  let req = requireMemo.get(dir);\n  if (req === undefined) {\n    req = createRequire(path.join(dir, \"__zod_compiler_resolve__.js\"));\n    requireMemo.set(dir, req);\n  }\n  return req;\n}\n\n/**\n * Resolve one specifier from a directory. Returns:\n * - an absolute path (first-party file to record + crawl)\n * - null when the dep is intentionally out of scope (node_modules, builtins)\n * - UNRESOLVED when resolution failed and the graph cannot be trusted\n */\nfunction resolveSpecifier(rawSpec: string, fromDir: string): string | null | typeof UNRESOLVED {\n  if (SKIP_SPECIFIER.test(rawSpec)) return null;\n  const memoKey = `${fromDir}\\0${rawSpec}`;\n  const memoized = resolveMemo.get(memoKey);\n  if (memoized !== undefined) return memoized;\n  const result = resolveSpecifierUncached(rawSpec, fromDir);\n  resolveMemo.set(memoKey, result);\n  return result;\n}\n\nfunction resolveSpecifierUncached(\n  rawSpec: string,\n  fromDir: string,\n): string | null | typeof UNRESOLVED {\n  // Vite-style resource queries (./logo.svg?url, ./shader.glsl?raw) resolve\n  // to the underlying file.\n  const q = rawSpec.indexOf(\"?\");\n  const spec = q === -1 ? rawSpec : rawSpec.slice(0, q);\n  if (spec === \"\") return null;\n\n  if (spec.startsWith(\"./\") || spec.startsWith(\"../\")) {\n    const hit = probeFile(path.resolve(fromDir, spec));\n    return hit === null ? UNRESOLVED : firstPartyOrNull(hit);\n  }\n\n  const { candidates, authoritative } = resolveTsconfigPathCandidates(fromDir, spec);\n  for (const candidate of candidates) {\n    const hit = probeFile(candidate);\n    if (hit !== null) {\n      return firstPartyOrNull(hit);\n    }\n  }\n  // An authoritative miss (explicit `paths` pattern matched, or the paths\n  // config is present but uninterpretable) means the import cannot be\n  // trusted. Implicit baseUrl candidates are proposed for EVERY bare\n  // specifier (npm packages, `#` imports) and only mean \"try baseDir\n  // first\" — a miss falls through to node resolution below.\n  if (authoritative) return UNRESOLVED;\n\n  // Bare specifier (package) or package.json \"imports\" (#...): node\n  // resolution from the importing directory. node_modules results are out of\n  // scope (zod's version is part of the cache key); symlinked workspace\n  // packages realpath outside node_modules and are crawled as first-party.\n  try {\n    const resolved = requireFor(fromDir).resolve(spec);\n    if (!path.isAbsolute(resolved)) return null; // node builtin\n    return firstPartyOrNull(resolved);\n  } catch {\n    // Unresolvable from Node's algorithm. jiti may still resolve it (e.g.\n    // ESM-only packages without CJS entries) — the file itself stays a dep\n    // through the entry, but its subtree is unknown for bare packages.\n    // Treat unresolvable BARE specifiers as out-of-scope third-party\n    // (caught by the zod-version/plugin key when relevant) only when they\n    // cannot be project files; '#' subpath imports stay strict.\n    return spec.startsWith(\"#\") ? UNRESOLVED : null;\n  }\n}\n\n/**\n * Scan + resolve one file into its edge list. Memoized by mtime, so the\n * shared core graph is read and resolved once per process — each entry's\n * closure walk after that is one cheap stat plus Map lookups per file.\n * Returns null for unreadable files.\n */\nfunction fileNode(filePath: string): FileNode | null {\n  const stat = tryStat(filePath);\n  if (stat === undefined || !stat.isFile()) {\n    nodeMemo.set(filePath, null);\n    return null;\n  }\n  const memo = nodeMemo.get(filePath);\n  if (memo !== undefined && memo !== null && memo.mtimeMs === stat.mtimeMs) return memo;\n\n  let source: string;\n  try {\n    source = fs.readFileSync(filePath, \"utf8\");\n  } catch {\n    nodeMemo.set(filePath, null);\n    return null;\n  }\n  // String/comment contents can false-positive both patterns; extra\n  // specifiers only add deps (safe), a false `incomplete` only falls back\n  // to the superset (safe).\n  let incomplete = DYNAMIC_CALL.test(source);\n  const edges: string[] = [];\n  const seen = new Set<string>();\n  const dir = path.dirname(filePath);\n  for (const m of source.matchAll(STATIC_SPECIFIER)) {\n    const spec = m[1];\n    if (!spec) continue;\n    const resolved = resolveSpecifier(spec, dir);\n    if (resolved === UNRESOLVED) {\n      incomplete = true;\n    } else if (resolved !== null && !seen.has(resolved)) {\n      seen.add(resolved);\n      edges.push(resolved);\n    }\n  }\n  const node: FileNode = { mtimeMs: stat.mtimeMs, edges, incomplete };\n  nodeMemo.set(filePath, node);\n  return node;\n}\n\n/**\n * Compute the static first-party dependency closure of `entryFile`.\n * The entry itself is excluded (its content is part of the cache key).\n */\nexport function collectStaticDeps(entryFile: string): StaticDeps {\n  const entry = firstPartyOrNull(path.resolve(entryFile));\n  if (entry === null) return INCOMPLETE;\n\n  const visited = new Set<string>([entry]);\n  const queue: string[] = [entry];\n\n  while (queue.length > 0) {\n    if (visited.size > MAX_FILES) return INCOMPLETE;\n    const file = queue.pop() as string;\n    const node = fileNode(file);\n    // Any unanalyzable node poisons the whole closure; the caller falls back\n    // to the superset, so abort instead of crawling to exhaustion.\n    if (node === null || node.incomplete) return INCOMPLETE;\n    for (const dep of node.edges) {\n      if (!visited.has(dep)) {\n        visited.add(dep);\n        queue.push(dep);\n      }\n    }\n  }\n\n  visited.delete(entry);\n  return { deps: [...visited], complete: true };\n}\n"],"mappings":"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"}
+{"version":3,"file":"dep-graph.js","names":["path","fs"],"sources":["../../src/unplugin/dep-graph.ts"],"sourcesContent":["/**\n * Static per-file dependency graphs, for disk-cache invalidation and for the\n * watch dependencies a loader host has to declare (see transformDependencies).\n *\n * The disk cache used to record `getFirstPartyModulePaths()` — the superset\n * of EVERY first-party module the loader had executed so far — as each\n * entry's dependency set. Supersets never serve stale results, but in a\n * large codebase every entry ends up recording the whole project (~1,900\n * deps, ~400KB JSON per entry in the field report), so ANY commit\n * invalidates essentially the entire cache and CI re-pays full discovery\n * every run.\n *\n * This module computes the file's ACTUAL import graph statically: scan\n * import/export/require specifiers, resolve them (relative paths with\n * extension probing, tsconfig path aliases via the loader's config, bare\n * specifiers through node resolution), and BFS across first-party files.\n * No file is executed. Type-only imports are included (over-approximation\n * only over-invalidates).\n *\n * Soundness rule: when anything cannot be analyzed — a non-literal dynamic\n * import, an unresolvable relative specifier — the crawl reports\n * `complete: false` and the caller falls back to the superset. A static\n * crawl may only replace the superset when it provably covers everything\n * the file can load.\n *\n * Cost discipline (this runs serialized on the bundler's main process, once\n * per discovery file, over closures that reach thousands of files):\n * - every existence probe uses `statSync(p, { throwIfNoEntry: false })` —\n *   a thrown ENOENT pays V8 error-plus-stack construction, and a cold crawl\n *   issues these probes by the million (the dominant cost in field samples);\n * - resolution is memoized at every level: realpath per path, createRequire\n *   per directory, resolved specifier per (directory, specifier), and the\n *   full edge list per file (mtime-validated) — repeat crawls over the\n *   shared core graph are Map lookups plus one cheap stat per file;\n * - the BFS aborts the moment the graph becomes unanalyzable: the caller\n *   discards an incomplete result for the superset anyway, so finishing the\n *   crawl would be pure waste (and incomplete is the COMMON outcome on\n *   large graphs — one dynamic import anywhere poisons the whole closure).\n */\n\nimport * as fs from \"node:fs\";\nimport { createRequire } from \"node:module\";\nimport * as path from \"node:path\";\nimport { resolveTsconfigPathCandidates } from \"../loader.js\";\n\nexport interface StaticDeps {\n  /** Absolute real paths of first-party files reachable from the entry. */\n  deps: string[];\n  /** False when the graph could not be fully analyzed — use the superset. */\n  complete: boolean;\n}\n\nconst SOURCE_EXTENSIONS = [\".ts\", \".tsx\", \".mts\", \".cts\", \".js\", \".jsx\", \".mjs\", \".cjs\"];\nconst NODE_MODULES_SEGMENT = `${path.sep}node_modules${path.sep}`;\n/** Specifier schemes that never resolve to project files. */\n// oxlint-disable-next-line no-control-regex -- rollup-convention virtual module ids begin with NUL\nconst SKIP_SPECIFIER = /^(?:node:|data:|virtual:|\\u0000)/;\n/** Runaway guard — graphs larger than this fall back to the superset. */\nconst MAX_FILES = 10_000;\n\nconst INCOMPLETE: StaticDeps = { deps: [], complete: false };\n\n/**\n * Resolution-failure sentinel. A unique symbol rather than a string literal:\n * `\"incomplete\" | string` collapses to `string`, so the type system could\n * not distinguish a resolved path from the failure marker.\n */\nconst UNRESOLVED = Symbol(\"unresolved\");\n\ninterface FileNode {\n  mtimeMs: number;\n  /** Resolved first-party imports (absolute real paths), deduped. */\n  edges: string[];\n  /** Non-literal dynamic import/require or unresolvable specifier. */\n  incomplete: boolean;\n}\n\n/**\n * Per-process memos. The file node memo is revalidated by mtime on every\n * visit; the resolution memos (specifier, realpath, require) depend on the\n * filesystem layout rather than file contents and are only dropped by\n * resetDepGraphMemo() — the same wholesale invalidation watch mode already\n * applies to the module cache (a memoized resolution can only go stale when\n * files appear/move, which fires watchChange).\n */\nconst nodeMemo = new Map<string, FileNode | null>();\nconst resolveMemo = new Map<string, string | null | typeof UNRESOLVED>();\nconst realpathMemo = new Map<string, string>();\nconst requireMemo = new Map<string, ReturnType<typeof createRequire>>();\n\n/** Reset the per-process dep-graph memos (watch-mode file changes). */\nexport function resetDepGraphMemo(): void {\n  nodeMemo.clear();\n  resolveMemo.clear();\n  realpathMemo.clear();\n  requireMemo.clear();\n}\n\nconst STATIC_SPECIFIER =\n  /(?:\\bfrom\\s*|\\bimport\\s+|\\bimport\\s*\\(\\s*|\\brequire\\s*\\(\\s*)[\"']([^\"'\\n]+)[\"']/g;\n// No /g flag: `.test()` on a global regex resumes from lastIndex of the\n// PREVIOUS file's match, silently missing dynamic imports (a missed\n// detection records a falsely-complete dep set — stale cache).\nconst DYNAMIC_CALL = /\\b(?:import|require)\\s*\\(\\s*(?![\"'])[^)\\s]/;\n\n/** statSync that reports ENOENT as undefined instead of an exception. */\nfunction tryStat(p: string): fs.Stats | undefined {\n  try {\n    return fs.statSync(p, { throwIfNoEntry: false });\n  } catch {\n    // Non-ENOENT errors (ENOTDIR from probing `file.ts/index.ts`, EACCES):\n    // treat as absent.\n    return undefined;\n  }\n}\n\nfunction tryFile(p: string): string | null {\n  return tryStat(p)?.isFile() ? p : null;\n}\n\n/** Probe a path (possibly extensionless) to an existing file. */\nfunction probeFile(base: string): string | null {\n  const hasExtension = path.extname(base) !== \"\";\n  if (hasExtension) {\n    if (tryFile(base)) return base;\n    // Extensioned path that doesn't exist as-is: TS source referenced with a\n    // .js specifier (nodenext style). Probe the extension-family swap before\n    // the append/index probes — in nodenext codebases this is the common hit\n    // and skips ~16 dead probes per import.\n    if (/\\.[cm]?js$/.test(base)) {\n      const hit =\n        tryFile(base.replace(/\\.([cm]?)js$/, \".$1ts\")) ??\n        tryFile(base.replace(/\\.[cm]?js$/, \".tsx\"));\n      if (hit) return hit;\n    }\n  }\n  for (const ext of SOURCE_EXTENSIONS) {\n    const hit = tryFile(base + ext);\n    if (hit) return hit;\n  }\n  for (const ext of SOURCE_EXTENSIONS) {\n    const hit = tryFile(path.join(base, `index${ext}`));\n    if (hit) return hit;\n  }\n  // Extensionless path that exists exactly (e.g. ./bin/cli).\n  return hasExtension ? null : tryFile(base);\n}\n\nfunction realpathOf(p: string): string {\n  let real = realpathMemo.get(p);\n  if (real === undefined) {\n    try {\n      real = fs.realpathSync(p);\n    } catch {\n      real = p; // keep the unresolved path\n    }\n    realpathMemo.set(p, real);\n  }\n  return real;\n}\n\nfunction firstPartyOrNull(resolved: string): string | null {\n  const real = realpathOf(resolved);\n  return real.includes(NODE_MODULES_SEGMENT) ? null : real;\n}\n\n/** Node resolution is a function of the importing DIRECTORY, not the file. */\nfunction requireFor(dir: string): ReturnType<typeof createRequire> {\n  let req = requireMemo.get(dir);\n  if (req === undefined) {\n    req = createRequire(path.join(dir, \"__zod_compiler_resolve__.js\"));\n    requireMemo.set(dir, req);\n  }\n  return req;\n}\n\n/**\n * Resolve one specifier from a directory. Returns:\n * - an absolute path (first-party file to record + crawl)\n * - null when the dep is intentionally out of scope (node_modules, builtins)\n * - UNRESOLVED when resolution failed and the graph cannot be trusted\n */\nfunction resolveSpecifier(rawSpec: string, fromDir: string): string | null | typeof UNRESOLVED {\n  if (SKIP_SPECIFIER.test(rawSpec)) return null;\n  const memoKey = `${fromDir}\\0${rawSpec}`;\n  const memoized = resolveMemo.get(memoKey);\n  if (memoized !== undefined) return memoized;\n  const result = resolveSpecifierUncached(rawSpec, fromDir);\n  resolveMemo.set(memoKey, result);\n  return result;\n}\n\nfunction resolveSpecifierUncached(\n  rawSpec: string,\n  fromDir: string,\n): string | null | typeof UNRESOLVED {\n  // Vite-style resource queries (./logo.svg?url, ./shader.glsl?raw) resolve\n  // to the underlying file.\n  const q = rawSpec.indexOf(\"?\");\n  const spec = q === -1 ? rawSpec : rawSpec.slice(0, q);\n  if (spec === \"\") return null;\n\n  if (spec.startsWith(\"./\") || spec.startsWith(\"../\")) {\n    const hit = probeFile(path.resolve(fromDir, spec));\n    return hit === null ? UNRESOLVED : firstPartyOrNull(hit);\n  }\n\n  const { candidates, authoritative } = resolveTsconfigPathCandidates(fromDir, spec);\n  for (const candidate of candidates) {\n    const hit = probeFile(candidate);\n    if (hit !== null) {\n      return firstPartyOrNull(hit);\n    }\n  }\n  // An authoritative miss (explicit `paths` pattern matched, or the paths\n  // config is present but uninterpretable) means the import cannot be\n  // trusted. Implicit baseUrl candidates are proposed for EVERY bare\n  // specifier (npm packages, `#` imports) and only mean \"try baseDir\n  // first\" — a miss falls through to node resolution below.\n  if (authoritative) return UNRESOLVED;\n\n  // Bare specifier (package) or package.json \"imports\" (#...): node\n  // resolution from the importing directory. node_modules results are out of\n  // scope (zod's version is part of the cache key); symlinked workspace\n  // packages realpath outside node_modules and are crawled as first-party.\n  try {\n    const resolved = requireFor(fromDir).resolve(spec);\n    if (!path.isAbsolute(resolved)) return null; // node builtin\n    return firstPartyOrNull(resolved);\n  } catch {\n    // Unresolvable from Node's algorithm. jiti may still resolve it (e.g.\n    // ESM-only packages without CJS entries) — the file itself stays a dep\n    // through the entry, but its subtree is unknown for bare packages.\n    // Treat unresolvable BARE specifiers as out-of-scope third-party\n    // (caught by the zod-version/plugin key when relevant) only when they\n    // cannot be project files; '#' subpath imports stay strict.\n    return spec.startsWith(\"#\") ? UNRESOLVED : null;\n  }\n}\n\n/**\n * Scan + resolve one file into its edge list. Memoized by mtime, so the\n * shared core graph is read and resolved once per process — each entry's\n * closure walk after that is one cheap stat plus Map lookups per file.\n * Returns null for unreadable files.\n */\nfunction fileNode(filePath: string): FileNode | null {\n  const stat = tryStat(filePath);\n  if (stat === undefined || !stat.isFile()) {\n    nodeMemo.set(filePath, null);\n    return null;\n  }\n  const memo = nodeMemo.get(filePath);\n  if (memo !== undefined && memo !== null && memo.mtimeMs === stat.mtimeMs) return memo;\n\n  let source: string;\n  try {\n    source = fs.readFileSync(filePath, \"utf8\");\n  } catch {\n    nodeMemo.set(filePath, null);\n    return null;\n  }\n  // String/comment contents can false-positive both patterns; extra\n  // specifiers only add deps (safe), a false `incomplete` only falls back\n  // to the superset (safe).\n  let incomplete = DYNAMIC_CALL.test(source);\n  const edges: string[] = [];\n  const seen = new Set<string>();\n  const dir = path.dirname(filePath);\n  for (const m of source.matchAll(STATIC_SPECIFIER)) {\n    const spec = m[1];\n    if (!spec) continue;\n    const resolved = resolveSpecifier(spec, dir);\n    if (resolved === UNRESOLVED) {\n      incomplete = true;\n    } else if (resolved !== null && !seen.has(resolved)) {\n      seen.add(resolved);\n      edges.push(resolved);\n    }\n  }\n  const node: FileNode = { mtimeMs: stat.mtimeMs, edges, incomplete };\n  nodeMemo.set(filePath, node);\n  return node;\n}\n\n/**\n * Compute the static first-party dependency closure of `entryFile`.\n * The entry itself is excluded (its content is part of the cache key).\n */\nexport function collectStaticDeps(entryFile: string): StaticDeps {\n  const entry = firstPartyOrNull(path.resolve(entryFile));\n  if (entry === null) return INCOMPLETE;\n\n  const visited = new Set<string>([entry]);\n  const queue: string[] = [entry];\n\n  while (queue.length > 0) {\n    if (visited.size > MAX_FILES) return INCOMPLETE;\n    const file = queue.pop() as string;\n    const node = fileNode(file);\n    // Any unanalyzable node poisons the whole closure; the caller falls back\n    // to the superset, so abort instead of crawling to exhaustion.\n    if (node === null || node.incomplete) return INCOMPLETE;\n    for (const dep of node.edges) {\n      if (!visited.has(dep)) {\n        visited.add(dep);\n        queue.push(dep);\n      }\n    }\n  }\n\n  visited.delete(entry);\n  return { deps: [...visited], complete: true };\n}\n\nexport interface TransformDependencies {\n  /**\n   * Files to declare as watch dependencies, entry first and deduped. Complete\n   * only when `complete` is true — otherwise it is just the entry.\n   */\n  files: string[];\n  /**\n   * False when the import graph could not be fully analyzed. `files` is then\n   * NOT sufficient, and the host has to reach for a coarser signal (a context\n   * dependency over the project, or refusing to cache the result) instead of\n   * trusting it.\n   */\n  complete: boolean;\n}\n\n/**\n * Files whose contents can change what `id`'s transform produces — the set a\n * host must declare as watch dependencies.\n *\n * Discovery EXECUTES the file's import graph, so a compiled validator reflects\n * every constant, enum and helper that graph contributed. A host that keys its\n * cache on `id`'s own content alone therefore serves a stale validator after an\n * edit to any of them.\n *\n * Bundler plugins do not need this: their `watchChange` hook fires for every\n * file in the project, so the plugin invalidates wholesale. Loader hosts\n * (Turbopack, plain webpack loaders) have no such hook — their only lever is\n * declaring dependencies per file, which is what this returns.\n *\n * The entry is always included, for the reason the disk cache records it too: a\n * host keys on the content it PASSED, but discovery executed the file from disk.\n *\n * Deliberately NOT backed by `getFirstPartyModulePaths()` when the crawl comes\n * up incomplete, unlike the disk cache's fallback. That superset is\n * point-in-time, not cumulative — `invalidateModuleCache()` empties it — so\n * after an unrelated file's discovery repopulates it, it describes THAT file's\n * graph and can silently omit this one's. The disk cache survives that because\n * `watchChange` invalidates wholesale and deferred entries flush against one\n * end-of-build snapshot; a loader host has neither backstop, so a plausible but\n * wrong list would go undetected. Reporting `complete: false` lets the caller\n * do the sound thing instead.\n */\nexport function transformDependencies(id: string): TransformDependencies {\n  // realpath, matching how the crawl records every dep — otherwise a symlinked\n  // or differently-cased spelling of the entry appears twice in one list.\n  const entry = realpathOf(path.resolve(id));\n  const staticDeps = collectStaticDeps(entry);\n  if (!staticDeps.complete) return { files: [entry], complete: false };\n  return { files: [entry, ...staticDeps.deps.filter((d) => d !== entry)], complete: true };\n}\n"],"mappings":"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"}

package/dist/unplugin/edits.d.ts

@@ -22,6 +22,18 @@ interface Insertion {
   offset: number;
   text: string;
 }
+/**
+ * Offset after the shebang and the directive prologue ("use strict",
+ * "use client", "use server", ...) — where module-head insertions must go.
+ *
+ * A directive is only a directive while it is still part of the prologue, so
+ * anything prepended at offset 0 demotes it to a plain string expression.
+ * Bundlers that give directives meaning reject that outright: React Server
+ * Components builds fail with `The "use client" directive must be placed
+ * before other expressions`, which is how the generated runtime prologue used
+ * to break every Next.js file that exported a schema.
+ */
+declare function moduleHeadOffset(code: string): number;
 /**
  * Apply non-overlapping edits (any order) and an optional insertion to a
  * string. Mirrors MagicString.overwrite + appendLeft semantics: an insertion
@@ -29,5 +41,5 @@ interface Insertion {
  */
 declare function applyEdits(code: string, edits: readonly Edit[], insert?: Insertion): string;
 //#endregion
-export { Edit, Insertion, applyEdits };
+export { Edit, Insertion, applyEdits, moduleHeadOffset };
 //# sourceMappingURL=edits.d.ts.map

package/dist/unplugin/edits.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"edits.d.ts","names":[],"sources":["../../src/unplugin/edits.ts"],"mappings":";;;;;;;;;;;UAWiB;;EAEf;;EAEA;;EAEA;;UAGe;;EAEf;EACA;;;;;;;iBAQc,WAAW,cAAc,gBAAgB,QAAQ,SAAS"}
+{"version":3,"file":"edits.d.ts","names":[],"sources":["../../src/unplugin/edits.ts"],"mappings":";;;;;;;;;;;UAWiB;;EAEf;;EAEA;;EAEA;;UAGe;;EAEf;EACA;;;;;;;;;;;;;iBAcc,iBAAiB;;;;;;iBAwCjB,WAAW,cAAc,gBAAgB,QAAQ,SAAS"}

package/dist/unplugin/edits.js

@@ -1,5 +1,39 @@
 //#region src/unplugin/edits.ts
 /**
+* Offset after the shebang and the directive prologue ("use strict",
+* "use client", "use server", ...) — where module-head insertions must go.
+*
+* A directive is only a directive while it is still part of the prologue, so
+* anything prepended at offset 0 demotes it to a plain string expression.
+* Bundlers that give directives meaning reject that outright: React Server
+* Components builds fail with `The "use client" directive must be placed
+* before other expressions`, which is how the generated runtime prologue used
+* to break every Next.js file that exported a schema.
+*/
+function moduleHeadOffset(code) {
+	let i = 0;
+	if (code.startsWith("#!")) {
+		const nl = code.indexOf("\n");
+		i = nl === -1 ? code.length : nl + 1;
+	}
+	while (true) {
+		while (i < code.length) {
+			const ch = code[i];
+			if (/\s/.test(ch)) i++;
+			else if (ch === "/" && code[i + 1] === "/") {
+				const nl = code.indexOf("\n", i);
+				i = nl === -1 ? code.length : nl + 1;
+			} else if (ch === "/" && code[i + 1] === "*") {
+				const end = code.indexOf("*/", i + 2);
+				i = end === -1 ? code.length : end + 2;
+			} else break;
+		}
+		const directive = code.slice(i).match(/^(["'])use [^"'\n\\]*\1(?=[^\S\n]*([;\n"']|$))\s*;?[^\S\n]*\n?/);
+		if (!directive) return i;
+		i += directive[0].length;
+	}
+}
+/**
 * Apply non-overlapping edits (any order) and an optional insertion to a
 * string. Mirrors MagicString.overwrite + appendLeft semantics: an insertion
 * at an edit boundary lands before the edit's replacement.
@@ -22,6 +56,6 @@ function applyEdits(code, edits, insert) {
 	return result;
 }
 //#endregion
-export { applyEdits };
+export { applyEdits, moduleHeadOffset };
 
 //# sourceMappingURL=edits.js.map

package/dist/unplugin/edits.js.map

@@ -1 +1 @@
-{"version":3,"file":"edits.js","names":[],"sources":["../../src/unplugin/edits.ts"],"sourcesContent":["/**\n * Edit primitives shared by the transform pipeline stages.\n *\n * Every stage (hoist → hoisted-schema compile → rewrites → runtime inject)\n * describes its changes as non-overlapping `Edit` splices (plus at most one\n * insertion) against the STAGE INPUT. The same edit list is applied two\n * ways: `applyEdits()` produces the stage output string, and the pipeline\n * applies it to a MagicString to produce the stage's sourcemap — deriving\n * both from one list makes code/map divergence impossible.\n */\n\nexport interface Edit {\n  /** Start offset in the stage-input string. */\n  start: number;\n  /** End offset (exclusive) in the stage-input string. */\n  end: number;\n  /** Replacement text. */\n  text: string;\n}\n\nexport interface Insertion {\n  /** Offset in the stage-input string to insert at. */\n  offset: number;\n  text: string;\n}\n\n/**\n * Apply non-overlapping edits (any order) and an optional insertion to a\n * string. Mirrors MagicString.overwrite + appendLeft semantics: an insertion\n * at an edit boundary lands before the edit's replacement.\n */\nexport function applyEdits(code: string, edits: readonly Edit[], insert?: Insertion): string {\n  const ops: Array<Edit | (Insertion & { insertion: true })> = [...edits];\n  if (insert) ops.push({ ...insert, insertion: true });\n  ops.sort((a, b) => {\n    const aStart = \"insertion\" in a ? a.offset : a.start;\n    const bStart = \"insertion\" in b ? b.offset : b.start;\n    if (aStart !== bStart) return bStart - aStart;\n    // Same position: apply the insertion last so it ends up BEFORE the\n    // replacement text in the output (appendLeft semantics).\n    return \"insertion\" in a ? -1 : 1;\n  });\n  let result = code;\n  for (const op of ops) {\n    if (\"insertion\" in op) {\n      result = result.slice(0, op.offset) + op.text + result.slice(op.offset);\n    } else {\n      result = result.slice(0, op.start) + op.text + result.slice(op.end);\n    }\n  }\n  return result;\n}\n"],"mappings":";;;;;;AA+BA,SAAgB,WAAW,MAAc,OAAwB,QAA4B;CAC3F,MAAM,MAAuD,CAAC,GAAG,KAAK;CACtE,IAAI,QAAQ,IAAI,KAAK;EAAE,GAAG;EAAQ,WAAW;CAAK,CAAC;CACnD,IAAI,MAAM,GAAG,MAAM;EACjB,MAAM,SAAS,eAAe,IAAI,EAAE,SAAS,EAAE;EAC/C,MAAM,SAAS,eAAe,IAAI,EAAE,SAAS,EAAE;EAC/C,IAAI,WAAW,QAAQ,OAAO,SAAS;EAGvC,OAAO,eAAe,IAAI,KAAK;CACjC,CAAC;CACD,IAAI,SAAS;CACb,KAAK,MAAM,MAAM,KACf,IAAI,eAAe,IACjB,SAAS,OAAO,MAAM,GAAG,GAAG,MAAM,IAAI,GAAG,OAAO,OAAO,MAAM,GAAG,MAAM;MAEtE,SAAS,OAAO,MAAM,GAAG,GAAG,KAAK,IAAI,GAAG,OAAO,OAAO,MAAM,GAAG,GAAG;CAGtE,OAAO;AACT"}
+{"version":3,"file":"edits.js","names":[],"sources":["../../src/unplugin/edits.ts"],"sourcesContent":["/**\n * Edit primitives shared by the transform pipeline stages.\n *\n * Every stage (hoist → hoisted-schema compile → rewrites → runtime inject)\n * describes its changes as non-overlapping `Edit` splices (plus at most one\n * insertion) against the STAGE INPUT. The same edit list is applied two\n * ways: `applyEdits()` produces the stage output string, and the pipeline\n * applies it to a MagicString to produce the stage's sourcemap — deriving\n * both from one list makes code/map divergence impossible.\n */\n\nexport interface Edit {\n  /** Start offset in the stage-input string. */\n  start: number;\n  /** End offset (exclusive) in the stage-input string. */\n  end: number;\n  /** Replacement text. */\n  text: string;\n}\n\nexport interface Insertion {\n  /** Offset in the stage-input string to insert at. */\n  offset: number;\n  text: string;\n}\n\n/**\n * Offset after the shebang and the directive prologue (\"use strict\",\n * \"use client\", \"use server\", ...) — where module-head insertions must go.\n *\n * A directive is only a directive while it is still part of the prologue, so\n * anything prepended at offset 0 demotes it to a plain string expression.\n * Bundlers that give directives meaning reject that outright: React Server\n * Components builds fail with `The \"use client\" directive must be placed\n * before other expressions`, which is how the generated runtime prologue used\n * to break every Next.js file that exported a schema.\n */\nexport function moduleHeadOffset(code: string): number {\n  let i = 0;\n  if (code.startsWith(\"#!\")) {\n    const nl = code.indexOf(\"\\n\");\n    i = nl === -1 ? code.length : nl + 1;\n  }\n  while (true) {\n    // Skip whitespace and comments between directives\n    while (i < code.length) {\n      const ch = code[i] as string;\n      if (/\\s/.test(ch)) {\n        i++;\n      } else if (ch === \"/\" && code[i + 1] === \"/\") {\n        const nl = code.indexOf(\"\\n\", i);\n        i = nl === -1 ? code.length : nl + 1;\n      } else if (ch === \"/\" && code[i + 1] === \"*\") {\n        const end = code.indexOf(\"*/\", i + 2);\n        i = end === -1 ? code.length : end + 2;\n      } else {\n        break;\n      }\n    }\n    // The body excludes backslashes and the lookahead demands a statement\n    // boundary, so the two shapes that merely START like a directive are left\n    // alone: `\"use \\\"strict\\\"\";` (matching through the escape would land the\n    // insertion mid-literal) and `\"use \" + mode;` (an expression statement,\n    // where it would land on the `+`). Both would emit a syntax error.\n    const directive = code\n      .slice(i)\n      .match(/^([\"'])use [^\"'\\n\\\\]*\\1(?=[^\\S\\n]*([;\\n\"']|$))\\s*;?[^\\S\\n]*\\n?/);\n    if (!directive) return i;\n    i += directive[0].length;\n  }\n}\n\n/**\n * Apply non-overlapping edits (any order) and an optional insertion to a\n * string. Mirrors MagicString.overwrite + appendLeft semantics: an insertion\n * at an edit boundary lands before the edit's replacement.\n */\nexport function applyEdits(code: string, edits: readonly Edit[], insert?: Insertion): string {\n  const ops: Array<Edit | (Insertion & { insertion: true })> = [...edits];\n  if (insert) ops.push({ ...insert, insertion: true });\n  ops.sort((a, b) => {\n    const aStart = \"insertion\" in a ? a.offset : a.start;\n    const bStart = \"insertion\" in b ? b.offset : b.start;\n    if (aStart !== bStart) return bStart - aStart;\n    // Same position: apply the insertion last so it ends up BEFORE the\n    // replacement text in the output (appendLeft semantics).\n    return \"insertion\" in a ? -1 : 1;\n  });\n  let result = code;\n  for (const op of ops) {\n    if (\"insertion\" in op) {\n      result = result.slice(0, op.offset) + op.text + result.slice(op.offset);\n    } else {\n      result = result.slice(0, op.start) + op.text + result.slice(op.end);\n    }\n  }\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;AAqCA,SAAgB,iBAAiB,MAAsB;CACrD,IAAI,IAAI;CACR,IAAI,KAAK,WAAW,IAAI,GAAG;EACzB,MAAM,KAAK,KAAK,QAAQ,IAAI;EAC5B,IAAI,OAAO,KAAK,KAAK,SAAS,KAAK;CACrC;CACA,OAAO,MAAM;EAEX,OAAO,IAAI,KAAK,QAAQ;GACtB,MAAM,KAAK,KAAK;GAChB,IAAI,KAAK,KAAK,EAAE,GACd;QACK,IAAI,OAAO,OAAO,KAAK,IAAI,OAAO,KAAK;IAC5C,MAAM,KAAK,KAAK,QAAQ,MAAM,CAAC;IAC/B,IAAI,OAAO,KAAK,KAAK,SAAS,KAAK;GACrC,OAAO,IAAI,OAAO,OAAO,KAAK,IAAI,OAAO,KAAK;IAC5C,MAAM,MAAM,KAAK,QAAQ,MAAM,IAAI,CAAC;IACpC,IAAI,QAAQ,KAAK,KAAK,SAAS,MAAM;GACvC,OACE;EAEJ;EAMA,MAAM,YAAY,KACf,MAAM,CAAC,CAAC,CACR,MAAM,gEAAgE;EACzE,IAAI,CAAC,WAAW,OAAO;EACvB,KAAK,UAAU,EAAE,CAAC;CACpB;AACF;;;;;;AAOA,SAAgB,WAAW,MAAc,OAAwB,QAA4B;CAC3F,MAAM,MAAuD,CAAC,GAAG,KAAK;CACtE,IAAI,QAAQ,IAAI,KAAK;EAAE,GAAG;EAAQ,WAAW;CAAK,CAAC;CACnD,IAAI,MAAM,GAAG,MAAM;EACjB,MAAM,SAAS,eAAe,IAAI,EAAE,SAAS,EAAE;EAC/C,MAAM,SAAS,eAAe,IAAI,EAAE,SAAS,EAAE;EAC/C,IAAI,WAAW,QAAQ,OAAO,SAAS;EAGvC,OAAO,eAAe,IAAI,KAAK;CACjC,CAAC;CACD,IAAI,SAAS;CACb,KAAK,MAAM,MAAM,KACf,IAAI,eAAe,IACjB,SAAS,OAAO,MAAM,GAAG,GAAG,MAAM,IAAI,GAAG,OAAO,OAAO,MAAM,GAAG,MAAM;MAEtE,SAAS,OAAO,MAAM,GAAG,GAAG,KAAK,IAAI,GAAG,OAAO,OAAO,MAAM,GAAG,GAAG;CAGtE,OAAO;AACT"}

package/dist/unplugin/hoist.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hoist.d.ts","names":[],"sources":["../../src/unplugin/hoist.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+Da,qBAAmB;;;;;;cAOnB,aAAW;;UAGP;;EAEf;;EAEA;;UAGQ;;EAER,KAAK;;EAEL,KAAK;;EAEL,SAAS,YAAY;;;;;;;iBAQP,sBAAsB,eAAe;UAq9BpC;;;;;;;EAOf,oBAAoB;;;;;;;;EAQpB;;;;;;;iBAQc,yBACd;EACG,WAAW;EAAa,cAAc;;;UAY1B;;EAEf;;EAEA;;UAGe;;EAEf;;EAEA,SAAS;;;;;;EAMT,OAAO;EACP,QAAQ;;;;;;iBAOM,gBAAgB,cAAc,UAAU;;;;;iBAQxC,oBAAoB,cAAc,UAAU,eAAe"}
+{"version":3,"file":"hoist.d.ts","names":[],"sources":["../../src/unplugin/hoist.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+Da,qBAAmB;;;;;;cAOnB,aAAW;;UAGP;;EAEf;;EAEA;;UAGQ;;EAER,KAAK;;EAEL,KAAK;;EAEL,SAAS,YAAY;;;;;;;iBAQP,sBAAsB,eAAe;UAw7BpC;;;;;;;EAOf,oBAAoB;;;;;;;;EAQpB;;;;;;;iBAQc,yBACd;EACG,WAAW;EAAa,cAAc;;;UAY1B;;EAEf;;EAEA;;UAGe;;EAEf;;EAEA,SAAS;;;;;;EAMT,OAAO;EACP,QAAQ;;;;;;iBAOM,gBAAgB,cAAc,UAAU;;;;;iBAQxC,oBAAoB,cAAc,UAAU,eAAe"}

package/dist/unplugin/hoist.js

@@ -1,4 +1,4 @@
-import { applyEdits } from "./edits.js";
+import { applyEdits, moduleHeadOffset } from "./edits.js";
 import { Parser } from "acorn";
 //#region src/unplugin/hoist.ts
 /**
@@ -723,30 +723,6 @@ function analyzeCaptures(expr) {
 		impure
 	};
 }
-/** Offset after the shebang and directive prologue ("use client", ...). */
-function insertionOffset(code) {
-	let i = 0;
-	if (code.startsWith("#!")) {
-		const nl = code.indexOf("\n");
-		i = nl === -1 ? code.length : nl + 1;
-	}
-	while (true) {
-		while (i < code.length) {
-			const ch = code[i];
-			if (/\s/.test(ch)) i++;
-			else if (ch === "/" && code[i + 1] === "/") {
-				const nl = code.indexOf("\n", i);
-				i = nl === -1 ? code.length : nl + 1;
-			} else if (ch === "/" && code[i + 1] === "*") {
-				const end = code.indexOf("*/", i + 2);
-				i = end === -1 ? code.length : end + 2;
-			} else break;
-		}
-		const directive = code.slice(i).match(/^(["'])use [^"'\n]*\1\s*;?[^\S\n]*\n?/);
-		if (!directive) return i;
-		i += directive[0].length;
-	}
-}
 /** Keywords that precede `( ... ) {` without binding anything. */
 const NON_BINDING_KEYWORDS = "if|for|while|switch|return|typeof|await|yield|new|do|else|case|in|of|delete|void";
 /**
@@ -998,7 +974,7 @@ function hoistZodSchemasMeta(code, options) {
 		text: h.name
 	}));
 	const insert = {
-		offset: insertionOffset(code),
+		offset: moduleHeadOffset(code),
 		text: `${decls}\n`
 	};
 	return {