zod-compiler 1.26.3 → 1.27.0

package/dist/is-zod-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-zod-schema.js","names":[],"sources":["../src/is-zod-schema.ts"],"sourcesContent":["import type { ZodType } from \"zod\";\n\n/**\n * Is this value a Zod schema? Zod schemas carry `_zod.def`, so that is the\n * probe — the same one auto-discovery uses at build time and `jitAll` uses at\n * runtime.\n *\n * The probe is applied to values the caller does not control: every own value\n * of a module namespace under `jitAll`, every export of a candidate file under\n * discovery. Some of those are not plain objects. A Proxy can trap `has` and\n * `get` and throw — an ORM model, a strict test double, an i18n catch-all — and\n * `\"_zod\" in value` fires the first trap while reading `_zod` fires the second.\n * Whatever such a value is, it is not a Zod schema, and asking must not take\n * down the caller: an uncaught throw here aborts the importing app at boot, or\n * the build, over an object that was never a candidate.\n *\n * Kept as a leaf module with no runtime imports: `jit`/`jitAll` reach it on the\n * startup path, where pulling in the build-time graph would be pure cost.\n */\nexport function isZodSchema(value: unknown): value is ZodType {\n  if (typeof value !== \"object\" || value === null) return false;\n  try {\n    if (!(\"_zod\" in value)) return false;\n    const internal = (value as Record<string, unknown>)[\"_zod\"];\n    return typeof internal === \"object\" && internal !== null && \"def\" in internal;\n  } catch {\n    return false;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAmBA,SAAgB,YAAY,OAAkC;CAC5D,IAAI,OAAO,UAAU,YAAY,UAAU,MAAM,OAAO;CACxD,IAAI;EACF,IAAI,EAAE,UAAU,QAAQ,OAAO;EAC/B,MAAM,WAAY,MAAkC;EACpD,OAAO,OAAO,aAAa,YAAY,aAAa,QAAQ,SAAS;CACvE,QAAQ;EACN,OAAO;CACT;AACF"}

package/dist/jit.d.ts

@@ -9,6 +9,8 @@ interface JitOptions {
    * eagerly. Default `false`.
    */
   eager?: boolean | undefined;
+  /** Use compact codegen and delegate cold error production to Zod. @default "schema" */
+  output?: "schema" | "compact" | undefined;
 }
 /**
  * Compile `schema` in-process and install the compiled `parse` / `safeParse` /

package/dist/jit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jit.d.ts","names":[],"sources":["../src/jit.ts"],"mappings":";;;UA4EiB;;;;;;;EAOf;;;;;;;;;;;;;;;;;;;;;;;iBAwBc,IAAI,UAAU,SAC5B,QAAQ,GACR,UAAU,aACT,IAAI,eAAe,OAAO;;;;;;;;;;;;;;iBAkHb,OAAO,iBAAiB,UAAU"}
+{"version":3,"file":"jit.d.ts","names":[],"sources":["../src/jit.ts"],"mappings":";;;UA6EiB;;;;;;;EAOf;;EAEA;;;;;;;;;;;;;;;;;;;;;;;iBAwBc,IAAI,UAAU,SAC5B,QAAQ,GACR,UAAU,aACT,IAAI,eAAe,OAAO;;;;;;;;;;;;;;iBA8Kb,OAAO,iBAAiB,UAAU"}

package/dist/jit.js

@@ -1,3 +1,4 @@
+import { isZodSchema } from "./is-zod-schema.js";
 import { FAILZ_CLASS_DECL, FAIL_CLASS_DECL, FINZ_DECL, FIN_DECL, FIN_DEFERRED_DECL, MK_VALIDATOR_DECL, ZOD_MSG_DECLARATION, generateIIFE } from "./core/iife.js";
 import { compileSchemas } from "./core/pipeline.js";
 import { ZodRealError, config, core } from "zod";
@@ -93,18 +94,22 @@ function jit(schema, options) {
 	if (seen.has(target)) return schema;
 	seen.add(target);
 	if (options?.eager === true) {
-		materialize(schema);
+		materialize(schema, options);
 		return schema;
 	}
 	const original = /* @__PURE__ */ new Map();
-	for (const slot of SLOTS) original.set(slot, Object.getOwnPropertyDescriptor(target, slot));
+	try {
+		for (const slot of SLOTS) original.set(slot, Object.getOwnPropertyDescriptor(target, slot));
+	} catch {
+		return schema;
+	}
 	let pending = true;
 	try {
 		installAccessors(target, original, () => {
 			if (!pending) return;
 			pending = false;
 			restore(target, original);
-			materialize(schema);
+			materialize(schema, options);
 		}, () => {
 			if (!pending) return;
 			pending = false;
@@ -118,27 +123,63 @@ function jit(schema, options) {
 }
 /**
 * Front every installed method with a compile-on-read accessor. `trigger`
-* materializes the schema, which replaces these accessors with the compiled
-* methods (or restores Zod's own), so the read that follows never re-enters.
+* materializes the schema, which normally replaces these accessors with the
+* compiled methods (or restores Zod's own). When that replacement does not take,
+* the getter falls back to the snapshot rather than re-reading the slot — see
+* the re-entrancy note in the body.
 */
 function installAccessors(target, original, trigger, cancel) {
-	for (const slot of SLOTS) Object.defineProperty(target, slot, {
-		configurable: true,
-		enumerable: original.get(slot)?.enumerable ?? false,
-		get() {
-			trigger();
-			return target[slot];
-		},
-		set(value) {
-			cancel();
-			Object.defineProperty(target, slot, {
-				configurable: true,
-				enumerable: original.get(slot)?.enumerable ?? false,
-				value,
-				writable: true
-			});
-		}
-	});
+	for (const slot of SLOTS) {
+		let reading = false;
+		const read = function() {
+			if (reading) return fromSnapshot(target, original, slot);
+			reading = true;
+			try {
+				trigger();
+				if (stillFrontedBy(target, slot, read)) return fromSnapshot(target, original, slot);
+				return target[slot];
+			} finally {
+				reading = false;
+			}
+		};
+		Object.defineProperty(target, slot, {
+			configurable: true,
+			enumerable: original.get(slot)?.enumerable ?? false,
+			get: read,
+			set(value) {
+				cancel();
+				Object.defineProperty(target, slot, {
+					configurable: true,
+					enumerable: original.get(slot)?.enumerable ?? false,
+					value,
+					writable: true
+				});
+			}
+		});
+	}
+}
+/**
+* Is `slot` still fronted by this very accessor — i.e. did the replacement that
+* `trigger()` was supposed to perform not take? A target that will not answer
+* the question is assumed to still hold it, since reading the slot to find out
+* is the recursion being avoided.
+*/
+function stillFrontedBy(target, slot, getter) {
+	try {
+		return Object.getOwnPropertyDescriptor(target, slot)?.get === getter;
+	} catch {
+		return true;
+	}
+}
+/**
+* What Zod had in `slot`, taken from the snapshot made before installation.
+* `undefined` for `is`, which no plain Zod schema carries — the same thing every
+* other degradation path leaves there.
+*/
+function fromSnapshot(target, original, slot) {
+	const descriptor = original.get(slot);
+	if (descriptor === void 0) return void 0;
+	return descriptor.get === void 0 ? descriptor.value : descriptor.get.call(target);
 }
 /**
 * Compile every Zod schema found among an object's own values — typically a
@@ -156,19 +197,13 @@ function installAccessors(target, original, trigger, cancel) {
 function jitAll(schemas, options) {
 	for (const value of Object.values(schemas)) if (isZodSchema(value)) jit(value, options);
 }
-/** Zod schemas carry `_zod.def`; the same probe auto-discovery uses at build time. */
-function isZodSchema(value) {
-	if (typeof value !== "object" || value === null || !("_zod" in value)) return false;
-	const internal = value["_zod"];
-	return typeof internal === "object" && internal !== null && "def" in internal;
-}
 /** Put Zod's own descriptors back, dropping the compile-on-read accessors. */
 function restore(target, original) {
-	for (const slot of SLOTS) {
+	for (const slot of SLOTS) try {
 		const descriptor = original.get(slot);
 		if (descriptor === void 0) delete target[slot];
 		else Object.defineProperty(target, slot, descriptor);
-	}
+	} catch {}
 }
 /**
 * Whether runtime code generation is permitted here. Read per call, never
@@ -184,10 +219,10 @@ function codegenAllowed() {
 * which the caller already has, so there is nothing to report and nothing to
 * break.
 */
-function materialize(schema) {
+function materialize(schema, options) {
 	if (!codegenAllowed()) return;
 	try {
-		buildValidator(schema);
+		buildValidator(schema, options);
 	} catch {}
 }
 /**
@@ -196,11 +231,14 @@ function materialize(schema) {
 * then the `__zcMkv` IIFE whose `__rf[]` bases and install target are the live
 * schema object passed in as `__schema`.
 */
-function buildValidator(schema) {
+function buildValidator(schema, options) {
 	const { schemas, shared } = compileSchemas([{
 		exportName: "jit",
 		schema
-	}], { mode: "inline" });
+	}], {
+		compact: options?.output === "compact",
+		mode: "inline"
+	});
 	const compiled = schemas[0];
 	if (compiled === void 0) throw new Error("zod-compiler: schema produced no validator");
 	const body = [

package/dist/jit.js.map

@@ -1 +1 @@
-{"version":3,"file":"jit.js","names":["zodCore","zodConfig"],"sources":["../src/jit.ts"],"sourcesContent":["/**\n * Runtime compilation — the same extract → codegen pipeline the build plugin\n * runs, executed in-process and evaluated through `new Function`.\n *\n * The AOT paths (unplugin, CLI) need a build step to fire. Plenty of everyday\n * code has none: `tsx server.ts`, `node --experimental-strip-types`, a Jest\n * suite, a serverless handler bundled by someone else's toolchain, a library\n * that ships schemas to consumers. There `compile()` is a no-op and every parse\n * runs plain Zod. `jit()` closes that gap — one call, no build integration,\n * measured 3-25x on everyday schemas at ~0.1-0.2 ms of one-time compilation.\n *\n * Nothing here re-implements validation: {@link compileSchemas} and\n * {@link generateIIFE} are the exact modules the plugin and CLI use, so the\n * generated validator, its Zod parity and its performance are identical to what\n * a build would have emitted. The only difference is *when* the code is\n * produced.\n *\n * Compilation is LAZY by default: `jit()` installs accessors that compile on\n * the first read of a parse method and replace themselves with the compiled\n * ones. Importing a module of 500 schemas therefore costs nothing, and a\n * serverless invocation touching three of them pays for three.\n *\n * Runtime code generation is not always permitted — a strict CSP without\n * `unsafe-eval`, some edge runtimes. Zod v4 has the same constraint (its object\n * fast-pass is itself a `new Function`) and already exposes the two switches\n * for it: the `core.util.allowsEval` probe and `z.config({ jitless: true })`.\n * `jit()` honours both and degrades to plain Zod, so one setting governs both\n * compilers. Those targets are where the build plugin belongs anyway — it emits\n * the same validator with no runtime evaluation at all.\n */\n\nimport { config as zodConfig, core as zodCore, ZodRealError, type output, type ZodType } from \"zod\";\nimport {\n  FAIL_CLASS_DECL,\n  FAILZ_CLASS_DECL,\n  FIN_DECL,\n  FIN_DEFERRED_DECL,\n  FINZ_DECL,\n  generateIIFE,\n  MK_VALIDATOR_DECL,\n  ZOD_MSG_DECLARATION,\n} from \"./core/iife.js\";\nimport { compileSchemas } from \"./core/pipeline.js\";\nimport type { CompiledSchema } from \"./core/types.js\";\n\n/**\n * The declarations `ZOD_CONFIG_IMPORT` supplies to an emitted module, minus the\n * import itself — `zod`'s three bindings arrive as parameters instead, so the\n * evaluated code has no module scope to resolve. Byte-for-byte the same helper\n * source the CLI emitter writes into a `.compiled.ts`, so a JIT validator and\n * an AOT one share their entire runtime layer.\n */\nconst RUNTIME_PRELUDE = [\n  ZOD_MSG_DECLARATION,\n  FAIL_CLASS_DECL,\n  MK_VALIDATOR_DECL,\n  FIN_DECL,\n  FIN_DEFERRED_DECL,\n  FAILZ_CLASS_DECL,\n  FINZ_DECL,\n].join(\"\\n\");\n\n/**\n * Methods `__zcMkv` installs. Each is fronted by a compile-on-read accessor\n * until the schema materializes.\n *\n * `~standard` earns its place: Zod builds it as a closure over `_zod.run`, not\n * over the schema's `safeParse` property, so a Standard Schema consumer (tRPC,\n * Hono, TanStack Form) that never touches `safeParse` would otherwise keep\n * running plain Zod forever behind a \"compiled\" schema.\n */\nconst SLOTS = [\"parse\", \"safeParse\", \"parseAsync\", \"safeParseAsync\", \"is\", \"~standard\"] as const;\n\n/** Schemas already handed to `jit()`, so a second call is a no-op rather than a recompile. */\nconst seen = new WeakSet<object>();\n\nexport interface JitOptions {\n  /**\n   * Compile immediately instead of on first use. Costs ~0.1-0.2 ms per schema\n   * at import time; useful for a long-lived server that would rather pay during\n   * startup than on the first request, or to surface a compilation failure\n   * eagerly. Default `false`.\n   */\n  eager?: boolean | undefined;\n}\n\n/**\n * Compile `schema` in-process and install the compiled `parse` / `safeParse` /\n * `parseAsync` / `safeParseAsync` / `is` / `~standard` on it.\n *\n * Returns the SAME object — identity-preserving exactly as the build plugin is,\n * so `.shape`, `_zod`, `instanceof`, `z.toJSONSchema()`, `.meta()` and\n * composition into a larger schema all keep working, and every existing\n * reference to the schema picks the compiled methods up.\n *\n * ```ts\n * import { z } from \"zod\";\n * import { jit } from \"zod-compiler/jit\";\n *\n * export const UserSchema = jit(z.object({ name: z.string(), email: z.email() }));\n * UserSchema.safeParse(input); // compiled on this first call\n * ```\n *\n * Schemas the compiler cannot reproduce fall back to Zod per sub-schema, the\n * same way they do at build time; a schema that cannot be compiled at all is\n * left as plain Zod.\n */\nexport function jit<T extends ZodType>(\n  schema: T,\n  options?: JitOptions,\n): T & CompiledSchema<output<T>> {\n  const target = schema as unknown as Record<string, unknown>;\n  if (seen.has(target)) return schema as T & CompiledSchema<output<T>>;\n  seen.add(target);\n\n  if (options?.eager === true) {\n    materialize(schema);\n    return schema as T & CompiledSchema<output<T>>;\n  }\n\n  // Snapshot Zod's own descriptors first: materialize() restores them before\n  // handing the object to `__zcMkv`, so the generated code sees a pristine\n  // schema — it captures the original `parseAsync` / `safeParseAsync` as its\n  // throw paths, and capturing a stub there would loop back into itself.\n  const original = new Map<string, PropertyDescriptor | undefined>();\n  for (const slot of SLOTS) {\n    original.set(slot, Object.getOwnPropertyDescriptor(target, slot));\n  }\n\n  // Installing the accessors is the one step that can throw rather than degrade:\n  // a slot locked non-configurable (a future Zod, another wrapper) makes\n  // defineProperty raise, and `jit()` is called at module scope — so an\n  // unhandled throw here takes down the importing app at boot. Roll back to\n  // whatever Zod had and leave the schema alone instead.\n  let pending = true;\n  try {\n    installAccessors(\n      target,\n      original,\n      () => {\n        if (!pending) return;\n        pending = false;\n        restore(target, original);\n        materialize(schema);\n      },\n      () => {\n        if (!pending) return;\n        pending = false;\n        // Restore EVERY slot, not just the one being written. A left-behind\n        // accessor whose trigger has been cancelled would read `target[slot]`\n        // and re-enter itself — unbounded recursion, which is what a later read\n        // of an untouched slot (`~standard`, from a Standard Schema consumer)\n        // would otherwise hit.\n        //\n        // Reached only when something WRITES a slot before anything reads one: a\n        // test double, another wrapper, or an AOT `safeParse` assigned directly.\n        // The build plugin's own `__zcMkv` does not land here — its first\n        // statement READS `parseAsync`/`safeParseAsync` to capture their\n        // originals, so it triggers materialization and then overwrites the\n        // compiled-by-jit methods with the compiled-by-plugin ones.\n        restore(target, original);\n      },\n    );\n  } catch {\n    pending = false;\n    restore(target, original);\n  }\n\n  return schema as T & CompiledSchema<output<T>>;\n}\n\n/**\n * Front every installed method with a compile-on-read accessor. `trigger`\n * materializes the schema, which replaces these accessors with the compiled\n * methods (or restores Zod's own), so the read that follows never re-enters.\n */\nfunction installAccessors(\n  target: Record<string, unknown>,\n  original: ReadonlyMap<string, PropertyDescriptor | undefined>,\n  trigger: () => void,\n  cancel: () => void,\n): void {\n  for (const slot of SLOTS) {\n    Object.defineProperty(target, slot, {\n      configurable: true,\n      // Preserve Zod's own visibility: parse/safeParse/... are enumerable own\n      // properties, `~standard` is not. `is` does not exist on a Zod schema, so\n      // it follows the non-enumerable convention `compile()` already uses.\n      enumerable: original.get(slot)?.enumerable ?? false,\n      get() {\n        trigger();\n        // Whatever now occupies the slot: the compiled method, or — if\n        // compilation was impossible — Zod's own, put back by restore().\n        return target[slot];\n      },\n      set(value: unknown) {\n        // Someone overwrote a method before first use (a test double, another\n        // wrapper). Their value wins, and compilation is cancelled outright —\n        // materializing later would restore Zod's descriptors over it.\n        cancel();\n        Object.defineProperty(target, slot, {\n          configurable: true,\n          enumerable: original.get(slot)?.enumerable ?? false,\n          value,\n          writable: true,\n        });\n      },\n    });\n  }\n}\n\n/**\n * Compile every Zod schema found among an object's own values — typically a\n * module namespace, so a whole schema file opts in with one call:\n *\n * ```ts\n * import * as schemas from \"./schemas.js\";\n * jitAll(schemas);\n * ```\n *\n * The namespace object itself is never written to (a module namespace is\n * read-only); `jit()` mutates the schema objects it holds, which is what every\n * importer of that module already references.\n */\nexport function jitAll(schemas: object, options?: JitOptions): void {\n  for (const value of Object.values(schemas)) {\n    if (isZodSchema(value)) jit(value, options);\n  }\n}\n\n/** Zod schemas carry `_zod.def`; the same probe auto-discovery uses at build time. */\nfunction isZodSchema(value: unknown): value is ZodType {\n  if (typeof value !== \"object\" || value === null || !(\"_zod\" in value)) return false;\n  const internal = (value as Record<string, unknown>)[\"_zod\"];\n  return typeof internal === \"object\" && internal !== null && \"def\" in internal;\n}\n\n/** Put Zod's own descriptors back, dropping the compile-on-read accessors. */\nfunction restore(\n  target: Record<string, unknown>,\n  original: ReadonlyMap<string, PropertyDescriptor | undefined>,\n): void {\n  for (const slot of SLOTS) {\n    const descriptor = original.get(slot);\n    if (descriptor === undefined) delete target[slot];\n    else Object.defineProperty(target, slot, descriptor);\n  }\n}\n\n/**\n * Whether runtime code generation is permitted here. Read per call, never\n * snapshotted: `z.config({ jitless: true })` runs in an entry point, after the\n * schema modules it imports have already been evaluated.\n */\nfunction codegenAllowed(): boolean {\n  return zodCore.globalConfig.jitless !== true && zodCore.util.allowsEval.value;\n}\n\n/**\n * Run the pipeline and let the generated IIFE install its methods on `schema`.\n * Swallows failure: a schema that cannot be compiled keeps Zod's own methods,\n * which the caller already has, so there is nothing to report and nothing to\n * break.\n */\nfunction materialize(schema: unknown): void {\n  if (!codegenAllowed()) return;\n  try {\n    buildValidator(schema);\n  } catch {\n    // Left as plain Zod. Deliberately silent: `jit()` is an optimization, and a\n    // schema using a construct the compiler declines is a supported outcome,\n    // not an error.\n  }\n}\n\n/**\n * Generate the validator and evaluate it, reproducing the module a\n * `.compiled.ts` would have been: helper preamble, the file-level shared block,\n * then the `__zcMkv` IIFE whose `__rf[]` bases and install target are the live\n * schema object passed in as `__schema`.\n */\nfunction buildValidator(schema: unknown): void {\n  const { schemas, shared } = compileSchemas([{ exportName: \"jit\", schema }], { mode: \"inline\" });\n  const compiled = schemas[0];\n  if (compiled === undefined) throw new Error(\"zod-compiler: schema produced no validator\");\n\n  const body = [RUNTIME_PRELUDE, shared.code, `return ${generateIIFE(\"__schema\", compiled)};`].join(\n    \"\\n\",\n  );\n\n  // The three bindings ZOD_CONFIG_IMPORT would have imported, passed in so the\n  // evaluated code needs no module resolution of its own.\n  // oxlint-disable-next-line no-new-func -- generating the validator IS the feature\n  const factory = new Function(\n    \"__zodCompilerConfig\",\n    \"__zcCore\",\n    \"__zcZodError\",\n    \"__schema\",\n    body,\n  ) as (\n    zodConfigFn: typeof zodConfig,\n    zodCoreNs: typeof zodCore,\n    zodErrorCtor: typeof ZodRealError,\n    target: unknown,\n  ) => unknown;\n\n  factory(zodConfig, zodCore, ZodRealError, schema);\n}\n"],"mappings":"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"}
+{"version":3,"file":"jit.js","names":["zodCore","zodConfig"],"sources":["../src/jit.ts"],"sourcesContent":["/**\n * Runtime compilation — the same extract → codegen pipeline the build plugin\n * runs, executed in-process and evaluated through `new Function`.\n *\n * The AOT paths (unplugin, CLI) need a build step to fire. Plenty of everyday\n * code has none: `tsx server.ts`, `node --experimental-strip-types`, a Jest\n * suite, a serverless handler bundled by someone else's toolchain, a library\n * that ships schemas to consumers. There `compile()` is a no-op and every parse\n * runs plain Zod. `jit()` closes that gap — one call, no build integration,\n * measured 3-25x on everyday schemas at ~0.1-0.2 ms of one-time compilation.\n *\n * Nothing here re-implements validation: {@link compileSchemas} and\n * {@link generateIIFE} are the exact modules the plugin and CLI use, so the\n * generated validator, its Zod parity and its performance are identical to what\n * a build would have emitted. The only difference is *when* the code is\n * produced.\n *\n * Compilation is LAZY by default: `jit()` installs accessors that compile on\n * the first read of a parse method and replace themselves with the compiled\n * ones. Importing a module of 500 schemas therefore costs nothing, and a\n * serverless invocation touching three of them pays for three.\n *\n * Runtime code generation is not always permitted — a strict CSP without\n * `unsafe-eval`, some edge runtimes. Zod v4 has the same constraint (its object\n * fast-pass is itself a `new Function`) and already exposes the two switches\n * for it: the `core.util.allowsEval` probe and `z.config({ jitless: true })`.\n * `jit()` honours both and degrades to plain Zod, so one setting governs both\n * compilers. Those targets are where the build plugin belongs anyway — it emits\n * the same validator with no runtime evaluation at all.\n */\n\nimport { config as zodConfig, core as zodCore, ZodRealError, type output, type ZodType } from \"zod\";\nimport {\n  FAIL_CLASS_DECL,\n  FAILZ_CLASS_DECL,\n  FIN_DECL,\n  FIN_DEFERRED_DECL,\n  FINZ_DECL,\n  generateIIFE,\n  MK_VALIDATOR_DECL,\n  ZOD_MSG_DECLARATION,\n} from \"./core/iife.js\";\nimport { compileSchemas } from \"./core/pipeline.js\";\nimport type { CompiledSchema } from \"./core/types.js\";\nimport { isZodSchema } from \"./is-zod-schema.js\";\n\n/**\n * The declarations `ZOD_CONFIG_IMPORT` supplies to an emitted module, minus the\n * import itself — `zod`'s three bindings arrive as parameters instead, so the\n * evaluated code has no module scope to resolve. Byte-for-byte the same helper\n * source the CLI emitter writes into a `.compiled.ts`, so a JIT validator and\n * an AOT one share their entire runtime layer.\n */\nconst RUNTIME_PRELUDE = [\n  ZOD_MSG_DECLARATION,\n  FAIL_CLASS_DECL,\n  MK_VALIDATOR_DECL,\n  FIN_DECL,\n  FIN_DEFERRED_DECL,\n  FAILZ_CLASS_DECL,\n  FINZ_DECL,\n].join(\"\\n\");\n\n/**\n * Methods `__zcMkv` installs. Each is fronted by a compile-on-read accessor\n * until the schema materializes.\n *\n * `~standard` earns its place: Zod builds it as a closure over `_zod.run`, not\n * over the schema's `safeParse` property, so a Standard Schema consumer (tRPC,\n * Hono, TanStack Form) that never touches `safeParse` would otherwise keep\n * running plain Zod forever behind a \"compiled\" schema.\n */\nconst SLOTS = [\"parse\", \"safeParse\", \"parseAsync\", \"safeParseAsync\", \"is\", \"~standard\"] as const;\n\n/** Schemas already handed to `jit()`, so a second call is a no-op rather than a recompile. */\nconst seen = new WeakSet<object>();\n\nexport interface JitOptions {\n  /**\n   * Compile immediately instead of on first use. Costs ~0.1-0.2 ms per schema\n   * at import time; useful for a long-lived server that would rather pay during\n   * startup than on the first request, or to surface a compilation failure\n   * eagerly. Default `false`.\n   */\n  eager?: boolean | undefined;\n  /** Use compact codegen and delegate cold error production to Zod. @default \"schema\" */\n  output?: \"schema\" | \"compact\" | undefined;\n}\n\n/**\n * Compile `schema` in-process and install the compiled `parse` / `safeParse` /\n * `parseAsync` / `safeParseAsync` / `is` / `~standard` on it.\n *\n * Returns the SAME object — identity-preserving exactly as the build plugin is,\n * so `.shape`, `_zod`, `instanceof`, `z.toJSONSchema()`, `.meta()` and\n * composition into a larger schema all keep working, and every existing\n * reference to the schema picks the compiled methods up.\n *\n * ```ts\n * import { z } from \"zod\";\n * import { jit } from \"zod-compiler/jit\";\n *\n * export const UserSchema = jit(z.object({ name: z.string(), email: z.email() }));\n * UserSchema.safeParse(input); // compiled on this first call\n * ```\n *\n * Schemas the compiler cannot reproduce fall back to Zod per sub-schema, the\n * same way they do at build time; a schema that cannot be compiled at all is\n * left as plain Zod.\n */\nexport function jit<T extends ZodType>(\n  schema: T,\n  options?: JitOptions,\n): T & CompiledSchema<output<T>> {\n  const target = schema as unknown as Record<string, unknown>;\n  if (seen.has(target)) return schema as T & CompiledSchema<output<T>>;\n  seen.add(target);\n\n  if (options?.eager === true) {\n    materialize(schema, options);\n    return schema as T & CompiledSchema<output<T>>;\n  }\n\n  // Snapshot Zod's own descriptors first: materialize() restores them before\n  // handing the object to `__zcMkv`, so the generated code sees a pristine\n  // schema — it captures the original `parseAsync` / `safeParseAsync` as its\n  // throw paths, and capturing a stub there would loop back into itself.\n  const original = new Map<string, PropertyDescriptor | undefined>();\n  try {\n    for (const slot of SLOTS) {\n      original.set(slot, Object.getOwnPropertyDescriptor(target, slot));\n    }\n  } catch {\n    // The target answers a descriptor query with a throw — an exotic wrapper,\n    // not anything Zod built. Without a snapshot there is nothing to roll back\n    // to, so install nothing and hand back the schema exactly as it came.\n    return schema as T & CompiledSchema<output<T>>;\n  }\n\n  // Installing the accessors is the step most likely to throw rather than\n  // degrade: a slot locked non-configurable (a future Zod, another wrapper) makes\n  // defineProperty raise, and `jit()` is called at module scope — so an\n  // unhandled throw here takes down the importing app at boot. Roll back to\n  // whatever Zod had and leave the schema alone instead.\n  let pending = true;\n  try {\n    installAccessors(\n      target,\n      original,\n      () => {\n        if (!pending) return;\n        pending = false;\n        restore(target, original);\n        materialize(schema, options);\n      },\n      () => {\n        if (!pending) return;\n        pending = false;\n        // Restore EVERY slot, not just the one being written. A left-behind\n        // accessor whose trigger has been cancelled would read `target[slot]`\n        // and re-enter itself — unbounded recursion, which is what a later read\n        // of an untouched slot (`~standard`, from a Standard Schema consumer)\n        // would otherwise hit.\n        //\n        // Reached only when something WRITES a slot before anything reads one: a\n        // test double, another wrapper, or an AOT `safeParse` assigned directly.\n        // The build plugin's own `__zcMkv` does not land here — its first\n        // statement READS `parseAsync`/`safeParseAsync` to capture their\n        // originals, so it triggers materialization and then overwrites the\n        // compiled-by-jit methods with the compiled-by-plugin ones.\n        restore(target, original);\n      },\n    );\n  } catch {\n    pending = false;\n    restore(target, original);\n  }\n\n  return schema as T & CompiledSchema<output<T>>;\n}\n\n/**\n * Front every installed method with a compile-on-read accessor. `trigger`\n * materializes the schema, which normally replaces these accessors with the\n * compiled methods (or restores Zod's own). When that replacement does not take,\n * the getter falls back to the snapshot rather than re-reading the slot — see\n * the re-entrancy note in the body.\n */\nfunction installAccessors(\n  target: Record<string, unknown>,\n  original: ReadonlyMap<string, PropertyDescriptor | undefined>,\n  trigger: () => void,\n  cancel: () => void,\n): void {\n  for (const slot of SLOTS) {\n    // Re-entrancy is settled structurally rather than by inspection. Reading the\n    // slot again is how this getter normally hands over — to the compiled method\n    // materialize() installed, or to Zod's own that restore() put back — but the\n    // handover can fail to take: a target frozen after `jit()` refuses both, and\n    // a second copy of this module in the graph leaves ITS accessor on the slot,\n    // so the two bounce reads between them. `trigger()` is spent by then, so\n    // either way the read recurses until the stack blows. While a read is already\n    // in flight, serve Zod's own method from the snapshot: a schema that cannot\n    // be compiled still parses.\n    let reading = false;\n    const read = function (): unknown {\n      if (reading) return fromSnapshot(target, original, slot);\n      reading = true;\n      try {\n        trigger();\n        if (stillFrontedBy(target, slot, read)) return fromSnapshot(target, original, slot);\n        return target[slot];\n      } finally {\n        reading = false;\n      }\n    };\n    Object.defineProperty(target, slot, {\n      configurable: true,\n      // Preserve Zod's own visibility: parse/safeParse/... are enumerable own\n      // properties, `~standard` is not. `is` does not exist on a Zod schema, so\n      // it follows the non-enumerable convention `compile()` already uses.\n      enumerable: original.get(slot)?.enumerable ?? false,\n      get: read,\n      set(value: unknown) {\n        // Someone overwrote a method before first use (a test double, another\n        // wrapper). Their value wins, and compilation is cancelled outright —\n        // materializing later would restore Zod's descriptors over it.\n        cancel();\n        Object.defineProperty(target, slot, {\n          configurable: true,\n          enumerable: original.get(slot)?.enumerable ?? false,\n          value,\n          writable: true,\n        });\n      },\n    });\n  }\n}\n\n/**\n * Is `slot` still fronted by this very accessor — i.e. did the replacement that\n * `trigger()` was supposed to perform not take? A target that will not answer\n * the question is assumed to still hold it, since reading the slot to find out\n * is the recursion being avoided.\n */\nfunction stillFrontedBy(\n  target: Record<string, unknown>,\n  slot: string,\n  getter: () => unknown,\n): boolean {\n  try {\n    return Object.getOwnPropertyDescriptor(target, slot)?.get === getter;\n  } catch {\n    return true;\n  }\n}\n\n/**\n * What Zod had in `slot`, taken from the snapshot made before installation.\n * `undefined` for `is`, which no plain Zod schema carries — the same thing every\n * other degradation path leaves there.\n */\nfunction fromSnapshot(\n  target: Record<string, unknown>,\n  original: ReadonlyMap<string, PropertyDescriptor | undefined>,\n  slot: string,\n): unknown {\n  const descriptor = original.get(slot);\n  if (descriptor === undefined) return undefined;\n  // `~standard` is a lazy getter on a Zod schema, so invoke it rather than\n  // reading a `value` it does not have.\n  return descriptor.get === undefined ? descriptor.value : descriptor.get.call(target);\n}\n\n/**\n * Compile every Zod schema found among an object's own values — typically a\n * module namespace, so a whole schema file opts in with one call:\n *\n * ```ts\n * import * as schemas from \"./schemas.js\";\n * jitAll(schemas);\n * ```\n *\n * The namespace object itself is never written to (a module namespace is\n * read-only); `jit()` mutates the schema objects it holds, which is what every\n * importer of that module already references.\n */\nexport function jitAll(schemas: object, options?: JitOptions): void {\n  for (const value of Object.values(schemas)) {\n    if (isZodSchema(value)) jit(value, options);\n  }\n}\n\n/** Put Zod's own descriptors back, dropping the compile-on-read accessors. */\nfunction restore(\n  target: Record<string, unknown>,\n  original: ReadonlyMap<string, PropertyDescriptor | undefined>,\n): void {\n  for (const slot of SLOTS) {\n    // Per slot, because this also runs as the rollback for a failed install: a\n    // target that refuses one slot must not cost the others their restoration.\n    // A slot left fronted by its accessor still reads correctly — the getter\n    // serves Zod's own method from the snapshot — but it keeps a redundant\n    // indirection, so restoring what can be restored is worth the try/catch.\n    try {\n      const descriptor = original.get(slot);\n      if (descriptor === undefined) delete target[slot];\n      else Object.defineProperty(target, slot, descriptor);\n    } catch {\n      // Nothing further to try for this slot.\n    }\n  }\n}\n\n/**\n * Whether runtime code generation is permitted here. Read per call, never\n * snapshotted: `z.config({ jitless: true })` runs in an entry point, after the\n * schema modules it imports have already been evaluated.\n */\nfunction codegenAllowed(): boolean {\n  return zodCore.globalConfig.jitless !== true && zodCore.util.allowsEval.value;\n}\n\n/**\n * Run the pipeline and let the generated IIFE install its methods on `schema`.\n * Swallows failure: a schema that cannot be compiled keeps Zod's own methods,\n * which the caller already has, so there is nothing to report and nothing to\n * break.\n */\nfunction materialize(schema: unknown, options?: JitOptions): void {\n  if (!codegenAllowed()) return;\n  try {\n    buildValidator(schema, options);\n  } catch {\n    // Left as plain Zod. Deliberately silent: `jit()` is an optimization, and a\n    // schema using a construct the compiler declines is a supported outcome,\n    // not an error.\n  }\n}\n\n/**\n * Generate the validator and evaluate it, reproducing the module a\n * `.compiled.ts` would have been: helper preamble, the file-level shared block,\n * then the `__zcMkv` IIFE whose `__rf[]` bases and install target are the live\n * schema object passed in as `__schema`.\n */\nfunction buildValidator(schema: unknown, options?: JitOptions): void {\n  const { schemas, shared } = compileSchemas([{ exportName: \"jit\", schema }], {\n    compact: options?.output === \"compact\",\n    mode: \"inline\",\n  });\n  const compiled = schemas[0];\n  if (compiled === undefined) throw new Error(\"zod-compiler: schema produced no validator\");\n\n  const body = [RUNTIME_PRELUDE, shared.code, `return ${generateIIFE(\"__schema\", compiled)};`].join(\n    \"\\n\",\n  );\n\n  // The three bindings ZOD_CONFIG_IMPORT would have imported, passed in so the\n  // evaluated code needs no module resolution of its own.\n  // oxlint-disable-next-line no-new-func -- generating the validator IS the feature\n  const factory = new Function(\n    \"__zodCompilerConfig\",\n    \"__zcCore\",\n    \"__zcZodError\",\n    \"__schema\",\n    body,\n  ) as (\n    zodConfigFn: typeof zodConfig,\n    zodCoreNs: typeof zodCore,\n    zodErrorCtor: typeof ZodRealError,\n    target: unknown,\n  ) => unknown;\n\n  factory(zodConfig, zodCore, ZodRealError, schema);\n}\n"],"mappings":"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"}

package/dist/register/config.d.ts

@@ -0,0 +1,20 @@
+import { ZodCompilerPluginOptions } from "../unplugin/types.js";
+//#region src/register/config.d.ts
+type RegisterOutput = Extract<ZodCompilerPluginOptions["output"], "schema" | "compact">;
+type SharedRegisterOptions = Pick<ZodCompilerPluginOptions, "include" | "exclude" | "schemas" | "hoist">;
+/** Configuration loaded by `zod-compiler/register` from the current working directory. */
+interface ZodCompilerRegisterConfig extends SharedRegisterOptions {
+  /** JSON Schema used by editors. @default "./node_modules/zod-compiler/schema.json" */
+  $schema?: string | undefined;
+  /** Compile immediately instead of when a validation method is first read. @default false */
+  eager?: boolean | undefined;
+  /**
+   * Preserve the complete compiled validator, or delegate cold error production
+   * to the retained Zod schema in compact mode.
+   * @default "schema"
+   */
+  output?: RegisterOutput | undefined;
+}
+//#endregion
+export { ZodCompilerRegisterConfig };
+//# sourceMappingURL=config.d.ts.map

package/dist/register/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","names":[],"sources":["../../src/register/config.ts"],"mappings":";;KAEK,iBAAiB,QAAQ;KACzB,wBAAwB,KAC3B;;UAKe,kCAAkC;;EAEjD;;EAEA;;;;;;EAMA,SAAS"}

package/dist/register/config.js

@@ -0,0 +1 @@
+export {};

package/dist/register/index.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/register/index.js

@@ -0,0 +1,68 @@
+import { isCompiledSchema } from "../core/compile.js";
+import { jit, jitAll } from "../jit.js";
+import { decodeModuleSource, instrumentModule, isRegisterFormat } from "./transform.js";
+import { registerHooks } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import fs from "node:fs";
+import { init } from "es-module-lexer";
+//#region src/register/index.ts
+const CONFIG_FILE = "zod-compiler.json";
+const REGISTER_SYMBOL = Symbol.for("zod-compiler:register");
+await init;
+const config = loadConfig();
+const jitOptions = {
+	eager: config.eager,
+	output: config.output
+};
+Object.defineProperty(globalThis, REGISTER_SYMBOL, {
+	configurable: true,
+	value(value, flatten = false) {
+		registerValue(value);
+		if (flatten && typeof value === "object" && value !== null) for (const exported of Object.values(value)) registerValue(exported);
+		return value;
+	}
+});
+registerHooks({ load(url, context, nextLoad) {
+	const loaded = nextLoad(url, context);
+	if (!url.startsWith("file:") || !isRegisterFormat(loaded.format) || loaded.source == null) return loaded;
+	const filename = fileURLToPath(url).replaceAll("\\", "/");
+	const source = decodeModuleSource(loaded.source);
+	let transformed;
+	try {
+		transformed = instrumentModule(source, filename, loaded.format, config);
+	} catch {
+		return loaded;
+	}
+	return transformed === null ? loaded : {
+		...loaded,
+		source: transformed
+	};
+} });
+function registerValue(value) {
+	if (config.schemas === "explicit") {
+		if (isCompiledSchema(value)) jit(value, jitOptions);
+	} else jitAll({ value }, jitOptions);
+}
+function loadConfig() {
+	const filename = path.resolve(CONFIG_FILE);
+	let source;
+	try {
+		source = fs.readFileSync(filename, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return {};
+		throw error;
+	}
+	let value;
+	try {
+		value = JSON.parse(source);
+	} catch (error) {
+		throw new SyntaxError(`Cannot parse ${filename}: ${error.message}`, { cause: error });
+	}
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new TypeError(`${filename} must contain a JSON object`);
+	return value;
+}
+//#endregion
+export {};
+
+//# sourceMappingURL=index.js.map

package/dist/register/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/register/index.ts"],"sourcesContent":["import fs from \"node:fs\";\nimport { registerHooks } from \"node:module\";\nimport path from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport { init } from \"es-module-lexer\";\nimport type { ZodType } from \"zod\";\nimport { isCompiledSchema } from \"../core/compile.js\";\nimport { jit, jitAll, type JitOptions } from \"../jit.js\";\nimport type { ZodCompilerRegisterConfig } from \"./config.js\";\nimport { decodeModuleSource, instrumentModule, isRegisterFormat } from \"./transform.js\";\n\nconst CONFIG_FILE = \"zod-compiler.json\";\nconst REGISTER_SYMBOL = Symbol.for(\"zod-compiler:register\");\n\nawait init;\n\nconst config = loadConfig();\nconst jitOptions: JitOptions = {\n  eager: config.eager,\n  output: config.output,\n};\n\nObject.defineProperty(globalThis, REGISTER_SYMBOL, {\n  configurable: true,\n  value(value: unknown, flatten = false): unknown {\n    registerValue(value);\n    if (flatten && typeof value === \"object\" && value !== null) {\n      for (const exported of Object.values(value)) registerValue(exported);\n    }\n    return value;\n  },\n});\n\nregisterHooks({\n  load(url, context, nextLoad) {\n    const loaded = nextLoad(url, context);\n    if (!url.startsWith(\"file:\") || !isRegisterFormat(loaded.format) || loaded.source == null) {\n      return loaded;\n    }\n\n    // Posix separators, because the include/exclude globs are matched with\n    // picomatch and the plugin paths it was written against are bundler ids,\n    // which are already normalized. `fileURLToPath` is the only caller that\n    // yields native separators, so on Windows `include: [\"src/**\"]` matched\n    // nothing and the whole feature went silently inert.\n    const filename = fileURLToPath(url).replaceAll(\"\\\\\", \"/\");\n    const source = decodeModuleSource(loaded.source);\n    // This hook runs for EVERY module the process loads, and what it adds is\n    // only an optimization. So nothing it does may fail a load: a config value\n    // of the wrong shape, a lexer that chokes on a dialect it half-supports, a\n    // bad `hoist.schemaNamePattern` — each would otherwise surface as a crash\n    // at startup, in someone else's file, naming zod-compiler internals. Ship\n    // the module unchanged instead and leave its schemas uncompiled.\n    let transformed: string | null;\n    try {\n      transformed = instrumentModule(source, filename, loaded.format, config);\n    } catch {\n      return loaded;\n    }\n    return transformed === null ? loaded : { ...loaded, source: transformed };\n  },\n});\n\nfunction registerValue(value: unknown): void {\n  if (config.schemas === \"explicit\") {\n    if (isCompiledSchema(value)) jit(value as unknown as ZodType, jitOptions);\n  } else {\n    jitAll({ value }, jitOptions);\n  }\n}\n\nfunction loadConfig(): ZodCompilerRegisterConfig {\n  const filename = path.resolve(CONFIG_FILE);\n  let source: string;\n  try {\n    source = fs.readFileSync(filename, \"utf8\");\n  } catch (error) {\n    if ((error as NodeJS.ErrnoException).code === \"ENOENT\") return {};\n    throw error;\n  }\n\n  let value: unknown;\n  try {\n    value = JSON.parse(source);\n  } catch (error) {\n    throw new SyntaxError(`Cannot parse ${filename}: ${(error as Error).message}`, {\n      cause: error,\n    });\n  }\n  if (typeof value !== \"object\" || value === null || Array.isArray(value)) {\n    throw new TypeError(`${filename} must contain a JSON object`);\n  }\n  return value as ZodCompilerRegisterConfig;\n}\n"],"mappings":";;;;;;;;;AAWA,MAAM,cAAc;AACpB,MAAM,kBAAkB,OAAO,IAAI,uBAAuB;AAE1D,MAAM;AAEN,MAAM,SAAS,WAAW;AAC1B,MAAM,aAAyB;CAC7B,OAAO,OAAO;CACd,QAAQ,OAAO;AACjB;AAEA,OAAO,eAAe,YAAY,iBAAiB;CACjD,cAAc;CACd,MAAM,OAAgB,UAAU,OAAgB;EAC9C,cAAc,KAAK;EACnB,IAAI,WAAW,OAAO,UAAU,YAAY,UAAU,MACpD,KAAK,MAAM,YAAY,OAAO,OAAO,KAAK,GAAG,cAAc,QAAQ;EAErE,OAAO;CACT;AACF,CAAC;AAED,cAAc,EACZ,KAAK,KAAK,SAAS,UAAU;CAC3B,MAAM,SAAS,SAAS,KAAK,OAAO;CACpC,IAAI,CAAC,IAAI,WAAW,OAAO,KAAK,CAAC,iBAAiB,OAAO,MAAM,KAAK,OAAO,UAAU,MACnF,OAAO;CAQT,MAAM,WAAW,cAAc,GAAG,CAAC,CAAC,WAAW,MAAM,GAAG;CACxD,MAAM,SAAS,mBAAmB,OAAO,MAAM;CAO/C,IAAI;CACJ,IAAI;EACF,cAAc,iBAAiB,QAAQ,UAAU,OAAO,QAAQ,MAAM;CACxE,QAAQ;EACN,OAAO;CACT;CACA,OAAO,gBAAgB,OAAO,SAAS;EAAE,GAAG;EAAQ,QAAQ;CAAY;AAC1E,EACF,CAAC;AAED,SAAS,cAAc,OAAsB;CAC3C,IAAI,OAAO,YAAY,YACjB;MAAA,iBAAiB,KAAK,GAAG,IAAI,OAA6B,UAAU;CAAA,OAExE,OAAO,EAAE,MAAM,GAAG,UAAU;AAEhC;AAEA,SAAS,aAAwC;CAC/C,MAAM,WAAW,KAAK,QAAQ,WAAW;CACzC,IAAI;CACJ,IAAI;EACF,SAAS,GAAG,aAAa,UAAU,MAAM;CAC3C,SAAS,OAAO;EACd,IAAK,MAAgC,SAAS,UAAU,OAAO,CAAC;EAChE,MAAM;CACR;CAEA,IAAI;CACJ,IAAI;EACF,QAAQ,KAAK,MAAM,MAAM;CAC3B,SAAS,OAAO;EACd,MAAM,IAAI,YAAY,gBAAgB,SAAS,IAAK,MAAgB,WAAW,EAC7E,OAAO,MACT,CAAC;CACH;CACA,IAAI,OAAO,UAAU,YAAY,UAAU,QAAQ,MAAM,QAAQ,KAAK,GACpE,MAAM,IAAI,UAAU,GAAG,SAAS,4BAA4B;CAE9D,OAAO;AACT"}

package/dist/register/transform.d.ts

@@ -0,0 +1,16 @@
+import { ZodCompilerRegisterConfig } from "./config.js";
+//#region src/register/transform.d.ts
+type RegisterFormat = "commonjs" | "commonjs-typescript" | "module" | "module-typescript";
+/** Formats whose source Node can execute after a synchronous load hook returns it. */
+declare function isRegisterFormat(format: string | null | undefined): format is RegisterFormat;
+/** Decode the textual module formats accepted by Node's load hook. */
+declare function decodeModuleSource(source: string | ArrayBuffer | NodeJS.TypedArray): string;
+/**
+ * Add lazy JIT registration to a module without executing it during the load hook.
+ * Named ESM exports are referenced by their real local binding, so aliases and
+ * multiple declarations work without rewriting their initializers.
+ */
+declare function instrumentModule(source: string, filename: string, format: RegisterFormat, config: ZodCompilerRegisterConfig): string | null;
+//#endregion
+export { decodeModuleSource, instrumentModule, isRegisterFormat };
+//# sourceMappingURL=transform.d.ts.map

package/dist/register/transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.d.ts","names":[],"sources":["../../src/register/transform.ts"],"mappings":";;KAMK;;iBASW,iBAAiB,oCAAoC,UAAU;;iBAK/D,mBAAmB,iBAAiB,cAAc,OAAO;;;;;;iBAazD,iBACd,gBACA,kBACA,QAAQ,gBACR,QAAQ"}

package/dist/register/transform.js

@@ -0,0 +1,148 @@
+import { hoistZodSchemasMeta } from "../unplugin/hoist.js";
+import { shouldTransform } from "../unplugin/transform.js";
+import { parse } from "es-module-lexer";
+//#region src/register/transform.ts
+const REGISTER_CALL = "globalThis[Symbol.for(\"zod-compiler:register\")]";
+const SUPPORTED_FORMATS = /* @__PURE__ */ new Set([
+	"commonjs",
+	"commonjs-typescript",
+	"module",
+	"module-typescript"
+]);
+/** Formats whose source Node can execute after a synchronous load hook returns it. */
+function isRegisterFormat(format) {
+	return format !== null && format !== void 0 && SUPPORTED_FORMATS.has(format);
+}
+/** Decode the textual module formats accepted by Node's load hook. */
+function decodeModuleSource(source) {
+	if (typeof source === "string") return source;
+	if (source instanceof ArrayBuffer) return new TextDecoder().decode(source);
+	return new TextDecoder().decode(new Uint8Array(source.buffer, source.byteOffset, source.byteLength));
+}
+/**
+* Add lazy JIT registration to a module without executing it during the load hook.
+* Named ESM exports are referenced by their real local binding, so aliases and
+* multiple declarations work without rewriting their initializers.
+*/
+function instrumentModule(source, filename, format, config) {
+	if (!shouldTransform(filename, {
+		...config.include === void 0 ? {} : { include: config.include },
+		...config.exclude === void 0 ? {} : { exclude: config.exclude }
+	})) return null;
+	if (!/[Zz]od/.test(source)) return null;
+	const hoisted = config.hoist === false ? null : hoistZodSchemasMeta(source, hoistOptions(config));
+	const code = hoisted?.code ?? source;
+	const names = new Set(hoisted?.schemas.map((schema) => schema.name) ?? []);
+	if (format === "commonjs" || format === "commonjs-typescript") return appendRegistrations(code, [...names], true);
+	let exports;
+	try {
+		[, exports] = parse(code);
+	} catch {
+		return hoisted?.code ?? null;
+	}
+	const typeOnlyNames = collectTypeOnlyExportNames(code, exports);
+	for (const exported of exports) {
+		if (exported.ls < 0 || exported.le < 0) continue;
+		const localName = code.slice(exported.ls, exported.le);
+		if (typeOnlyNames.has(localName)) continue;
+		names.add(localName);
+	}
+	return names.size === 0 ? hoisted?.code ?? null : appendRegistrations(code, [...names], false);
+}
+function hoistOptions(config) {
+	return typeof config.hoist === "object" ? config.hoist : void 0;
+}
+/**
+* Reserved words es-module-lexer can hand back as a "local name". It reports
+* byte offsets into TypeScript it only half-understands, so `export const enum
+* Level` yields `enum` and `export default class extends Error {}` yields
+* `extends`. Emitting either as an expression is a SyntaxError, which no
+* try/catch can contain — the module never compiles.
+*/
+const RESERVED_WORDS = /* @__PURE__ */ new Set([
+	"await",
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"enum",
+	"export",
+	"extends",
+	"false",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"import",
+	"in",
+	"instanceof",
+	"new",
+	"null",
+	"return",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with",
+	"yield"
+]);
+/** Can this text be emitted as a bare identifier reference? */
+function isEmittableIdentifier(name) {
+	return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) && !RESERVED_WORDS.has(name);
+}
+/**
+* Registration is an optimization, so a registration that cannot run must cost
+* nothing but the optimization. Two things make one fail at runtime, and both
+* are unavoidable when the name comes from a JS lexer reading TS source:
+*
+*  - the binding does not exist — `export declare class`/`function` are erased
+*    by type stripping, and `export abstract class Base {}` is misreported as
+*    the local name `s` (the tail of the `class` keyword);
+*  - the binding exists but is not initialized yet — a re-exported import in a
+*    circular barrel is in its TDZ when the appended read runs.
+*
+* Both throw at the READ, so a per-call catch turns each from an app-down boot
+* failure into a schema that merely stays uncompiled. Per call rather than one
+* block around all of them, so one bad export does not cost its file-mates
+* their registration. The `globalThis[Symbol.for(...)]` lookup sits inside the
+* try too: a module that shadows `Symbol` would otherwise throw there instead.
+*/
+function appendRegistrations(code, names, commonjs) {
+	const calls = names.filter(isEmittableIdentifier).map((name) => `try{${REGISTER_CALL}(${name})}catch{}`);
+	if (commonjs) calls.push(`try{${REGISTER_CALL}(module.exports, true)}catch{}`);
+	if (calls.length === 0) return code;
+	return `${code}\n;${calls.join("\n")}\n`;
+}
+/** es-module-lexer deliberately accepts TS syntax but reports `type` list entries as values. */
+function collectTypeOnlyExportNames(code, exports) {
+	const names = /* @__PURE__ */ new Set();
+	for (const exported of exports) {
+		const statement = code.slice(exported.ss, exported.le < 0 ? exported.e : exported.le);
+		if (/^export\s+type\b/.test(statement)) {
+			if (exported.ln) names.add(exported.ln);
+			continue;
+		}
+		for (const match of statement.matchAll(/(?:^|[{,])\s*type\s+([A-Za-z_$][\w$]*)/g)) {
+			names.add("type");
+			if (match[1]) names.add(match[1]);
+		}
+	}
+	return names;
+}
+//#endregion
+export { decodeModuleSource, instrumentModule, isRegisterFormat };
+
+//# sourceMappingURL=transform.js.map

package/dist/register/transform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.js","names":[],"sources":["../../src/register/transform.ts"],"sourcesContent":["import { parse, type ExportSpecifier } from \"es-module-lexer\";\nimport { hoistZodSchemasMeta, type HoistOptions } from \"../unplugin/hoist.js\";\nimport { shouldTransform } from \"../unplugin/transform.js\";\nimport type { ZodCompilerRegisterConfig } from \"./config.js\";\n\nconst REGISTER_CALL = 'globalThis[Symbol.for(\"zod-compiler:register\")]';\ntype RegisterFormat = \"commonjs\" | \"commonjs-typescript\" | \"module\" | \"module-typescript\";\nconst SUPPORTED_FORMATS = new Set([\n  \"commonjs\",\n  \"commonjs-typescript\",\n  \"module\",\n  \"module-typescript\",\n]);\n\n/** Formats whose source Node can execute after a synchronous load hook returns it. */\nexport function isRegisterFormat(format: string | null | undefined): format is RegisterFormat {\n  return format !== null && format !== undefined && SUPPORTED_FORMATS.has(format);\n}\n\n/** Decode the textual module formats accepted by Node's load hook. */\nexport function decodeModuleSource(source: string | ArrayBuffer | NodeJS.TypedArray): string {\n  if (typeof source === \"string\") return source;\n  if (source instanceof ArrayBuffer) return new TextDecoder().decode(source);\n  return new TextDecoder().decode(\n    new Uint8Array(source.buffer, source.byteOffset, source.byteLength),\n  );\n}\n\n/**\n * Add lazy JIT registration to a module without executing it during the load hook.\n * Named ESM exports are referenced by their real local binding, so aliases and\n * multiple declarations work without rewriting their initializers.\n */\nexport function instrumentModule(\n  source: string,\n  filename: string,\n  format: RegisterFormat,\n  config: ZodCompilerRegisterConfig,\n): string | null {\n  const filter = {\n    ...(config.include === undefined ? {} : { include: config.include }),\n    ...(config.exclude === undefined ? {} : { exclude: config.exclude }),\n  };\n  if (!shouldTransform(filename, filter)) return null;\n  if (!/[Zz]od/.test(source)) return null;\n\n  const hoisted = config.hoist === false ? null : hoistZodSchemasMeta(source, hoistOptions(config));\n  const code = hoisted?.code ?? source;\n  const names = new Set(hoisted?.schemas.map((schema) => schema.name) ?? []);\n\n  if (format === \"commonjs\" || format === \"commonjs-typescript\") {\n    return appendRegistrations(code, [...names], true);\n  }\n\n  let exports: readonly ExportSpecifier[];\n  try {\n    [, exports] = parse(code);\n  } catch {\n    return hoisted?.code ?? null;\n  }\n\n  const typeOnlyNames = collectTypeOnlyExportNames(code, exports);\n  for (const exported of exports) {\n    if (exported.ls < 0 || exported.le < 0) continue;\n    const localName = code.slice(exported.ls, exported.le);\n    if (typeOnlyNames.has(localName)) continue;\n    names.add(localName);\n  }\n\n  return names.size === 0 ? (hoisted?.code ?? null) : appendRegistrations(code, [...names], false);\n}\n\nfunction hoistOptions(config: ZodCompilerRegisterConfig): HoistOptions | undefined {\n  return typeof config.hoist === \"object\" ? config.hoist : undefined;\n}\n\n/**\n * Reserved words es-module-lexer can hand back as a \"local name\". It reports\n * byte offsets into TypeScript it only half-understands, so `export const enum\n * Level` yields `enum` and `export default class extends Error {}` yields\n * `extends`. Emitting either as an expression is a SyntaxError, which no\n * try/catch can contain — the module never compiles.\n */\nconst RESERVED_WORDS = new Set([\n  \"await\",\n  \"break\",\n  \"case\",\n  \"catch\",\n  \"class\",\n  \"const\",\n  \"continue\",\n  \"debugger\",\n  \"default\",\n  \"delete\",\n  \"do\",\n  \"else\",\n  \"enum\",\n  \"export\",\n  \"extends\",\n  \"false\",\n  \"finally\",\n  \"for\",\n  \"function\",\n  \"if\",\n  \"import\",\n  \"in\",\n  \"instanceof\",\n  \"new\",\n  \"null\",\n  \"return\",\n  \"super\",\n  \"switch\",\n  \"this\",\n  \"throw\",\n  \"true\",\n  \"try\",\n  \"typeof\",\n  \"var\",\n  \"void\",\n  \"while\",\n  \"with\",\n  \"yield\",\n]);\n\n/** Can this text be emitted as a bare identifier reference? */\nfunction isEmittableIdentifier(name: string): boolean {\n  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) && !RESERVED_WORDS.has(name);\n}\n\n/**\n * Registration is an optimization, so a registration that cannot run must cost\n * nothing but the optimization. Two things make one fail at runtime, and both\n * are unavoidable when the name comes from a JS lexer reading TS source:\n *\n *  - the binding does not exist — `export declare class`/`function` are erased\n *    by type stripping, and `export abstract class Base {}` is misreported as\n *    the local name `s` (the tail of the `class` keyword);\n *  - the binding exists but is not initialized yet — a re-exported import in a\n *    circular barrel is in its TDZ when the appended read runs.\n *\n * Both throw at the READ, so a per-call catch turns each from an app-down boot\n * failure into a schema that merely stays uncompiled. Per call rather than one\n * block around all of them, so one bad export does not cost its file-mates\n * their registration. The `globalThis[Symbol.for(...)]` lookup sits inside the\n * try too: a module that shadows `Symbol` would otherwise throw there instead.\n */\nfunction appendRegistrations(code: string, names: readonly string[], commonjs: boolean): string {\n  const calls = names\n    .filter(isEmittableIdentifier)\n    .map((name) => `try{${REGISTER_CALL}(${name})}catch{}`);\n  if (commonjs) calls.push(`try{${REGISTER_CALL}(module.exports, true)}catch{}`);\n  if (calls.length === 0) return code;\n  return `${code}\\n;${calls.join(\"\\n\")}\\n`;\n}\n\n/** es-module-lexer deliberately accepts TS syntax but reports `type` list entries as values. */\nfunction collectTypeOnlyExportNames(\n  code: string,\n  exports: readonly ExportSpecifier[],\n): ReadonlySet<string> {\n  const names = new Set<string>();\n  for (const exported of exports) {\n    const statement = code.slice(exported.ss, exported.le < 0 ? exported.e : exported.le);\n    if (/^export\\s+type\\b/.test(statement)) {\n      if (exported.ln) names.add(exported.ln);\n      continue;\n    }\n    for (const match of statement.matchAll(/(?:^|[{,])\\s*type\\s+([A-Za-z_$][\\w$]*)/g)) {\n      names.add(\"type\");\n      if (match[1]) names.add(match[1]);\n    }\n  }\n  return names;\n}\n"],"mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"file":"hoist-compile.d.ts","names":[],"sources":["../../src/unplugin/hoist-compile.ts"],"mappings":";;;;;UA6CiB;;EAEf;;EAEA;;EAEA,MAAM;;;;;;iBAmGc,sBACpB,kBAAkB,iBAClB,cACA,YACA,MAAM,cACL,QAAQ"}
+{"version":3,"file":"hoist-compile.d.ts","names":[],"sources":["../../src/unplugin/hoist-compile.ts"],"mappings":";;;;;UA8CiB;;EAEf;;EAEA;;EAEA,MAAM;;;;;;iBAyFc,sBACpB,kBAAkB,iBAClB,cACA,YACA,MAAM,cACL,QAAQ"}

package/dist/unplugin/hoist-compile.js

@@ -1,12 +1,9 @@
+import { isZodSchema } from "../is-zod-schema.js";
 import { loadModule } from "../loader.js";
 import { generateValidator } from "../core/codegen/index.js";
 import { extractSchema } from "../core/extract/index.js";
 import { analyzeHoistedExpression, collectImportBindings } from "./hoist.js";
 //#region src/unplugin/hoist-compile.ts
-/** Duck-type check mirroring discovery's isZodSchema. */
-function isZodSchema(value) {
-	return typeof value === "object" && value !== null && "_zod" in value && typeof value._zod === "object";
-}
 /**
 * Evaluate a hoisted expression with its zod bindings and compile it.
 * Returns null when the schema is ineligible or anything fails.

package/dist/unplugin/hoist-compile.js.map

@@ -1 +1 @@
-{"version":3,"file":"hoist-compile.js","names":[],"sources":["../../src/unplugin/hoist-compile.ts"],"sourcesContent":["/**\n * Build-time compilation of hoisted schemas.\n *\n * After hoistZodSchemasMeta() lifts `z.object({...})` constructions to\n * module-scope `_zh_*` declarations, this step evaluates each hoisted\n * expression with the project's real zod module, runs the regular\n * extract → codegen pipeline on the resulting schema object, and hands the\n * transform a compiled IIFE to splice in as the declaration initializer:\n *\n *   const _zh_x = z.object({ id: z.number() });\n *     ⇣\n *   const _zh_x = /* @__PURE__ *\\/ (() => { ... return __zcMkv(...); })();\n *\n * Eligibility is STRICTER than hoist eligibility. Hoisting only moves an\n * expression; compiling it bakes build-time evaluation results into\n * generated checks, so the construction must be deterministic:\n *\n * - Every EAGER free identifier must be a zod-package binding. Anything\n *   else (other imports: `getLimit()`, globals: `new Date()`,\n *   `Math.random()`) could evaluate differently at build time vs module\n *   load — those schemas stay plainly hoisted.\n * - DEFERRED references (inside refine/transform/default callbacks) are\n *   unrestricted: callbacks reach generated code via fn.toString() or stay\n *   on the runtime-constructed schema (`__rf` delegation), never via their\n *   build-time closure values. If extraction itself needs a deferred value\n *   it cannot have (z.lazy(() => ImportedChild)), evaluation throws and the\n *   schema falls back to a plain hoist.\n *\n * Every failure path is graceful: the declaration keeps its original zod\n * expression and runtime behavior is unchanged.\n */\n\nimport type { CodegenMode } from \"../core/codegen/context.js\";\nimport { generateValidator } from \"../core/codegen/index.js\";\nimport { extractSchema, type RefEntry } from \"../core/extract/index.js\";\nimport type { CompiledSchemaInfo } from \"../core/pipeline.js\";\nimport { loadModule } from \"../loader.js\";\nimport {\n  analyzeHoistedExpression,\n  collectImportBindings,\n  type HoistedSchema,\n  type ImportDetail,\n} from \"./hoist.js\";\n\n/** A hoisted declaration whose initializer can be replaced with a compiled IIFE. */\nexport interface CompiledHoistedSchema {\n  /** The `_zh_*` declaration name. */\n  name: string;\n  /** Original construction expression text (becomes the IIFE's schema expression). */\n  text: string;\n  /** Compiled validator for the schema. */\n  info: CompiledSchemaInfo;\n}\n\n/** Duck-type check mirroring discovery's isZodSchema. */\nfunction isZodSchema(value: unknown): boolean {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    \"_zod\" in value &&\n    typeof (value as { _zod: unknown })._zod === \"object\"\n  );\n}\n\n/**\n * Evaluate a hoisted expression with its zod bindings and compile it.\n * Returns null when the schema is ineligible or anything fails.\n */\nasync function compileOne(\n  schema: HoistedSchema,\n  importDetails: Map<string, ImportDetail>,\n  id: string,\n  mode: CodegenMode,\n  moduleCache: Map<string, Promise<Record<string, unknown>>>,\n): Promise<CompiledHoistedSchema | null> {\n  const analysis = analyzeHoistedExpression(schema.text);\n  if (analysis === null) return null;\n\n  // Determinism gate: eager evaluation may only touch zod bindings.\n  const free = new Set([...analysis.eagerFree, ...analysis.deferredFree]);\n  const bindings: Array<{ name: string; detail: ImportDetail }> = [];\n  for (const name of analysis.eagerFree) {\n    const detail = importDetails.get(name);\n    if (!detail || !isZodSpecifier(detail.specifier)) return null;\n  }\n  // Inject every free import binding we can resolve (eager ones are all zod\n  // by the gate above; deferred ones are best-effort — extraction only\n  // dereferences them for build-time-invoked callbacks like z.lazy getters).\n  for (const name of free) {\n    const detail = importDetails.get(name);\n    if (detail && isZodSpecifier(detail.specifier)) {\n      bindings.push({ name, detail });\n    } else if (analysis.eagerFree.has(name)) {\n      return null;\n    }\n    // deferred non-zod names stay unbound: the evaluated closure would throw\n    // if invoked at build time, which the try/catch below converts to a skip.\n  }\n\n  try {\n    const values = await Promise.all(\n      bindings.map(async ({ detail }) => {\n        let loading = moduleCache.get(detail.specifier);\n        if (!loading) {\n          loading = loadModule(detail.specifier, id);\n          moduleCache.set(detail.specifier, loading);\n        }\n        const mod = await loading;\n        return detail.imported === \"*\" ? mod : mod[detail.imported];\n      }),\n    );\n\n    const evaluate = new Function(\n      ...bindings.map((b) => b.name),\n      `\"use strict\"; return (${schema.text});`,\n    );\n    const value: unknown = evaluate(...values);\n    if (!isZodSchema(value)) return null;\n\n    const refEntries: RefEntry[] = [];\n    const ir = extractSchema(value, refEntries);\n    // A root fallback compiles to a pure delegation wrapper — strictly worse\n    // than leaving the plain hoisted construction in place.\n    if (ir.type === \"fallback\") return null;\n\n    const codegenResult = generateValidator(ir, schema.name, { mode });\n    return {\n      name: schema.name,\n      text: schema.text,\n      info: { exportName: schema.name, codegenResult, refEntries },\n    };\n  } catch {\n    return null;\n  }\n}\n\nfunction isZodSpecifier(specifier: string): boolean {\n  return (\n    specifier === \"zod\" ||\n    specifier === \"zod/v4\" ||\n    specifier === \"zod/mini\" ||\n    specifier === \"zod/v4/mini\" ||\n    specifier === \"zod/v4-mini\"\n  );\n}\n\n/**\n * Compile every eligible hoisted schema. Failures are silent per schema —\n * the caller leaves ineligible declarations as plain hoists.\n */\nexport async function compileHoistedSchemas(\n  schemas: readonly HoistedSchema[],\n  code: string,\n  id: string,\n  mode: CodegenMode,\n): Promise<CompiledHoistedSchema[]> {\n  const { details } = collectImportBindings(code);\n  const moduleCache = new Map<string, Promise<Record<string, unknown>>>();\n  const compiled: CompiledHoistedSchema[] = [];\n  for (const schema of schemas) {\n    const result = await compileOne(schema, details, id, mode, moduleCache);\n    if (result !== null) compiled.push(result);\n  }\n  return compiled;\n}\n"],"mappings":";;;;;;AAuDA,SAAS,YAAY,OAAyB;CAC5C,OACE,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACV,OAAQ,MAA4B,SAAS;AAEjD;;;;;AAMA,eAAe,WACb,QACA,eACA,IACA,MACA,aACuC;CACvC,MAAM,WAAW,yBAAyB,OAAO,IAAI;CACrD,IAAI,aAAa,MAAM,OAAO;CAG9B,MAAM,uBAAO,IAAI,IAAI,CAAC,GAAG,SAAS,WAAW,GAAG,SAAS,YAAY,CAAC;CACtE,MAAM,WAA0D,CAAC;CACjE,KAAK,MAAM,QAAQ,SAAS,WAAW;EACrC,MAAM,SAAS,cAAc,IAAI,IAAI;EACrC,IAAI,CAAC,UAAU,CAAC,eAAe,OAAO,SAAS,GAAG,OAAO;CAC3D;CAIA,KAAK,MAAM,QAAQ,MAAM;EACvB,MAAM,SAAS,cAAc,IAAI,IAAI;EACrC,IAAI,UAAU,eAAe,OAAO,SAAS,GAC3C,SAAS,KAAK;GAAE;GAAM;EAAO,CAAC;OACzB,IAAI,SAAS,UAAU,IAAI,IAAI,GACpC,OAAO;CAIX;CAEA,IAAI;EACF,MAAM,SAAS,MAAM,QAAQ,IAC3B,SAAS,IAAI,OAAO,EAAE,aAAa;GACjC,IAAI,UAAU,YAAY,IAAI,OAAO,SAAS;GAC9C,IAAI,CAAC,SAAS;IACZ,UAAU,WAAW,OAAO,WAAW,EAAE;IACzC,YAAY,IAAI,OAAO,WAAW,OAAO;GAC3C;GACA,MAAM,MAAM,MAAM;GAClB,OAAO,OAAO,aAAa,MAAM,MAAM,IAAI,OAAO;EACpD,CAAC,CACH;EAMA,MAAM,QAAiB,IAJF,SACnB,GAAG,SAAS,KAAK,MAAM,EAAE,IAAI,GAC7B,yBAAyB,OAAO,KAAK,GAET,CAAC,CAAC,GAAG,MAAM;EACzC,IAAI,CAAC,YAAY,KAAK,GAAG,OAAO;EAEhC,MAAM,aAAyB,CAAC;EAChC,MAAM,KAAK,cAAc,OAAO,UAAU;EAG1C,IAAI,GAAG,SAAS,YAAY,OAAO;EAEnC,MAAM,gBAAgB,kBAAkB,IAAI,OAAO,MAAM,EAAE,KAAK,CAAC;EACjE,OAAO;GACL,MAAM,OAAO;GACb,MAAM,OAAO;GACb,MAAM;IAAE,YAAY,OAAO;IAAM;IAAe;GAAW;EAC7D;CACF,QAAQ;EACN,OAAO;CACT;AACF;AAEA,SAAS,eAAe,WAA4B;CAClD,OACE,cAAc,SACd,cAAc,YACd,cAAc,cACd,cAAc,iBACd,cAAc;AAElB;;;;;AAMA,eAAsB,sBACpB,SACA,MACA,IACA,MACkC;CAClC,MAAM,EAAE,YAAY,sBAAsB,IAAI;CAC9C,MAAM,8BAAc,IAAI,IAA8C;CACtE,MAAM,WAAoC,CAAC;CAC3C,KAAK,MAAM,UAAU,SAAS;EAC5B,MAAM,SAAS,MAAM,WAAW,QAAQ,SAAS,IAAI,MAAM,WAAW;EACtE,IAAI,WAAW,MAAM,SAAS,KAAK,MAAM;CAC3C;CACA,OAAO;AACT"}
+{"version":3,"file":"hoist-compile.js","names":[],"sources":["../../src/unplugin/hoist-compile.ts"],"sourcesContent":["/**\n * Build-time compilation of hoisted schemas.\n *\n * After hoistZodSchemasMeta() lifts `z.object({...})` constructions to\n * module-scope `_zh_*` declarations, this step evaluates each hoisted\n * expression with the project's real zod module, runs the regular\n * extract → codegen pipeline on the resulting schema object, and hands the\n * transform a compiled IIFE to splice in as the declaration initializer:\n *\n *   const _zh_x = z.object({ id: z.number() });\n *     ⇣\n *   const _zh_x = /* @__PURE__ *\\/ (() => { ... return __zcMkv(...); })();\n *\n * Eligibility is STRICTER than hoist eligibility. Hoisting only moves an\n * expression; compiling it bakes build-time evaluation results into\n * generated checks, so the construction must be deterministic:\n *\n * - Every EAGER free identifier must be a zod-package binding. Anything\n *   else (other imports: `getLimit()`, globals: `new Date()`,\n *   `Math.random()`) could evaluate differently at build time vs module\n *   load — those schemas stay plainly hoisted.\n * - DEFERRED references (inside refine/transform/default callbacks) are\n *   unrestricted: callbacks reach generated code via fn.toString() or stay\n *   on the runtime-constructed schema (`__rf` delegation), never via their\n *   build-time closure values. If extraction itself needs a deferred value\n *   it cannot have (z.lazy(() => ImportedChild)), evaluation throws and the\n *   schema falls back to a plain hoist.\n *\n * Every failure path is graceful: the declaration keeps its original zod\n * expression and runtime behavior is unchanged.\n */\n\nimport type { CodegenMode } from \"../core/codegen/context.js\";\nimport { generateValidator } from \"../core/codegen/index.js\";\nimport { extractSchema, type RefEntry } from \"../core/extract/index.js\";\nimport type { CompiledSchemaInfo } from \"../core/pipeline.js\";\nimport { isZodSchema } from \"../is-zod-schema.js\";\nimport { loadModule } from \"../loader.js\";\nimport {\n  analyzeHoistedExpression,\n  collectImportBindings,\n  type HoistedSchema,\n  type ImportDetail,\n} from \"./hoist.js\";\n\n/** A hoisted declaration whose initializer can be replaced with a compiled IIFE. */\nexport interface CompiledHoistedSchema {\n  /** The `_zh_*` declaration name. */\n  name: string;\n  /** Original construction expression text (becomes the IIFE's schema expression). */\n  text: string;\n  /** Compiled validator for the schema. */\n  info: CompiledSchemaInfo;\n}\n\n/**\n * Evaluate a hoisted expression with its zod bindings and compile it.\n * Returns null when the schema is ineligible or anything fails.\n */\nasync function compileOne(\n  schema: HoistedSchema,\n  importDetails: Map<string, ImportDetail>,\n  id: string,\n  mode: CodegenMode,\n  moduleCache: Map<string, Promise<Record<string, unknown>>>,\n): Promise<CompiledHoistedSchema | null> {\n  const analysis = analyzeHoistedExpression(schema.text);\n  if (analysis === null) return null;\n\n  // Determinism gate: eager evaluation may only touch zod bindings.\n  const free = new Set([...analysis.eagerFree, ...analysis.deferredFree]);\n  const bindings: Array<{ name: string; detail: ImportDetail }> = [];\n  for (const name of analysis.eagerFree) {\n    const detail = importDetails.get(name);\n    if (!detail || !isZodSpecifier(detail.specifier)) return null;\n  }\n  // Inject every free import binding we can resolve (eager ones are all zod\n  // by the gate above; deferred ones are best-effort — extraction only\n  // dereferences them for build-time-invoked callbacks like z.lazy getters).\n  for (const name of free) {\n    const detail = importDetails.get(name);\n    if (detail && isZodSpecifier(detail.specifier)) {\n      bindings.push({ name, detail });\n    } else if (analysis.eagerFree.has(name)) {\n      return null;\n    }\n    // deferred non-zod names stay unbound: the evaluated closure would throw\n    // if invoked at build time, which the try/catch below converts to a skip.\n  }\n\n  try {\n    const values = await Promise.all(\n      bindings.map(async ({ detail }) => {\n        let loading = moduleCache.get(detail.specifier);\n        if (!loading) {\n          loading = loadModule(detail.specifier, id);\n          moduleCache.set(detail.specifier, loading);\n        }\n        const mod = await loading;\n        return detail.imported === \"*\" ? mod : mod[detail.imported];\n      }),\n    );\n\n    const evaluate = new Function(\n      ...bindings.map((b) => b.name),\n      `\"use strict\"; return (${schema.text});`,\n    );\n    const value: unknown = evaluate(...values);\n    if (!isZodSchema(value)) return null;\n\n    const refEntries: RefEntry[] = [];\n    const ir = extractSchema(value, refEntries);\n    // A root fallback compiles to a pure delegation wrapper — strictly worse\n    // than leaving the plain hoisted construction in place.\n    if (ir.type === \"fallback\") return null;\n\n    const codegenResult = generateValidator(ir, schema.name, { mode });\n    return {\n      name: schema.name,\n      text: schema.text,\n      info: { exportName: schema.name, codegenResult, refEntries },\n    };\n  } catch {\n    return null;\n  }\n}\n\nfunction isZodSpecifier(specifier: string): boolean {\n  return (\n    specifier === \"zod\" ||\n    specifier === \"zod/v4\" ||\n    specifier === \"zod/mini\" ||\n    specifier === \"zod/v4/mini\" ||\n    specifier === \"zod/v4-mini\"\n  );\n}\n\n/**\n * Compile every eligible hoisted schema. Failures are silent per schema —\n * the caller leaves ineligible declarations as plain hoists.\n */\nexport async function compileHoistedSchemas(\n  schemas: readonly HoistedSchema[],\n  code: string,\n  id: string,\n  mode: CodegenMode,\n): Promise<CompiledHoistedSchema[]> {\n  const { details } = collectImportBindings(code);\n  const moduleCache = new Map<string, Promise<Record<string, unknown>>>();\n  const compiled: CompiledHoistedSchema[] = [];\n  for (const schema of schemas) {\n    const result = await compileOne(schema, details, id, mode, moduleCache);\n    if (result !== null) compiled.push(result);\n  }\n  return compiled;\n}\n"],"mappings":";;;;;;;;;;AA2DA,eAAe,WACb,QACA,eACA,IACA,MACA,aACuC;CACvC,MAAM,WAAW,yBAAyB,OAAO,IAAI;CACrD,IAAI,aAAa,MAAM,OAAO;CAG9B,MAAM,uBAAO,IAAI,IAAI,CAAC,GAAG,SAAS,WAAW,GAAG,SAAS,YAAY,CAAC;CACtE,MAAM,WAA0D,CAAC;CACjE,KAAK,MAAM,QAAQ,SAAS,WAAW;EACrC,MAAM,SAAS,cAAc,IAAI,IAAI;EACrC,IAAI,CAAC,UAAU,CAAC,eAAe,OAAO,SAAS,GAAG,OAAO;CAC3D;CAIA,KAAK,MAAM,QAAQ,MAAM;EACvB,MAAM,SAAS,cAAc,IAAI,IAAI;EACrC,IAAI,UAAU,eAAe,OAAO,SAAS,GAC3C,SAAS,KAAK;GAAE;GAAM;EAAO,CAAC;OACzB,IAAI,SAAS,UAAU,IAAI,IAAI,GACpC,OAAO;CAIX;CAEA,IAAI;EACF,MAAM,SAAS,MAAM,QAAQ,IAC3B,SAAS,IAAI,OAAO,EAAE,aAAa;GACjC,IAAI,UAAU,YAAY,IAAI,OAAO,SAAS;GAC9C,IAAI,CAAC,SAAS;IACZ,UAAU,WAAW,OAAO,WAAW,EAAE;IACzC,YAAY,IAAI,OAAO,WAAW,OAAO;GAC3C;GACA,MAAM,MAAM,MAAM;GAClB,OAAO,OAAO,aAAa,MAAM,MAAM,IAAI,OAAO;EACpD,CAAC,CACH;EAMA,MAAM,QAAiB,IAJF,SACnB,GAAG,SAAS,KAAK,MAAM,EAAE,IAAI,GAC7B,yBAAyB,OAAO,KAAK,GAET,CAAC,CAAC,GAAG,MAAM;EACzC,IAAI,CAAC,YAAY,KAAK,GAAG,OAAO;EAEhC,MAAM,aAAyB,CAAC;EAChC,MAAM,KAAK,cAAc,OAAO,UAAU;EAG1C,IAAI,GAAG,SAAS,YAAY,OAAO;EAEnC,MAAM,gBAAgB,kBAAkB,IAAI,OAAO,MAAM,EAAE,KAAK,CAAC;EACjE,OAAO;GACL,MAAM,OAAO;GACb,MAAM,OAAO;GACb,MAAM;IAAE,YAAY,OAAO;IAAM;IAAe;GAAW;EAC7D;CACF,QAAQ;EACN,OAAO;CACT;AACF;AAEA,SAAS,eAAe,WAA4B;CAClD,OACE,cAAc,SACd,cAAc,YACd,cAAc,cACd,cAAc,iBACd,cAAc;AAElB;;;;;AAMA,eAAsB,sBACpB,SACA,MACA,IACA,MACkC;CAClC,MAAM,EAAE,YAAY,sBAAsB,IAAI;CAC9C,MAAM,8BAAc,IAAI,IAA8C;CACtE,MAAM,WAAoC,CAAC;CAC3C,KAAK,MAAM,UAAU,SAAS;EAC5B,MAAM,SAAS,MAAM,WAAW,QAAQ,SAAS,IAAI,MAAM,WAAW;EACtE,IAAI,WAAW,MAAM,SAAS,KAAK,MAAM;CAC3C;CACA,OAAO;AACT"}