zod-compiler 1.23.0 → 1.23.2

package/dist/core/extract/registry.js

@@ -32,134 +32,107 @@ import { extractUnion } from "./extractors/union.js";
 import { extractUnknown } from "./extractors/unknown.js";
 import { extractVoid } from "./extractors/void.js";
 import { makeFallback } from "./fallback.js";
-// ─── Typed registry ─────────────────────────────────────────────────────────
-// Adding a new SupportedZodDefType without registering an extractor here causes
-// a compile error, preventing silent-missing-case bugs.
-//
-// Note: SupportedZodDefType covers Zod's def.type values, not SchemaIR types.
-// SchemaIR types like discriminatedUnion, recursiveRef, effect, and fallback are
-// produced by extractors (e.g. union emits discriminatedUnion, lazy emits
-// recursiveRef) but have no corresponding Zod def.type.
-export const extractRegistry = {
-    // Primitives (order follows SupportedZodDefType union in types.ts)
-    boolean: extractBoolean,
-    null: extractNull,
-    undefined: extractUndefined,
-    any: extractAny,
-    unknown: extractUnknown,
-    symbol: extractSymbol,
-    void: extractVoid,
-    nan: extractNan,
-    never: extractNever,
-    literal: extractLiteral,
-    enum: extractEnum,
-    optional: extractOptional,
-    nullable: extractNullable,
-    readonly: extractReadonly,
-    intersection: extractIntersection,
-    // Complex extractors
-    string: extractString,
-    number: extractNumber,
-    bigint: extractBigint,
-    date: extractDate,
-    object: extractObject,
-    array: extractArray,
-    tuple: extractTuple,
-    record: extractRecord,
-    set: extractSet,
-    map: extractMap,
-    union: extractUnion,
-    default: extractDefault,
-    pipe: extractPipe,
-    lazy: extractLazy,
-    catch: extractCatch,
-    template_literal: extractTemplateLiteral,
-    file: extractFile,
+//#region src/core/extract/registry.ts
+const extractRegistry = {
+	boolean: extractBoolean,
+	null: extractNull,
+	undefined: extractUndefined,
+	any: extractAny,
+	unknown: extractUnknown,
+	symbol: extractSymbol,
+	void: extractVoid,
+	nan: extractNan,
+	never: extractNever,
+	literal: extractLiteral,
+	enum: extractEnum,
+	optional: extractOptional,
+	nullable: extractNullable,
+	readonly: extractReadonly,
+	intersection: extractIntersection,
+	string: extractString,
+	number: extractNumber,
+	bigint: extractBigint,
+	date: extractDate,
+	object: extractObject,
+	array: extractArray,
+	tuple: extractTuple,
+	record: extractRecord,
+	set: extractSet,
+	map: extractMap,
+	union: extractUnion,
+	default: extractDefault,
+	pipe: extractPipe,
+	lazy: extractLazy,
+	catch: extractCatch,
+	template_literal: extractTemplateLiteral,
+	file: extractFile
 };
-// ─── Factory ────────────────────────────────────────────────────────────────
-// Lives here (not in types.ts) to avoid circular imports:
-// visit() → dispatch() → imports from types.ts
 function createExtractorContext(schema, path, refs, visiting, recursion) {
-    return {
-        schema,
-        path,
-        refs,
-        visiting,
-        recursion,
-        visit(childSchema, pathSuffix) {
-            const childPath = pathSuffix ? `${path}${pathSuffix}` : path;
-            return dispatch(childSchema, childPath, refs, visiting, recursion);
-        },
-        fallback(reason) {
-            return makeFallback(reason, schema, refs, path);
-        },
-    };
+	return {
+		schema,
+		path,
+		refs,
+		visiting,
+		recursion,
+		visit(childSchema, pathSuffix) {
+			return dispatch(childSchema, pathSuffix ? `${path}${pathSuffix}` : path, refs, visiting, recursion);
+		},
+		fallback(reason) {
+			return makeFallback(reason, schema, refs, path);
+		}
+	};
 }
-// ─── Dispatch ───────────────────────────────────────────────────────────────
 /**
- * def.type values whose extractors consume `def.checks`. In Zod v4, `.refine()`
- * (and `.check()`) appends to the checks array of WHATEVER schema type it is
- * called on — z.string().nullable().refine(...) puts the check on the nullable.
- * For every other type, checks present on the def would be silently dropped by
- * extraction, so dispatch() forces a Zod fallback instead (validation hole
- * otherwise: compiled output accepts input Zod rejects).
- */
-const CHECKS_AWARE_TYPES = new Set([
-    "string",
-    "number",
-    "bigint",
-    "date",
-    "object",
-    "array",
-    "set",
-    "file",
+* def.type values whose extractors consume `def.checks`. In Zod v4, `.refine()`
+* (and `.check()`) appends to the checks array of WHATEVER schema type it is
+* called on — z.string().nullable().refine(...) puts the check on the nullable.
+* For every other type, checks present on the def would be silently dropped by
+* extraction, so dispatch() forces a Zod fallback instead (validation hole
+* otherwise: compiled output accepts input Zod rejects).
+*/
+const CHECKS_AWARE_TYPES = /* @__PURE__ */ new Set([
+	"string",
+	"number",
+	"bigint",
+	"date",
+	"object",
+	"array",
+	"set",
+	"file"
 ]);
 /**
- * Central dispatch — replaces extractSchemaInner().
- * visit() and dispatch() form a mutually recursive pair, both in this file.
- */
-export function dispatch(zodSchema, path, refs, visiting, recursion) {
-    const schema = zodSchema;
-    const def = schema._zod.def;
-    visiting.add(zodSchema);
-    try {
-        const extractor = extractRegistry[def.type];
-        const ctx = createExtractorContext(zodSchema, path, refs, visiting, recursion);
-        let ir = extractor ? extractor(def, ctx) : makeFallback("unsupported", zodSchema, refs, path);
-        if (ir.type === "fallback")
-            return ir;
-        // Safety net: checks attached to a type whose extractor ignores them.
-        if (def.checks && def.checks.length > 0 && !CHECKS_AWARE_TYPES.has(def.type)) {
-            return makeFallback("refine", zodSchema, refs, path);
-        }
-        // Schema-level custom error (z.string({ error: "..." })): bake static
-        // messages as the node's default issue message; dynamic error maps can't
-        // be compiled — delegate to Zod so messages stay exact.
-        if (def.error !== undefined) {
-            const resolved = resolveCheckMessage(def.error);
-            if (resolved.kind === "dynamic") {
-                return makeFallback("refine", zodSchema, refs, path);
-            }
-            if (resolved.kind === "static") {
-                ir = { ...ir, typeMessage: resolved.message };
-            }
-        }
-        // This schema is the target of a non-root recursive cycle (a `recursiveRef`
-        // with refId ≥ 1 was emitted for it deeper in the walk): wrap its IR as the
-        // OUTERMOST transformation so codegen hosts it as a standalone validator.
-        // Done last — after the fallback post-processing above — so a target that
-        // delegates to Zod returns its fallback leaf, discarding the whole subtree
-        // (including the inner `recursiveRef`) instead of leaving a dangling ref.
-        // The root target (refId 0) is the schema's own function and is never
-        // wrapped.
-        const refId = recursion.targets.get(zodSchema);
-        if (refId !== undefined) {
-            return { type: "recursionTarget", refId, inner: ir };
-        }
-        return ir;
-    }
-    finally {
-        visiting.delete(zodSchema);
-    }
+* Central dispatch — replaces extractSchemaInner().
+* visit() and dispatch() form a mutually recursive pair, both in this file.
+*/
+function dispatch(zodSchema, path, refs, visiting, recursion) {
+	const def = zodSchema._zod.def;
+	visiting.add(zodSchema);
+	try {
+		const extractor = extractRegistry[def.type];
+		const ctx = createExtractorContext(zodSchema, path, refs, visiting, recursion);
+		let ir = extractor ? extractor(def, ctx) : makeFallback("unsupported", zodSchema, refs, path);
+		if (ir.type === "fallback") return ir;
+		if (def.checks && def.checks.length > 0 && !CHECKS_AWARE_TYPES.has(def.type)) return makeFallback("refine", zodSchema, refs, path);
+		if (def.error !== void 0) {
+			const resolved = resolveCheckMessage(def.error);
+			if (resolved.kind === "dynamic") return makeFallback("refine", zodSchema, refs, path);
+			if (resolved.kind === "static") ir = {
+				...ir,
+				typeMessage: resolved.message
+			};
+		}
+		const refId = recursion.targets.get(zodSchema);
+		if (refId !== void 0) return {
+			type: "recursionTarget",
+			refId,
+			inner: ir
+		};
+		return ir;
+	} finally {
+		visiting.delete(zodSchema);
+	}
 }
+//#endregion
+export { dispatch, extractRegistry };
+
 //# sourceMappingURL=registry.js.map

package/dist/core/extract/registry.js.map

@@ -1 +1 @@
-{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../../src/core/extract/registry.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"registry.js","names":["schema"],"sources":["../../../src/core/extract/registry.ts"],"sourcesContent":["import type { FallbackIR, SchemaIR } from \"../types.js\";\nimport { resolveCheckMessage } from \"./checks.js\";\nimport { extractAny } from \"./extractors/any.js\";\nimport { extractArray } from \"./extractors/array.js\";\nimport { extractBigint } from \"./extractors/bigint.js\";\nimport { extractBoolean } from \"./extractors/boolean.js\";\nimport { extractCatch } from \"./extractors/catch.js\";\nimport { extractDate } from \"./extractors/date.js\";\nimport { extractDefault } from \"./extractors/default.js\";\nimport { extractEnum } from \"./extractors/enum.js\";\nimport { extractFile } from \"./extractors/file.js\";\nimport { extractIntersection } from \"./extractors/intersection.js\";\nimport { extractLazy } from \"./extractors/lazy.js\";\nimport { extractLiteral } from \"./extractors/literal.js\";\nimport { extractMap } from \"./extractors/map.js\";\nimport { extractNan } from \"./extractors/nan.js\";\nimport { extractNever } from \"./extractors/never.js\";\nimport { extractNull } from \"./extractors/null.js\";\nimport { extractNullable } from \"./extractors/nullable.js\";\nimport { extractNumber } from \"./extractors/number.js\";\nimport { extractObject } from \"./extractors/object.js\";\nimport { extractOptional } from \"./extractors/optional.js\";\nimport { extractPipe } from \"./extractors/pipe.js\";\nimport { extractReadonly } from \"./extractors/readonly.js\";\nimport { extractRecord } from \"./extractors/record.js\";\nimport { extractSet } from \"./extractors/set.js\";\nimport { extractString } from \"./extractors/string.js\";\nimport { extractSymbol } from \"./extractors/symbol.js\";\nimport { extractTemplateLiteral } from \"./extractors/template-literal.js\";\nimport { extractTuple } from \"./extractors/tuple.js\";\nimport { extractUndefined } from \"./extractors/undefined.js\";\nimport { extractUnion } from \"./extractors/union.js\";\nimport { extractUnknown } from \"./extractors/unknown.js\";\nimport { extractVoid } from \"./extractors/void.js\";\nimport { makeFallback } from \"./fallback.js\";\nimport type {\n  Extractor,\n  ExtractorContext,\n  RecursionState,\n  RefEntry,\n  SupportedZodDefType,\n  ZodSchema,\n} from \"./types.js\";\n\n// ─── Typed registry ─────────────────────────────────────────────────────────\n// Adding a new SupportedZodDefType without registering an extractor here causes\n// a compile error, preventing silent-missing-case bugs.\n//\n// Note: SupportedZodDefType covers Zod's def.type values, not SchemaIR types.\n// SchemaIR types like discriminatedUnion, recursiveRef, effect, and fallback are\n// produced by extractors (e.g. union emits discriminatedUnion, lazy emits\n// recursiveRef) but have no corresponding Zod def.type.\n\nexport const extractRegistry = {\n  // Primitives (order follows SupportedZodDefType union in types.ts)\n  boolean: extractBoolean,\n  null: extractNull,\n  undefined: extractUndefined,\n  any: extractAny,\n  unknown: extractUnknown,\n  symbol: extractSymbol,\n  void: extractVoid,\n  nan: extractNan,\n  never: extractNever,\n  literal: extractLiteral,\n  enum: extractEnum,\n  optional: extractOptional,\n  nullable: extractNullable,\n  readonly: extractReadonly,\n  intersection: extractIntersection,\n  // Complex extractors\n  string: extractString,\n  number: extractNumber,\n  bigint: extractBigint,\n  date: extractDate,\n  object: extractObject,\n  array: extractArray,\n  tuple: extractTuple,\n  record: extractRecord,\n  set: extractSet,\n  map: extractMap,\n  union: extractUnion,\n  default: extractDefault,\n  pipe: extractPipe,\n  lazy: extractLazy,\n  catch: extractCatch,\n  template_literal: extractTemplateLiteral,\n  file: extractFile,\n} satisfies Record<SupportedZodDefType, Extractor>;\n\n// ─── Factory ────────────────────────────────────────────────────────────────\n// Lives here (not in types.ts) to avoid circular imports:\n// visit() → dispatch() → imports from types.ts\n\nfunction createExtractorContext(\n  schema: unknown,\n  path: string,\n  refs: RefEntry[] | undefined,\n  visiting: Set<unknown>,\n  recursion: RecursionState,\n): ExtractorContext {\n  return {\n    schema,\n    path,\n    refs,\n    visiting,\n    recursion,\n    visit(childSchema: unknown, pathSuffix?: string): SchemaIR {\n      const childPath = pathSuffix ? `${path}${pathSuffix}` : path;\n      return dispatch(childSchema, childPath, refs, visiting, recursion);\n    },\n    fallback(reason: FallbackIR[\"reason\"]) {\n      return makeFallback(reason, schema, refs, path);\n    },\n  };\n}\n\n// ─── Dispatch ───────────────────────────────────────────────────────────────\n\n/**\n * def.type values whose extractors consume `def.checks`. In Zod v4, `.refine()`\n * (and `.check()`) appends to the checks array of WHATEVER schema type it is\n * called on — z.string().nullable().refine(...) puts the check on the nullable.\n * For every other type, checks present on the def would be silently dropped by\n * extraction, so dispatch() forces a Zod fallback instead (validation hole\n * otherwise: compiled output accepts input Zod rejects).\n */\nconst CHECKS_AWARE_TYPES: ReadonlySet<string> = new Set([\n  \"string\",\n  \"number\",\n  \"bigint\",\n  \"date\",\n  \"object\",\n  \"array\",\n  \"set\",\n  \"file\",\n]);\n\n/**\n * Central dispatch — replaces extractSchemaInner().\n * visit() and dispatch() form a mutually recursive pair, both in this file.\n */\nexport function dispatch(\n  zodSchema: unknown,\n  path: string,\n  refs: RefEntry[] | undefined,\n  visiting: Set<unknown>,\n  recursion: RecursionState,\n): SchemaIR {\n  const schema = zodSchema as ZodSchema;\n  const def = schema._zod.def;\n\n  visiting.add(zodSchema);\n  try {\n    const extractor = extractRegistry[def.type as SupportedZodDefType];\n    const ctx = createExtractorContext(zodSchema, path, refs, visiting, recursion);\n    let ir = extractor ? extractor(def, ctx) : makeFallback(\"unsupported\", zodSchema, refs, path);\n    if (ir.type === \"fallback\") return ir;\n\n    // Safety net: checks attached to a type whose extractor ignores them.\n    if (def.checks && def.checks.length > 0 && !CHECKS_AWARE_TYPES.has(def.type)) {\n      return makeFallback(\"refine\", zodSchema, refs, path);\n    }\n\n    // Schema-level custom error (z.string({ error: \"...\" })): bake static\n    // messages as the node's default issue message; dynamic error maps can't\n    // be compiled — delegate to Zod so messages stay exact.\n    if (def.error !== undefined) {\n      const resolved = resolveCheckMessage(def.error);\n      if (resolved.kind === \"dynamic\") {\n        return makeFallback(\"refine\", zodSchema, refs, path);\n      }\n      if (resolved.kind === \"static\") {\n        ir = { ...ir, typeMessage: resolved.message };\n      }\n    }\n\n    // This schema is the target of a non-root recursive cycle (a `recursiveRef`\n    // with refId ≥ 1 was emitted for it deeper in the walk): wrap its IR as the\n    // OUTERMOST transformation so codegen hosts it as a standalone validator.\n    // Done last — after the fallback post-processing above — so a target that\n    // delegates to Zod returns its fallback leaf, discarding the whole subtree\n    // (including the inner `recursiveRef`) instead of leaving a dangling ref.\n    // The root target (refId 0) is the schema's own function and is never\n    // wrapped.\n    const refId = recursion.targets.get(zodSchema);\n    if (refId !== undefined) {\n      return { type: \"recursionTarget\", refId, inner: ir };\n    }\n    return ir;\n  } finally {\n    visiting.delete(zodSchema);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqDA,MAAa,kBAAkB;CAE7B,SAAS;CACT,MAAM;CACN,WAAW;CACX,KAAK;CACL,SAAS;CACT,QAAQ;CACR,MAAM;CACN,KAAK;CACL,OAAO;CACP,SAAS;CACT,MAAM;CACN,UAAU;CACV,UAAU;CACV,UAAU;CACV,cAAc;CAEd,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,MAAM;CACN,QAAQ;CACR,OAAO;CACP,OAAO;CACP,QAAQ;CACR,KAAK;CACL,KAAK;CACL,OAAO;CACP,SAAS;CACT,MAAM;CACN,MAAM;CACN,OAAO;CACP,kBAAkB;CAClB,MAAM;AACR;AAMA,SAAS,uBACP,QACA,MACA,MACA,UACA,WACkB;CAClB,OAAO;EACL;EACA;EACA;EACA;EACA;EACA,MAAM,aAAsB,YAA+B;GAEzD,OAAO,SAAS,aADE,aAAa,GAAG,OAAO,eAAe,MAChB,MAAM,UAAU,SAAS;EACnE;EACA,SAAS,QAA8B;GACrC,OAAO,aAAa,QAAQ,QAAQ,MAAM,IAAI;EAChD;CACF;AACF;;;;;;;;;AAYA,MAAM,qCAA0C,IAAI,IAAI;CACtD;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;;;;;AAMD,SAAgB,SACd,WACA,MACA,MACA,UACA,WACU;CAEV,MAAM,MAAMA,UAAO,KAAK;CAExB,SAAS,IAAI,SAAS;CACtB,IAAI;EACF,MAAM,YAAY,gBAAgB,IAAI;EACtC,MAAM,MAAM,uBAAuB,WAAW,MAAM,MAAM,UAAU,SAAS;EAC7E,IAAI,KAAK,YAAY,UAAU,KAAK,GAAG,IAAI,aAAa,eAAe,WAAW,MAAM,IAAI;EAC5F,IAAI,GAAG,SAAS,YAAY,OAAO;EAGnC,IAAI,IAAI,UAAU,IAAI,OAAO,SAAS,KAAK,CAAC,mBAAmB,IAAI,IAAI,IAAI,GACzE,OAAO,aAAa,UAAU,WAAW,MAAM,IAAI;EAMrD,IAAI,IAAI,UAAU,KAAA,GAAW;GAC3B,MAAM,WAAW,oBAAoB,IAAI,KAAK;GAC9C,IAAI,SAAS,SAAS,WACpB,OAAO,aAAa,UAAU,WAAW,MAAM,IAAI;GAErD,IAAI,SAAS,SAAS,UACpB,KAAK;IAAE,GAAG;IAAI,aAAa,SAAS;GAAQ;EAEhD;EAUA,MAAM,QAAQ,UAAU,QAAQ,IAAI,SAAS;EAC7C,IAAI,UAAU,KAAA,GACZ,OAAO;GAAE,MAAM;GAAmB;GAAO,OAAO;EAAG;EAErD,OAAO;CACT,UAAU;EACR,SAAS,OAAO,SAAS;CAC3B;AACF"}

package/dist/core/extract/types.d.ts

@@ -1,107 +1,109 @@
-export interface ZodCheckDef {
-    check: string;
-    type: string;
-    format: string;
-    pattern: RegExp | string;
-    minimum: number;
-    maximum: number;
-    length: number;
-    size: number;
-    value: number;
-    inclusive: boolean;
-    includes: string;
-    position: number;
-    prefix: string;
-    suffix: string;
-    fn: unknown;
-    /** `.refine(fn, { path })` — issue path suffix, relative to the refined value. */
-    path?: unknown;
-    /** $ZodCheckOverwrite transform function (.trim(), .toLowerCase(), ...). */
-    tx?: unknown;
-    /** Runtime predicate gating check execution — forces fallback when present. */
-    when?: unknown;
-    /** abort:true stops later checks and marks union options aborted — forces fallback. */
-    abort?: boolean;
-    mime: string[];
-    /** url-only constraints (z.httpUrl()). */
-    hostname?: RegExp;
-    protocol?: RegExp;
-    normalize?: boolean;
-    error?: unknown;
+import { FallbackIR, SchemaIR } from "../types.js";
+//#region src/core/extract/types.d.ts
+interface ZodCheckDef {
+  check: string;
+  type: string;
+  format: string;
+  pattern: RegExp | string;
+  minimum: number;
+  maximum: number;
+  length: number;
+  size: number;
+  value: number;
+  inclusive: boolean;
+  includes: string;
+  position: number;
+  prefix: string;
+  suffix: string;
+  fn: unknown;
+  /** `.refine(fn, { path })` — issue path suffix, relative to the refined value. */
+  path?: unknown;
+  /** $ZodCheckOverwrite transform function (.trim(), .toLowerCase(), ...). */
+  tx?: unknown;
+  /** Runtime predicate gating check execution — forces fallback when present. */
+  when?: unknown;
+  /** abort:true stops later checks and marks union options aborted — forces fallback. */
+  abort?: boolean;
+  mime: string[];
+  /** url-only constraints (z.httpUrl()). */
+  hostname?: RegExp;
+  protocol?: RegExp;
+  normalize?: boolean;
+  error?: unknown;
 }
-export interface ZodCheckSchema {
-    _zod?: {
-        def: ZodCheckDef;
-        /**
-         * The check's own implementation. `superRefine` (and a raw `.check(fn)`)
-         * live here rather than in `def.fn`: they take zod's payload and push
-         * issues onto it instead of returning a verdict.
-         */
-        check?: unknown;
-    };
+interface ZodCheckSchema {
+  _zod?: {
+    def: ZodCheckDef;
+    /**
+     * The check's own implementation. `superRefine` (and a raw `.check(fn)`)
+     * live here rather than in `def.fn`: they take zod's payload and push
+     * issues onto it instead of returning a verdict.
+     */
+    check?: unknown;
+  };
 }
-export interface ZodDef {
-    type: string;
-    checks: ZodCheckSchema[];
-    check: string;
-    format: string;
-    pattern: RegExp | string;
-    /** Schema-level custom error (z.string({ error: "..." })). */
-    error?: unknown;
-    /** Unknown-key policy schema (z.strictObject → never, z.looseObject → unknown). */
-    catchall?: ZodSchema;
-    shape: Record<string, ZodSchema>;
-    element: ZodSchema;
-    options: ZodSchema[];
-    innerType: ZodSchema;
-    values: (string | number | boolean | null | bigint | undefined)[];
-    entries: Record<string, string>;
-    in: ZodSchema;
-    out: ZodSchema;
-    items: ZodSchema[];
-    rest: ZodSchema | null;
-    keyType: ZodSchema;
-    valueType: ZodSchema;
-    left: ZodSchema;
-    right: ZodSchema;
-    discriminator: string;
-    /** false on z.xor() unions (exactly-one-match semantics). */
-    inclusive?: boolean;
-    defaultValue: unknown;
-    coerce?: boolean;
-    catchValue?: (ctx: unknown) => unknown;
-    /** Transform function reference (present when type is "transform", and on Codec pipes). */
-    transform?: unknown;
-    /** Reverse transform (present on Codec schemas like stringbool). */
-    reverseTransform?: unknown;
+interface ZodDef {
+  type: string;
+  checks: ZodCheckSchema[];
+  check: string;
+  format: string;
+  pattern: RegExp | string;
+  /** Schema-level custom error (z.string({ error: "..." })). */
+  error?: unknown;
+  /** Unknown-key policy schema (z.strictObject → never, z.looseObject → unknown). */
+  catchall?: ZodSchema;
+  shape: Record<string, ZodSchema>;
+  element: ZodSchema;
+  options: ZodSchema[];
+  innerType: ZodSchema;
+  values: (string | number | boolean | null | bigint | undefined)[];
+  entries: Record<string, string>;
+  in: ZodSchema;
+  out: ZodSchema;
+  items: ZodSchema[];
+  rest: ZodSchema | null;
+  keyType: ZodSchema;
+  valueType: ZodSchema;
+  left: ZodSchema;
+  right: ZodSchema;
+  discriminator: string;
+  /** false on z.xor() unions (exactly-one-match semantics). */
+  inclusive?: boolean;
+  defaultValue: unknown;
+  coerce?: boolean;
+  catchValue?: (ctx: unknown) => unknown;
+  /** Transform function reference (present when type is "transform", and on Codec pipes). */
+  transform?: unknown;
+  /** Reverse transform (present on Codec schemas like stringbool). */
+  reverseTransform?: unknown;
 }
-export interface ZodSchema {
-    _zod: {
-        def: ZodDef;
-        bag?: Record<string, unknown>;
-        /** Resolved inner type for lazy schemas. */
-        innerType?: ZodSchema;
-        /** Pre-compiled pattern for templateLiteral schemas. */
-        pattern?: RegExp;
-        /** Finite value set (enum/literal keys) — drives exhaustive-key records. */
-        values?: Set<unknown>;
-        /** Class trait names from zod's $constructor (e.g. "$ZodExactOptional"). */
-        traits?: Set<string>;
-        /** "optional" when the key may be absent in object output (zod optout). */
-        optout?: string;
-        /** Discriminator dispatch values per property key (discriminated unions). */
-        propValues?: Record<string, Set<unknown> | undefined>;
-    };
+interface ZodSchema {
+  _zod: {
+    def: ZodDef;
+    bag?: Record<string, unknown>;
+    /** Resolved inner type for lazy schemas. */
+    innerType?: ZodSchema;
+    /** Pre-compiled pattern for templateLiteral schemas. */
+    pattern?: RegExp;
+    /** Finite value set (enum/literal keys) — drives exhaustive-key records. */
+    values?: Set<unknown>;
+    /** Class trait names from zod's $constructor (e.g. "$ZodExactOptional"). */
+    traits?: Set<string>;
+    /** "optional" when the key may be absent in object output (zod optout). */
+    optout?: string;
+    /** Discriminator dispatch values per property key (discriminated unions). */
+    propValues?: Record<string, Set<unknown> | undefined>;
+  };
 }
 /** Entry collected during extraction for each fallback sub-schema. */
-export interface RefEntry {
-    /** Runtime reference to the Zod sub-schema. */
-    schema: unknown;
-    /** Navigation path from root schema, e.g. '.shape["slug"]' */
-    accessPath: string;
+interface RefEntry {
+  /** Runtime reference to the Zod sub-schema. */
+  schema: unknown;
+  /** Navigation path from root schema, e.g. '.shape["slug"]' */
+  accessPath: string;
 }
 /** All Zod v4 def.type values that zod-compiler supports. */
-export type SupportedZodDefType = "boolean" | "null" | "undefined" | "any" | "unknown" | "symbol" | "void" | "nan" | "never" | "literal" | "enum" | "optional" | "nullable" | "readonly" | "intersection" | "string" | "number" | "bigint" | "date" | "object" | "array" | "tuple" | "record" | "set" | "map" | "union" | "default" | "pipe" | "lazy" | "catch" | "template_literal" | "file";
+type SupportedZodDefType = "boolean" | "null" | "undefined" | "any" | "unknown" | "symbol" | "void" | "nan" | "never" | "literal" | "enum" | "optional" | "nullable" | "readonly" | "intersection" | "string" | "number" | "bigint" | "date" | "object" | "array" | "tuple" | "record" | "set" | "map" | "union" | "default" | "pipe" | "lazy" | "catch" | "template_literal" | "file";
 /**
  * Shared, mutable recursion-target bookkeeping for one {@link extractSchema}
  * call. Lazy cycle detection assigns each NON-root recursion target a stable
@@ -109,31 +111,33 @@ export type SupportedZodDefType = "boolean" | "null" | "undefined" | "any" | "un
  * separately and uses the implicit refId 0. `dispatch` wraps a schema's IR in
  * a `recursionTarget` node when that schema turns out to be a non-root target.
  */
-export interface RecursionState {
-    /** The root schema of this extraction (first dispatched), for root detection. */
-    readonly root: unknown;
-    /** Non-root recursion targets: Zod schema → assigned refId (≥ 1). */
-    readonly targets: Map<unknown, number>;
-    /** Next refId to hand out (starts at 1; 0 is reserved for the root). */
-    next: number;
+interface RecursionState {
+  /** The root schema of this extraction (first dispatched), for root detection. */
+  readonly root: unknown;
+  /** Non-root recursion targets: Zod schema → assigned refId (≥ 1). */
+  readonly targets: Map<unknown, number>;
+  /** Next refId to hand out (starts at 1; 0 is reserved for the root). */
+  next: number;
 }
 /** Context object for extractor functions. Unifies the varied parameter patterns. */
-export interface ExtractorContext {
-    /** Raw Zod schema reference (for fallback entries and schema._zod access). */
-    readonly schema: unknown;
-    /** Navigation path from root, e.g. '._zod.def.innerType' */
-    readonly path: string;
-    /** Fallback entries collector (undefined if partial fallback disabled). */
-    readonly refs: RefEntry[] | undefined;
-    /** Cycle detection set for lazy resolution. */
-    readonly visiting: Set<unknown>;
-    /** Recursion-target bookkeeping (shared across the whole extraction). */
-    readonly recursion: RecursionState;
-    /** Recursively extract a child schema. Manages visiting set automatically. */
-    visit(childSchema: unknown, pathSuffix?: string): import("../types.js").SchemaIR;
-    /** Create a fallback entry for non-compilable sub-schemas. */
-    fallback(reason: import("../types.js").FallbackIR["reason"]): import("../types.js").FallbackIR;
+interface ExtractorContext {
+  /** Raw Zod schema reference (for fallback entries and schema._zod access). */
+  readonly schema: unknown;
+  /** Navigation path from root, e.g. '._zod.def.innerType' */
+  readonly path: string;
+  /** Fallback entries collector (undefined if partial fallback disabled). */
+  readonly refs: RefEntry[] | undefined;
+  /** Cycle detection set for lazy resolution. */
+  readonly visiting: Set<unknown>;
+  /** Recursion-target bookkeeping (shared across the whole extraction). */
+  readonly recursion: RecursionState;
+  /** Recursively extract a child schema. Manages visiting set automatically. */
+  visit(childSchema: unknown, pathSuffix?: string): SchemaIR;
+  /** Create a fallback entry for non-compilable sub-schemas. */
+  fallback(reason: FallbackIR["reason"]): FallbackIR;
 }
 /** Extractor function signature — registered in extractRegistry. */
-export type Extractor = (def: ZodDef, ctx: ExtractorContext) => import("../types.js").SchemaIR;
+type Extractor = (def: ZodDef, ctx: ExtractorContext) => SchemaIR;
+//#endregion
+export { Extractor, ExtractorContext, RecursionState, RefEntry, SupportedZodDefType, ZodCheckDef, ZodCheckSchema, ZodDef, ZodSchema };
 //# sourceMappingURL=types.d.ts.map

package/dist/core/extract/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/core/extract/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/core/extract/types.ts"],"mappings":";;UAAiB;EACf;EACA;EACA;EACA,SAAS;EACT;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;EACA;;EAEA,WAAW;EACX,WAAW;EACX;EACA;;UAGe;EACf;IACE,KAAK;;;;;;IAML;;;UAIa;EACf;EACA,QAAQ;EACR;EACA;EACA,SAAS;;EAET;;EAEA,WAAW;EACX,OAAO,eAAe;EACtB,SAAS;EACT,SAAS;EACT,WAAW;EACX;EACA,SAAS;EACT,IAAI;EACJ,KAAK;EACL,OAAO;EACP,MAAM;EACN,SAAS;EACT,WAAW;EACX,MAAM;EACN,OAAO;EACP;;EAEA;EACA;EACA;EACA,cAAc;;EAEd;;EAEA;;UAGe;EACf;IACE,KAAK;IACL,MAAM;;IAEN,YAAY;;IAEZ,UAAU;;IAEV,SAAS;;IAET,SAAS;;IAET;;IAEA,aAAa,eAAe;;;;UAKf;;EAEf;;EAEA;;;KAMU;;;;;;;;UA2CK;;WAEN;;WAEA,SAAS;;EAElB;;;UAMe;;WAEN;;WAEA;;WAEA,MAAM;;WAEN,UAAU;;WAEV,WAAW;;EAGpB,MAAM,sBAAsB,sBAHR;;EAMpB,SAAS,QAH+D,uBAGjC;;;KAI7B,aAAa,KAAK,QAAQ,KAAK,qBAAA"}

package/dist/core/extract/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map