zod-compiler 1.23.0 → 1.23.2

package/dist/jit.js

@@ -1,245 +1,216 @@
-/**
- * Runtime compilation — the same extract → codegen pipeline the build plugin
- * runs, executed in-process and evaluated through `new Function`.
- *
- * The AOT paths (unplugin, CLI) need a build step to fire. Plenty of everyday
- * code has none: `tsx server.ts`, `node --experimental-strip-types`, a Jest
- * suite, a serverless handler bundled by someone else's toolchain, a library
- * that ships schemas to consumers. There `compile()` is a no-op and every parse
- * runs plain Zod. `jit()` closes that gap — one call, no build integration,
- * measured 3-25x on everyday schemas at ~0.1-0.2 ms of one-time compilation.
- *
- * Nothing here re-implements validation: {@link compileSchemas} and
- * {@link generateIIFE} are the exact modules the plugin and CLI use, so the
- * generated validator, its Zod parity and its performance are identical to what
- * a build would have emitted. The only difference is *when* the code is
- * produced.
- *
- * Compilation is LAZY by default: `jit()` installs accessors that compile on
- * the first read of a parse method and replace themselves with the compiled
- * ones. Importing a module of 500 schemas therefore costs nothing, and a
- * serverless invocation touching three of them pays for three.
- *
- * Runtime code generation is not always permitted — a strict CSP without
- * `unsafe-eval`, some edge runtimes. Zod v4 has the same constraint (its object
- * fast-pass is itself a `new Function`) and already exposes the two switches
- * for it: the `core.util.allowsEval` probe and `z.config({ jitless: true })`.
- * `jit()` honours both and degrades to plain Zod, so one setting governs both
- * compilers. Those targets are where the build plugin belongs anyway — it emits
- * the same validator with no runtime evaluation at all.
- */
-import { config as zodConfig, core as zodCore, ZodRealError } from "zod";
-import { FAIL_CLASS_DECL, FAILZ_CLASS_DECL, FIN_DECL, FIN_DEFERRED_DECL, FINZ_DECL, generateIIFE, MK_VALIDATOR_DECL, ZOD_MSG_DECLARATION, } from "./core/iife.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";
+//#region src/jit.ts
+/**
+* Runtime compilation — the same extract → codegen pipeline the build plugin
+* runs, executed in-process and evaluated through `new Function`.
+*
+* The AOT paths (unplugin, CLI) need a build step to fire. Plenty of everyday
+* code has none: `tsx server.ts`, `node --experimental-strip-types`, a Jest
+* suite, a serverless handler bundled by someone else's toolchain, a library
+* that ships schemas to consumers. There `compile()` is a no-op and every parse
+* runs plain Zod. `jit()` closes that gap — one call, no build integration,
+* measured 3-25x on everyday schemas at ~0.1-0.2 ms of one-time compilation.
+*
+* Nothing here re-implements validation: {@link compileSchemas} and
+* {@link generateIIFE} are the exact modules the plugin and CLI use, so the
+* generated validator, its Zod parity and its performance are identical to what
+* a build would have emitted. The only difference is *when* the code is
+* produced.
+*
+* Compilation is LAZY by default: `jit()` installs accessors that compile on
+* the first read of a parse method and replace themselves with the compiled
+* ones. Importing a module of 500 schemas therefore costs nothing, and a
+* serverless invocation touching three of them pays for three.
+*
+* Runtime code generation is not always permitted — a strict CSP without
+* `unsafe-eval`, some edge runtimes. Zod v4 has the same constraint (its object
+* fast-pass is itself a `new Function`) and already exposes the two switches
+* for it: the `core.util.allowsEval` probe and `z.config({ jitless: true })`.
+* `jit()` honours both and degrades to plain Zod, so one setting governs both
+* compilers. Those targets are where the build plugin belongs anyway — it emits
+* the same validator with no runtime evaluation at all.
+*/
 /**
- * The declarations `ZOD_CONFIG_IMPORT` supplies to an emitted module, minus the
- * import itself — `zod`'s three bindings arrive as parameters instead, so the
- * evaluated code has no module scope to resolve. Byte-for-byte the same helper
- * source the CLI emitter writes into a `.compiled.ts`, so a JIT validator and
- * an AOT one share their entire runtime layer.
- */
+* The declarations `ZOD_CONFIG_IMPORT` supplies to an emitted module, minus the
+* import itself — `zod`'s three bindings arrive as parameters instead, so the
+* evaluated code has no module scope to resolve. Byte-for-byte the same helper
+* source the CLI emitter writes into a `.compiled.ts`, so a JIT validator and
+* an AOT one share their entire runtime layer.
+*/
 const RUNTIME_PRELUDE = [
-    ZOD_MSG_DECLARATION,
-    FAIL_CLASS_DECL,
-    MK_VALIDATOR_DECL,
-    FIN_DECL,
-    FIN_DEFERRED_DECL,
-    FAILZ_CLASS_DECL,
-    FINZ_DECL,
+	ZOD_MSG_DECLARATION,
+	FAIL_CLASS_DECL,
+	MK_VALIDATOR_DECL,
+	FIN_DECL,
+	FIN_DEFERRED_DECL,
+	FAILZ_CLASS_DECL,
+	FINZ_DECL
 ].join("\n");
 /**
- * Methods `__zcMkv` installs. Each is fronted by a compile-on-read accessor
- * until the schema materializes.
- *
- * `~standard` earns its place: Zod builds it as a closure over `_zod.run`, not
- * over the schema's `safeParse` property, so a Standard Schema consumer (tRPC,
- * Hono, TanStack Form) that never touches `safeParse` would otherwise keep
- * running plain Zod forever behind a "compiled" schema.
- */
-const SLOTS = ["parse", "safeParse", "parseAsync", "safeParseAsync", "is", "~standard"];
+* Methods `__zcMkv` installs. Each is fronted by a compile-on-read accessor
+* until the schema materializes.
+*
+* `~standard` earns its place: Zod builds it as a closure over `_zod.run`, not
+* over the schema's `safeParse` property, so a Standard Schema consumer (tRPC,
+* Hono, TanStack Form) that never touches `safeParse` would otherwise keep
+* running plain Zod forever behind a "compiled" schema.
+*/
+const SLOTS = [
+	"parse",
+	"safeParse",
+	"parseAsync",
+	"safeParseAsync",
+	"is",
+	"~standard"
+];
 /** Schemas already handed to `jit()`, so a second call is a no-op rather than a recompile. */
-const seen = new WeakSet();
+const seen = /* @__PURE__ */ new WeakSet();
 /**
- * Compile `schema` in-process and install the compiled `parse` / `safeParse` /
- * `parseAsync` / `safeParseAsync` / `is` / `~standard` on it.
- *
- * Returns the SAME object — identity-preserving exactly as the build plugin is,
- * so `.shape`, `_zod`, `instanceof`, `z.toJSONSchema()`, `.meta()` and
- * composition into a larger schema all keep working, and every existing
- * reference to the schema picks the compiled methods up.
- *
- * ```ts
- * import { z } from "zod";
- * import { jit } from "zod-compiler/jit";
- *
- * export const UserSchema = jit(z.object({ name: z.string(), email: z.email() }));
- * UserSchema.safeParse(input); // compiled on this first call
- * ```
- *
- * Schemas the compiler cannot reproduce fall back to Zod per sub-schema, the
- * same way they do at build time; a schema that cannot be compiled at all is
- * left as plain Zod.
- */
-export function jit(schema, options) {
-    const target = schema;
-    if (seen.has(target))
-        return schema;
-    seen.add(target);
-    if (options?.eager === true) {
-        materialize(schema);
-        return schema;
-    }
-    // Snapshot Zod's own descriptors first: materialize() restores them before
-    // handing the object to `__zcMkv`, so the generated code sees a pristine
-    // schema — it captures `~standard`'s original `validate` as its throw path,
-    // and capturing a stub there would loop back into itself.
-    const original = new Map();
-    for (const slot of SLOTS) {
-        original.set(slot, Object.getOwnPropertyDescriptor(target, slot));
-    }
-    // Installing the accessors is the one step that can throw rather than degrade:
-    // a slot locked non-configurable (a future Zod, another wrapper) makes
-    // defineProperty raise, and `jit()` is called at module scope — so an
-    // unhandled throw here takes down the importing app at boot. Roll back to
-    // whatever Zod had and leave the schema alone instead.
-    let pending = true;
-    try {
-        installAccessors(target, original, () => {
-            if (!pending)
-                return;
-            pending = false;
-            restore(target, original);
-            materialize(schema);
-        }, () => {
-            if (!pending)
-                return;
-            pending = false;
-            // Restore EVERY slot, not just the one being written. A left-behind
-            // accessor whose trigger has been cancelled would read `target[slot]`
-            // and re-enter itself — unbounded recursion. This is the path the build
-            // plugin takes when a file uses `jit()` too: `__zcMkv` assigns the parse
-            // methods (cancelling here) and then reads `~standard`.
-            restore(target, original);
-        });
-    }
-    catch {
-        pending = false;
-        restore(target, original);
-    }
-    return schema;
+* Compile `schema` in-process and install the compiled `parse` / `safeParse` /
+* `parseAsync` / `safeParseAsync` / `is` / `~standard` on it.
+*
+* Returns the SAME object — identity-preserving exactly as the build plugin is,
+* so `.shape`, `_zod`, `instanceof`, `z.toJSONSchema()`, `.meta()` and
+* composition into a larger schema all keep working, and every existing
+* reference to the schema picks the compiled methods up.
+*
+* ```ts
+* import { z } from "zod";
+* import { jit } from "zod-compiler/jit";
+*
+* export const UserSchema = jit(z.object({ name: z.string(), email: z.email() }));
+* UserSchema.safeParse(input); // compiled on this first call
+* ```
+*
+* Schemas the compiler cannot reproduce fall back to Zod per sub-schema, the
+* same way they do at build time; a schema that cannot be compiled at all is
+* left as plain Zod.
+*/
+function jit(schema, options) {
+	const target = schema;
+	if (seen.has(target)) return schema;
+	seen.add(target);
+	if (options?.eager === true) {
+		materialize(schema);
+		return schema;
+	}
+	const original = /* @__PURE__ */ new Map();
+	for (const slot of SLOTS) original.set(slot, Object.getOwnPropertyDescriptor(target, slot));
+	let pending = true;
+	try {
+		installAccessors(target, original, () => {
+			if (!pending) return;
+			pending = false;
+			restore(target, original);
+			materialize(schema);
+		}, () => {
+			if (!pending) return;
+			pending = false;
+			restore(target, original);
+		});
+	} catch {
+		pending = false;
+		restore(target, original);
+	}
+	return schema;
 }
 /**
- * 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.
- */
+* 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.
+*/
 function installAccessors(target, original, trigger, cancel) {
-    for (const slot of SLOTS) {
-        Object.defineProperty(target, slot, {
-            configurable: true,
-            // Preserve Zod's own visibility: parse/safeParse/... are enumerable own
-            // properties, `~standard` is not. `is` does not exist on a Zod schema, so
-            // it follows the non-enumerable convention `compile()` already uses.
-            enumerable: original.get(slot)?.enumerable ?? false,
-            get() {
-                trigger();
-                // Whatever now occupies the slot: the compiled method, or — if
-                // compilation was impossible — Zod's own, put back by restore().
-                return target[slot];
-            },
-            set(value) {
-                // Someone overwrote a method before first use (a test double, another
-                // wrapper). Their value wins, and compilation is cancelled outright —
-                // materializing later would restore Zod's descriptors over it.
-                cancel();
-                Object.defineProperty(target, slot, {
-                    configurable: true,
-                    enumerable: original.get(slot)?.enumerable ?? false,
-                    value,
-                    writable: true,
-                });
-            },
-        });
-    }
+	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
+			});
+		}
+	});
 }
 /**
- * Compile every Zod schema found among an object's own values — typically a
- * module namespace, so a whole schema file opts in with one call:
- *
- * ```ts
- * import * as schemas from "./schemas.js";
- * jitAll(schemas);
- * ```
- *
- * The namespace object itself is never written to (a module namespace is
- * read-only); `jit()` mutates the schema objects it holds, which is what every
- * importer of that module already references.
- */
-export function jitAll(schemas, options) {
-    for (const value of Object.values(schemas)) {
-        if (isZodSchema(value))
-            jit(value, options);
-    }
+* Compile every Zod schema found among an object's own values — typically a
+* module namespace, so a whole schema file opts in with one call:
+*
+* ```ts
+* import * as schemas from "./schemas.js";
+* jitAll(schemas);
+* ```
+*
+* The namespace object itself is never written to (a module namespace is
+* read-only); `jit()` mutates the schema objects it holds, which is what every
+* importer of that module already references.
+*/
+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;
+	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) {
-        const descriptor = original.get(slot);
-        if (descriptor === undefined)
-            delete target[slot];
-        else
-            Object.defineProperty(target, slot, descriptor);
-    }
+	for (const slot of SLOTS) {
+		const descriptor = original.get(slot);
+		if (descriptor === void 0) delete target[slot];
+		else Object.defineProperty(target, slot, descriptor);
+	}
 }
 /**
- * Whether runtime code generation is permitted here. Read per call, never
- * snapshotted: `z.config({ jitless: true })` runs in an entry point, after the
- * schema modules it imports have already been evaluated.
- */
+* Whether runtime code generation is permitted here. Read per call, never
+* snapshotted: `z.config({ jitless: true })` runs in an entry point, after the
+* schema modules it imports have already been evaluated.
+*/
 function codegenAllowed() {
-    return zodCore.globalConfig.jitless !== true && zodCore.util.allowsEval.value;
+	return core.globalConfig.jitless !== true && core.util.allowsEval.value;
 }
 /**
- * Run the pipeline and let the generated IIFE install its methods on `schema`.
- * Swallows failure: a schema that cannot be compiled keeps Zod's own methods,
- * which the caller already has, so there is nothing to report and nothing to
- * break.
- */
+* Run the pipeline and let the generated IIFE install its methods on `schema`.
+* Swallows failure: a schema that cannot be compiled keeps Zod's own methods,
+* which the caller already has, so there is nothing to report and nothing to
+* break.
+*/
 function materialize(schema) {
-    if (!codegenAllowed())
-        return;
-    try {
-        buildValidator(schema);
-    }
-    catch {
-        // Left as plain Zod. Deliberately silent: `jit()` is an optimization, and a
-        // schema using a construct the compiler declines is a supported outcome,
-        // not an error.
-    }
+	if (!codegenAllowed()) return;
+	try {
+		buildValidator(schema);
+	} catch {}
 }
 /**
- * Generate the validator and evaluate it, reproducing the module a
- * `.compiled.ts` would have been: helper preamble, the file-level shared block,
- * then the `__zcMkv` IIFE whose `__rf[]` bases and install target are the live
- * schema object passed in as `__schema`.
- */
+* Generate the validator and evaluate it, reproducing the module a
+* `.compiled.ts` would have been: helper preamble, the file-level shared block,
+* then the `__zcMkv` IIFE whose `__rf[]` bases and install target are the live
+* schema object passed in as `__schema`.
+*/
 function buildValidator(schema) {
-    const { schemas, shared } = compileSchemas([{ exportName: "jit", schema }], { mode: "inline" });
-    const compiled = schemas[0];
-    if (compiled === undefined)
-        throw new Error("zod-compiler: schema produced no validator");
-    const body = [RUNTIME_PRELUDE, shared.code, `return ${generateIIFE("__schema", compiled)};`].join("\n");
-    // The three bindings ZOD_CONFIG_IMPORT would have imported, passed in so the
-    // evaluated code needs no module resolution of its own.
-    // oxlint-disable-next-line no-new-func -- generating the validator IS the feature
-    const factory = new Function("__zodCompilerConfig", "__zcCore", "__zcZodError", "__schema", body);
-    factory(zodConfig, zodCore, ZodRealError, schema);
+	const { schemas, shared } = compileSchemas([{
+		exportName: "jit",
+		schema
+	}], { mode: "inline" });
+	const compiled = schemas[0];
+	if (compiled === void 0) throw new Error("zod-compiler: schema produced no validator");
+	const body = [
+		RUNTIME_PRELUDE,
+		shared.code,
+		`return ${generateIIFE("__schema", compiled)};`
+	].join("\n");
+	new Function("__zodCompilerConfig", "__zcCore", "__zcZodError", "__schema", body)(config, core, ZodRealError, schema);
 }
+//#endregion
+export { jit, jitAll };
+
 //# sourceMappingURL=jit.js.map

package/dist/jit.js.map

@@ -1 +1 @@
-{"version":3,"file":"jit.js","sourceRoot":"","sources":["../src/jit.ts"],"names":[],"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\";\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 `~standard`'s original `validate` as its throw path,\n  // 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. This is the path the build\n        // plugin takes when a file uses `jit()` too: `__zcMkv` assigns the parse\n        // methods (cancelling here) and then reads `~standard`.\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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"}

package/dist/loader.d.ts

@@ -1,3 +1,4 @@
+//#region src/loader.d.ts
 /**
  * Candidate files for a specifier using the tsconfig path mappings visible
  * from a directory. Used by the static dependency crawler so alias imports
@@ -15,9 +16,9 @@
  *   and `#` subpath imports included) and expects the caller to fall back
  *   to node resolution when the candidate does not exist.
  */
-export declare function resolveTsconfigPathCandidates(fromDir: string, specifier: string): {
-    candidates: string[];
-    authoritative: boolean;
+declare function resolveTsconfigPathCandidates(fromDir: string, specifier: string): {
+  candidates: string[];
+  authoritative: boolean;
 };
 /**
  * Thrown in place of a `process.exit()` call made while a build-time module is
@@ -25,10 +26,10 @@ export declare function resolveTsconfigPathCandidates(fromDir: string, specifier
  * and skips the file (falling back to runtime Zod), so a non-cooperating
  * module's exit degrades gracefully instead of terminating the bundler.
  */
-export declare class ProcessExitDuringLoadError extends Error {
-    /** The code passed to the intercepted `process.exit()`, if any. */
-    readonly exitCode: number | string | undefined;
-    constructor(code?: number | string);
+declare class ProcessExitDuringLoadError extends Error {
+  /** The code passed to the intercepted `process.exit()`, if any. */
+  readonly exitCode: number | string | undefined;
+  constructor(code?: number | string);
 }
 /**
  * Drop every first-party (non-node_modules) module from the shared loader
@@ -42,7 +43,7 @@ export declare class ProcessExitDuringLoadError extends Error {
  * keeping node_modules (the expensive bulk — zod itself) warm is both correct
  * and fast.
  */
-export declare function invalidateModuleCache(): void;
+declare function invalidateModuleCache(): void;
 /**
  * Absolute paths of every first-party (non-node_modules) module currently
  * executed by the shared loader. Used by the unplugin disk cache to record
@@ -52,7 +53,7 @@ export declare function invalidateModuleCache(): void;
  * Returns null when no jiti instance exists (Bun/Deno native import — no
  * evictable cache, so dependency tracking is unavailable).
  */
-export declare function getFirstPartyModulePaths(): string[] | null;
+declare function getFirstPartyModulePaths(): string[] | null;
 /**
  * Dynamically import a source file (.ts or .js).
  * - Bun/Deno: native TypeScript support, direct import
@@ -62,7 +63,7 @@ export declare function getFirstPartyModulePaths(): string[] | null;
  * Module executions are cached across calls; use invalidateModuleCache()
  * when source files change (watch/HMR).
  */
-export declare function loadSourceFile(filePath: string): Promise<Record<string, unknown>>;
+declare function loadSourceFile(filePath: string): Promise<Record<string, unknown>>;
 /**
  * Import a module by SPECIFIER as `fromFile` would: relative specifiers
  * resolve against the importing file's directory; bare specifiers (`zod`)
@@ -70,5 +71,7 @@ export declare function loadSourceFile(filePath: string): Promise<Record<string,
  * the same module instance discovery executions see. Used by the hoisted-
  * schema compile step to evaluate hoisted expressions at build time.
  */
-export declare function loadModule(specifier: string, fromFile: string): Promise<Record<string, unknown>>;
+declare function loadModule(specifier: string, fromFile: string): Promise<Record<string, unknown>>;
+//#endregion
+export { ProcessExitDuringLoadError, getFirstPartyModulePaths, invalidateModuleCache, loadModule, loadSourceFile, resolveTsconfigPathCandidates };
 //# sourceMappingURL=loader.d.ts.map

package/dist/loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../src/loader.ts"],"names":[],"mappings":"AAoFA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,GAChB;IAAE,UAAU,EAAE,MAAM,EAAE,CAAC;IAAC,aAAa,EAAE,OAAO,CAAA;CAAE,CAoBlD;AAoCD;;;;;GAKG;AACH,qBAAa,0BAA2B,SAAQ,KAAK;IACnD,mEAAmE;IACnE,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;gBAEnC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM;CAQnC;AA0DD;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAS5C;AAED;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,EAAE,GAAG,IAAI,CAW1D;AAiBD;;;;;;;;GAQG;AACH,wBAAsB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAsBvF;AAED;;;;;;GAMG;AACH,wBAAsB,UAAU,CAC9B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAkBlC"}
+{"version":3,"file":"loader.d.ts","names":[],"sources":["../src/loader.ts"],"mappings":";;;;;;;;;;;;;;;;;;iBAqGgB,8BACd,iBACA;EACG;EAAsB;;;;;;;;cA8Dd,mCAAmC;;WAErC;EAEG,YAAA;;;;;;;;;;;;;;iBA8EE;;;;;;;;;;iBAoBA;;;;;;;;;;iBAqCM,eAAe,mBAAmB,QAAQ;;;;;;;;iBA+B1C,WACpB,mBACA,mBACC,QAAQ"}