zod-compiler 1.23.0 → 1.23.2

package/dist/core/types.d.ts

@@ -1,96 +1,97 @@
+//#region src/core/types.d.ts
 /**
  * SchemaIR — Intermediate representation for Zod schemas.
  * Extracted from Zod's `_zod.def` and `_zod.bag` at build time.
  */
 /** Shared base: static custom error message extracted from the check's `error` param. */
-export interface CheckBase {
-    /** Static message from e.g. `.min(3, "too short")`. Dynamic error maps force fallback. */
-    message?: string;
-}
-export interface CheckMinLength extends CheckBase {
-    kind: "min_length";
-    minimum: number;
-}
-export interface CheckMaxLength extends CheckBase {
-    kind: "max_length";
-    maximum: number;
-}
-export interface CheckLengthEquals extends CheckBase {
-    kind: "length_equals";
-    length: number;
-}
-export interface CheckGreaterThan extends CheckBase {
-    kind: "greater_than";
-    value: number;
-    inclusive: boolean;
-}
-export interface CheckLessThan extends CheckBase {
-    kind: "less_than";
-    value: number;
-    inclusive: boolean;
-}
-export interface CheckMultipleOf extends CheckBase {
-    kind: "multiple_of";
-    value: number;
-}
-export interface CheckNumberFormat extends CheckBase {
-    kind: "number_format";
-    format: "safeint" | "int32" | "uint32" | "float32" | "float64";
-}
-export interface CheckStringFormat extends CheckBase {
-    kind: "string_format";
-    format: string;
-    pattern?: string;
-    /** RegExp flags of the source pattern (e.g. "u" for z.emoji()). */
-    patternFlags?: string;
-    /** url-only: hostname constraint regex source (z.httpUrl()). */
-    hostname?: string;
-    hostnameFlags?: string;
-    /** url-only: protocol constraint regex source (z.httpUrl()). */
-    protocol?: string;
-    protocolFlags?: string;
-    /** url-only: output url.href instead of the trimmed input. */
-    normalize?: boolean;
-}
-export interface CheckIncludes extends CheckBase {
-    kind: "includes";
-    includes: string;
-    position?: number;
-}
-export interface CheckStartsWith extends CheckBase {
-    kind: "starts_with";
-    prefix: string;
-}
-export interface CheckEndsWith extends CheckBase {
-    kind: "ends_with";
-    suffix: string;
-}
-export type CheckIR = CheckMinLength | CheckMaxLength | CheckLengthEquals | CheckGreaterThan | CheckLessThan | CheckMultipleOf | CheckNumberFormat | CheckStringFormat | CheckIncludes | CheckStartsWith | CheckEndsWith;
-export interface RefineEffectCheckIR {
-    kind: "refine_effect";
-    /**
-     * fn.toString() result, e.g. "v => v.includes('@')". Set when the predicate
-     * is zero-capture and can be inlined into the generated code. Mutually
-     * exclusive with {@link refIndex}.
-     */
-    source?: string;
-    /**
-     * `__rf[N]` index of the predicate, used when the callback CAPTURES outer
-     * variables and so cannot be inlined. The generated code calls the user's
-     * original function object through the schema reference instead of
-     * delegating the whole schema to zod — a captured `.refine()` on a root
-     * object otherwise costs the entire compilation (measured 246.7 ns vs
-     * 10.4 ns for the same schema with an inlinable predicate).
-     */
-    refIndex?: number;
-    /** Custom error message from .refine(fn, "message") or .refine(fn, { message }) */
-    message?: string;
-    /**
-     * Issue path suffix from `.refine(fn, { path: [...] })`, appended to the
-     * node's own path — zod reports the failure against that member rather than
-     * the refined value itself.
-     */
-    path?: (string | number)[];
+interface CheckBase {
+  /** Static message from e.g. `.min(3, "too short")`. Dynamic error maps force fallback. */
+  message?: string;
+}
+interface CheckMinLength extends CheckBase {
+  kind: "min_length";
+  minimum: number;
+}
+interface CheckMaxLength extends CheckBase {
+  kind: "max_length";
+  maximum: number;
+}
+interface CheckLengthEquals extends CheckBase {
+  kind: "length_equals";
+  length: number;
+}
+interface CheckGreaterThan extends CheckBase {
+  kind: "greater_than";
+  value: number;
+  inclusive: boolean;
+}
+interface CheckLessThan extends CheckBase {
+  kind: "less_than";
+  value: number;
+  inclusive: boolean;
+}
+interface CheckMultipleOf extends CheckBase {
+  kind: "multiple_of";
+  value: number;
+}
+interface CheckNumberFormat extends CheckBase {
+  kind: "number_format";
+  format: "safeint" | "int32" | "uint32" | "float32" | "float64";
+}
+interface CheckStringFormat extends CheckBase {
+  kind: "string_format";
+  format: string;
+  pattern?: string;
+  /** RegExp flags of the source pattern (e.g. "u" for z.emoji()). */
+  patternFlags?: string;
+  /** url-only: hostname constraint regex source (z.httpUrl()). */
+  hostname?: string;
+  hostnameFlags?: string;
+  /** url-only: protocol constraint regex source (z.httpUrl()). */
+  protocol?: string;
+  protocolFlags?: string;
+  /** url-only: output url.href instead of the trimmed input. */
+  normalize?: boolean;
+}
+interface CheckIncludes extends CheckBase {
+  kind: "includes";
+  includes: string;
+  position?: number;
+}
+interface CheckStartsWith extends CheckBase {
+  kind: "starts_with";
+  prefix: string;
+}
+interface CheckEndsWith extends CheckBase {
+  kind: "ends_with";
+  suffix: string;
+}
+type CheckIR = CheckMinLength | CheckMaxLength | CheckLengthEquals | CheckGreaterThan | CheckLessThan | CheckMultipleOf | CheckNumberFormat | CheckStringFormat | CheckIncludes | CheckStartsWith | CheckEndsWith;
+interface RefineEffectCheckIR {
+  kind: "refine_effect";
+  /**
+   * fn.toString() result, e.g. "v => v.includes('@')". Set when the predicate
+   * is zero-capture and can be inlined into the generated code. Mutually
+   * exclusive with {@link refIndex}.
+   */
+  source?: string;
+  /**
+   * `__rf[N]` index of the predicate, used when the callback CAPTURES outer
+   * variables and so cannot be inlined. The generated code calls the user's
+   * original function object through the schema reference instead of
+   * delegating the whole schema to zod — a captured `.refine()` on a root
+   * object otherwise costs the entire compilation (measured 246.7 ns vs
+   * 10.4 ns for the same schema with an inlinable predicate).
+   */
+  refIndex?: number;
+  /** Custom error message from .refine(fn, "message") or .refine(fn, { message }) */
+  message?: string;
+  /**
+   * Issue path suffix from `.refine(fn, { path: [...] })`, appended to the
+   * node's own path — zod reports the failure against that member rather than
+   * the refined value itself.
+   */
+  path?: (string | number)[];
 }
 /**
  * A `superRefine` (or a raw `.check(payloadFn)`): a callback that receives zod's
@@ -103,301 +104,301 @@ export interface RefineEffectCheckIR {
  * `fatal`/`continue:false` aborts zod's remaining check chain, which compiled
  * output (running every check) could not reproduce.
  */
-export interface SuperRefineEffectCheckIR {
-    kind: "super_refine_effect";
-    /** `__rf[N]` index of the payload-taking callback. */
-    refIndex: number;
+interface SuperRefineEffectCheckIR {
+  kind: "super_refine_effect";
+  /** `__rf[N]` index of the payload-taking callback. */
+  refIndex: number;
 }
 /**
  * Value-rewriting check compiled from a $ZodCheckOverwrite (.trim(), .toLowerCase(), ...).
  * Applied at its original position: `value = (source)(value)`. Never produces issues.
  */
-export interface OverwriteEffectCheckIR {
-    kind: "overwrite_effect";
-    /** fn.toString() of the overwrite transform, e.g. "(input) => input.trim()" */
-    source: string;
+interface OverwriteEffectCheckIR {
+  kind: "overwrite_effect";
+  /** fn.toString() of the overwrite transform, e.g. "(input) => input.trim()" */
+  source: string;
 }
 /** A check entry that may be a compiled check or an inline effect. */
-export type CheckOrEffectIR = CheckIR | RefineEffectCheckIR | SuperRefineEffectCheckIR | OverwriteEffectCheckIR;
-export interface CheckDateGreaterThan extends CheckBase {
-    kind: "date_greater_than";
-    value: string;
-    timestamp: number;
-    inclusive: boolean;
-}
-export interface CheckDateLessThan extends CheckBase {
-    kind: "date_less_than";
-    value: string;
-    timestamp: number;
-    inclusive: boolean;
-}
-export type DateCheckIR = CheckDateGreaterThan | CheckDateLessThan;
-export interface CheckBigIntGreaterThan extends CheckBase {
-    kind: "bigint_greater_than";
-    /** String representation of the BigInt value (e.g. "10") */
-    value: string;
-    inclusive: boolean;
-}
-export interface CheckBigIntLessThan extends CheckBase {
-    kind: "bigint_less_than";
-    /** String representation of the BigInt value (e.g. "100") */
-    value: string;
-    inclusive: boolean;
-}
-export interface CheckBigIntMultipleOf extends CheckBase {
-    kind: "bigint_multiple_of";
-    /** String representation of the BigInt value (e.g. "3") */
-    value: string;
-}
-export type BigIntCheckIR = CheckBigIntGreaterThan | CheckBigIntLessThan | CheckBigIntMultipleOf;
-export interface CheckMinSize extends CheckBase {
-    kind: "min_size";
-    minimum: number;
-}
-export interface CheckMaxSize extends CheckBase {
-    kind: "max_size";
-    maximum: number;
-}
-export interface CheckSizeEquals extends CheckBase {
-    kind: "size_equals";
-    size: number;
-}
-export type SetCheckIR = CheckMinSize | CheckMaxSize | CheckSizeEquals;
-export interface CheckMimeType extends CheckBase {
-    kind: "mime_type";
-    mime: string[];
-}
-export type FileCheckIR = CheckMinSize | CheckMaxSize | CheckMimeType;
-export interface StringIR {
-    type: "string";
-    checks: CheckOrEffectIR[];
-    coerce?: boolean;
-}
-export interface NumberIR {
-    type: "number";
-    checks: CheckOrEffectIR[];
-    coerce?: boolean;
-}
-export interface BooleanIR {
-    type: "boolean";
-    coerce?: boolean;
-}
-export interface BigIntIR {
-    type: "bigint";
-    checks: BigIntCheckIR[];
-    coerce?: boolean;
-}
-export interface DateIR {
-    type: "date";
-    checks: DateCheckIR[];
-    coerce?: boolean;
-}
-export interface SymbolIR {
-    type: "symbol";
-}
-export interface NullIR {
-    type: "null";
-}
-export interface UndefinedIR {
-    type: "undefined";
-}
-export interface VoidIR {
-    type: "void";
-}
-export interface NanIR {
-    type: "nan";
-}
-export interface NeverIR {
-    type: "never";
-}
-export interface AnyIR {
-    type: "any";
-}
-export interface UnknownIR {
-    type: "unknown";
-}
-export interface LiteralIR {
-    type: "literal";
-    values: (string | number | boolean | null | bigint | undefined)[];
-}
-export interface EnumIR {
-    type: "enum";
-    /** Accepted values — z.nativeEnum() can contribute numbers. */
-    values: (string | number)[];
-}
-export interface ObjectIR {
-    type: "object";
-    properties: Record<string, SchemaIR>;
-    /**
-     * Reject unknown keys (z.strictObject / .strict() / .catchall(z.never())).
-     * Compiled as a for-in membership pass after the property checks, mirroring
-     * zod's handleCatchall exactly: `for (const key in input)` (inherited
-     * enumerable keys count, no hasOwnProperty filter) collecting ALL unknown
-     * keys into ONE `unrecognized_keys` issue pushed after property issues.
-     * Pass-through still holds — valid strict data has no extra keys, so
-     * data === input and the schema stays Fast Path eligible.
-     */
-    strict?: boolean;
-    /**
-     * Strip unknown keys from the output (zod's DEFAULT `z.object()` behavior),
-     * set only when the `stripUnknownKeys` build option is enabled AND this is a
-     * genuine `z.object()` (no catchall) — never on `z.looseObject()` (keep) or
-     * `z.strictObject()` (reject). Compiled by rebuilding a fresh object from
-     * only the declared own keys, mirroring zod's strip exactly. Because the
-     * output is a fresh value, a strip object counts as a {@link hasMutation}
-     * node: it never takes the zero-allocation by-reference fast path, and parent
-     * containers clone before it writes back (so intersections of strip objects
-     * delegate to zod, matching zod's merge-then-strip semantics). Mutually
-     * exclusive with `strict`.
-     */
-    stripUnknownKeys?: boolean;
-    /** Object-level refine effects from z.object({...}).refine(fn) */
-    checks?: (RefineEffectCheckIR | SuperRefineEffectCheckIR)[];
-    /**
-     * `.catchall(schema)`: every key not in the shape is validated against this
-     * schema instead of being ignored (plain object) or rejected (strict).
-     * Mutually exclusive with `strict` — `.catchall(z.never())` IS strict — and
-     * with `stripUnknownKeys`, since a catchall exists to KEEP unknown keys.
-     */
-    catchall?: SchemaIR;
-    /**
-     * Fallback-typed property keys whose zod schema is optional-out: when the
-     * key is ABSENT from the input, their issues are suppressed (mirrors zod's
-     * handlePropertyResult). Lets z.exactOptional() and friends fall back at
-     * the property level without rejecting missing keys.
-     */
-    suppressAbsentKeys?: string[];
-}
-export interface ArrayIR {
-    type: "array";
-    element: SchemaIR;
-    checks: CheckOrEffectIR[];
-}
-export interface TupleIR {
-    type: "tuple";
-    items: SchemaIR[];
-    rest: SchemaIR | null;
-}
-export interface RecordIR {
-    type: "record";
-    keyType: SchemaIR;
-    valueType: SchemaIR;
-}
-export interface SetIR {
-    type: "set";
-    valueType: SchemaIR;
-    checks?: SetCheckIR[];
-}
-export interface MapIR {
-    type: "map";
-    keyType: SchemaIR;
-    valueType: SchemaIR;
-}
-export interface FileIR {
-    type: "file";
-    checks?: FileCheckIR[];
-}
-export interface UnionIR {
-    type: "union";
-    options: SchemaIR[];
-}
-export interface DiscriminatedUnionIR {
-    type: "discriminatedUnion";
-    discriminator: string;
-    options: SchemaIR[];
-    /**
-     * Typed discriminator-value dispatch table, sourced from zod's
-     * `_zod.propValues` (covers literal AND enum discriminators, preserving
-     * value types so numeric/boolean discriminators switch correctly).
-     */
-    cases: {
-        value: string | number | boolean | null | bigint | undefined;
-        option: number;
-    }[];
-}
-export interface IntersectionIR {
-    type: "intersection";
-    left: SchemaIR;
-    right: SchemaIR;
-}
-export interface OptionalIR {
-    type: "optional";
-    inner: SchemaIR;
-}
-export interface NullableIR {
-    type: "nullable";
-    inner: SchemaIR;
-}
-export interface ReadonlyIR {
-    type: "readonly";
-    inner: SchemaIR;
-}
-export interface DefaultIR {
-    type: "default";
-    inner: SchemaIR;
-    refIndex: number;
-    /**
-     * The declared default value is not itself `undefined`, read off the schema at
-     * extraction time. That makes the node's output ALWAYS defined — the default
-     * branch yields the declared value, and the inner branch only runs for a
-     * non-undefined input, which zod's strip test keeps regardless of what the
-     * inner produced. Lets a defaulted property claim a slot in the output object
-     * literal instead of a conditional append (see outputAlwaysDefined).
-     *
-     * Absent for the degenerate `.default(undefined)`, where zod drops the key.
-     */
-    alwaysDefined?: boolean;
-}
-export interface PipeIR {
-    type: "pipe";
-    in: SchemaIR;
-    out: SchemaIR;
-}
-export interface TransformEffectIR {
-    type: "effect";
-    effectKind: "transform";
-    /**
-     * fn.toString() result, e.g. "v => v.toLowerCase()". Set when the callback is
-     * zero-capture and can be inlined. Mutually exclusive with {@link refIndex}.
-     */
-    source?: string;
-    /**
-     * `__rf[N]` index of the transform, used when the callback CAPTURES outer
-     * variables. Calling the user's own function object keeps the schema compiled;
-     * delegating the whole schema to zod instead measured 163.7 ns against zod's
-     * own 136.7 ns — the fallback wrapper made it SLOWER than not compiling.
-     */
-    refIndex?: number;
-    /** The input schema to validate before applying the transform */
-    inner: SchemaIR;
-}
-export interface FallbackIR {
-    type: "fallback";
-    reason: "transform" | "refine" | "superRefine" | "custom" | "lazy" | "unsupported" | "coalesced";
-    /** Index into the __rf[] fallback schemas array. Present when partial fallback is used. */
-    refIndex?: number;
-}
-export interface TemplateLiteralIR {
-    type: "templateLiteral";
-    pattern: string;
-}
-export interface CatchIR {
-    type: "catch";
-    inner: SchemaIR;
-    /** Index into __rf[] — the original z.catch() schema whose catchValue runs per parse. */
-    refIndex: number;
-}
-export interface RecursiveRefIR {
-    type: "recursiveRef";
-    /**
-     * Identifies which recursion target this back-edge re-invokes. Absent (or 0)
-     * means the ROOT schema — the directly self-recursive case, whose validator
-     * is the schema's own `safeParse_<name>` / hosted fast-check. A value ≥ 1
-     * targets a non-root sub-schema hosted as a standalone validator (see
-     * {@link RecursionTargetIR}); used for recursive schemas nested inside a
-     * larger root, multiple distinct recursive sub-schemas, and mutual recursion.
-     */
-    refId?: number;
+type CheckOrEffectIR = CheckIR | RefineEffectCheckIR | SuperRefineEffectCheckIR | OverwriteEffectCheckIR;
+interface CheckDateGreaterThan extends CheckBase {
+  kind: "date_greater_than";
+  value: string;
+  timestamp: number;
+  inclusive: boolean;
+}
+interface CheckDateLessThan extends CheckBase {
+  kind: "date_less_than";
+  value: string;
+  timestamp: number;
+  inclusive: boolean;
+}
+type DateCheckIR = CheckDateGreaterThan | CheckDateLessThan;
+interface CheckBigIntGreaterThan extends CheckBase {
+  kind: "bigint_greater_than";
+  /** String representation of the BigInt value (e.g. "10") */
+  value: string;
+  inclusive: boolean;
+}
+interface CheckBigIntLessThan extends CheckBase {
+  kind: "bigint_less_than";
+  /** String representation of the BigInt value (e.g. "100") */
+  value: string;
+  inclusive: boolean;
+}
+interface CheckBigIntMultipleOf extends CheckBase {
+  kind: "bigint_multiple_of";
+  /** String representation of the BigInt value (e.g. "3") */
+  value: string;
+}
+type BigIntCheckIR = CheckBigIntGreaterThan | CheckBigIntLessThan | CheckBigIntMultipleOf;
+interface CheckMinSize extends CheckBase {
+  kind: "min_size";
+  minimum: number;
+}
+interface CheckMaxSize extends CheckBase {
+  kind: "max_size";
+  maximum: number;
+}
+interface CheckSizeEquals extends CheckBase {
+  kind: "size_equals";
+  size: number;
+}
+type SetCheckIR = CheckMinSize | CheckMaxSize | CheckSizeEquals;
+interface CheckMimeType extends CheckBase {
+  kind: "mime_type";
+  mime: string[];
+}
+type FileCheckIR = CheckMinSize | CheckMaxSize | CheckMimeType;
+interface StringIR {
+  type: "string";
+  checks: CheckOrEffectIR[];
+  coerce?: boolean;
+}
+interface NumberIR {
+  type: "number";
+  checks: CheckOrEffectIR[];
+  coerce?: boolean;
+}
+interface BooleanIR {
+  type: "boolean";
+  coerce?: boolean;
+}
+interface BigIntIR {
+  type: "bigint";
+  checks: BigIntCheckIR[];
+  coerce?: boolean;
+}
+interface DateIR {
+  type: "date";
+  checks: DateCheckIR[];
+  coerce?: boolean;
+}
+interface SymbolIR {
+  type: "symbol";
+}
+interface NullIR {
+  type: "null";
+}
+interface UndefinedIR {
+  type: "undefined";
+}
+interface VoidIR {
+  type: "void";
+}
+interface NanIR {
+  type: "nan";
+}
+interface NeverIR {
+  type: "never";
+}
+interface AnyIR {
+  type: "any";
+}
+interface UnknownIR {
+  type: "unknown";
+}
+interface LiteralIR {
+  type: "literal";
+  values: (string | number | boolean | null | bigint | undefined)[];
+}
+interface EnumIR {
+  type: "enum";
+  /** Accepted values — z.nativeEnum() can contribute numbers. */
+  values: (string | number)[];
+}
+interface ObjectIR {
+  type: "object";
+  properties: Record<string, SchemaIR>;
+  /**
+   * Reject unknown keys (z.strictObject / .strict() / .catchall(z.never())).
+   * Compiled as a for-in membership pass after the property checks, mirroring
+   * zod's handleCatchall exactly: `for (const key in input)` (inherited
+   * enumerable keys count, no hasOwnProperty filter) collecting ALL unknown
+   * keys into ONE `unrecognized_keys` issue pushed after property issues.
+   * Pass-through still holds — valid strict data has no extra keys, so
+   * data === input and the schema stays Fast Path eligible.
+   */
+  strict?: boolean;
+  /**
+   * Strip unknown keys from the output (zod's DEFAULT `z.object()` behavior),
+   * set only when the `stripUnknownKeys` build option is enabled AND this is a
+   * genuine `z.object()` (no catchall) — never on `z.looseObject()` (keep) or
+   * `z.strictObject()` (reject). Compiled by rebuilding a fresh object from
+   * only the declared own keys, mirroring zod's strip exactly. Because the
+   * output is a fresh value, a strip object counts as a {@link hasMutation}
+   * node: it never takes the zero-allocation by-reference fast path, and parent
+   * containers clone before it writes back (so intersections of strip objects
+   * delegate to zod, matching zod's merge-then-strip semantics). Mutually
+   * exclusive with `strict`.
+   */
+  stripUnknownKeys?: boolean;
+  /** Object-level refine effects from z.object({...}).refine(fn) */
+  checks?: (RefineEffectCheckIR | SuperRefineEffectCheckIR)[];
+  /**
+   * `.catchall(schema)`: every key not in the shape is validated against this
+   * schema instead of being ignored (plain object) or rejected (strict).
+   * Mutually exclusive with `strict` — `.catchall(z.never())` IS strict — and
+   * with `stripUnknownKeys`, since a catchall exists to KEEP unknown keys.
+   */
+  catchall?: SchemaIR;
+  /**
+   * Fallback-typed property keys whose zod schema is optional-out: when the
+   * key is ABSENT from the input, their issues are suppressed (mirrors zod's
+   * handlePropertyResult). Lets z.exactOptional() and friends fall back at
+   * the property level without rejecting missing keys.
+   */
+  suppressAbsentKeys?: string[];
+}
+interface ArrayIR {
+  type: "array";
+  element: SchemaIR;
+  checks: CheckOrEffectIR[];
+}
+interface TupleIR {
+  type: "tuple";
+  items: SchemaIR[];
+  rest: SchemaIR | null;
+}
+interface RecordIR {
+  type: "record";
+  keyType: SchemaIR;
+  valueType: SchemaIR;
+}
+interface SetIR {
+  type: "set";
+  valueType: SchemaIR;
+  checks?: SetCheckIR[];
+}
+interface MapIR {
+  type: "map";
+  keyType: SchemaIR;
+  valueType: SchemaIR;
+}
+interface FileIR {
+  type: "file";
+  checks?: FileCheckIR[];
+}
+interface UnionIR {
+  type: "union";
+  options: SchemaIR[];
+}
+interface DiscriminatedUnionIR {
+  type: "discriminatedUnion";
+  discriminator: string;
+  options: SchemaIR[];
+  /**
+   * Typed discriminator-value dispatch table, sourced from zod's
+   * `_zod.propValues` (covers literal AND enum discriminators, preserving
+   * value types so numeric/boolean discriminators switch correctly).
+   */
+  cases: {
+    value: string | number | boolean | null | bigint | undefined;
+    option: number;
+  }[];
+}
+interface IntersectionIR {
+  type: "intersection";
+  left: SchemaIR;
+  right: SchemaIR;
+}
+interface OptionalIR {
+  type: "optional";
+  inner: SchemaIR;
+}
+interface NullableIR {
+  type: "nullable";
+  inner: SchemaIR;
+}
+interface ReadonlyIR {
+  type: "readonly";
+  inner: SchemaIR;
+}
+interface DefaultIR {
+  type: "default";
+  inner: SchemaIR;
+  refIndex: number;
+  /**
+   * The declared default value is not itself `undefined`, read off the schema at
+   * extraction time. That makes the node's output ALWAYS defined — the default
+   * branch yields the declared value, and the inner branch only runs for a
+   * non-undefined input, which zod's strip test keeps regardless of what the
+   * inner produced. Lets a defaulted property claim a slot in the output object
+   * literal instead of a conditional append (see outputAlwaysDefined).
+   *
+   * Absent for the degenerate `.default(undefined)`, where zod drops the key.
+   */
+  alwaysDefined?: boolean;
+}
+interface PipeIR {
+  type: "pipe";
+  in: SchemaIR;
+  out: SchemaIR;
+}
+interface TransformEffectIR {
+  type: "effect";
+  effectKind: "transform";
+  /**
+   * fn.toString() result, e.g. "v => v.toLowerCase()". Set when the callback is
+   * zero-capture and can be inlined. Mutually exclusive with {@link refIndex}.
+   */
+  source?: string;
+  /**
+   * `__rf[N]` index of the transform, used when the callback CAPTURES outer
+   * variables. Calling the user's own function object keeps the schema compiled;
+   * delegating the whole schema to zod instead measured 163.7 ns against zod's
+   * own 136.7 ns — the fallback wrapper made it SLOWER than not compiling.
+   */
+  refIndex?: number;
+  /** The input schema to validate before applying the transform */
+  inner: SchemaIR;
+}
+interface FallbackIR {
+  type: "fallback";
+  reason: "transform" | "refine" | "superRefine" | "custom" | "lazy" | "unsupported" | "coalesced";
+  /** Index into the __rf[] fallback schemas array. Present when partial fallback is used. */
+  refIndex?: number;
+}
+interface TemplateLiteralIR {
+  type: "templateLiteral";
+  pattern: string;
+}
+interface CatchIR {
+  type: "catch";
+  inner: SchemaIR;
+  /** Index into __rf[] — the original z.catch() schema whose catchValue runs per parse. */
+  refIndex: number;
+}
+interface RecursiveRefIR {
+  type: "recursiveRef";
+  /**
+   * Identifies which recursion target this back-edge re-invokes. Absent (or 0)
+   * means the ROOT schema — the directly self-recursive case, whose validator
+   * is the schema's own `safeParse_<name>` / hosted fast-check. A value ≥ 1
+   * targets a non-root sub-schema hosted as a standalone validator (see
+   * {@link RecursionTargetIR}); used for recursive schemas nested inside a
+   * larger root, multiple distinct recursive sub-schemas, and mutual recursion.
+   */
+  refId?: number;
 }
 /**
  * Marks a sub-schema that is the target of one or more {@link RecursiveRefIR}
@@ -407,16 +408,16 @@ export interface RecursiveRefIR {
  * the (wrong-shaped) root validator. The root target needs no wrapper: it IS
  * the root function, so it is never wrapped and uses the implicit refId 0.
  */
-export interface RecursionTargetIR {
-    type: "recursionTarget";
-    refId: number;
-    inner: SchemaIR;
+interface RecursionTargetIR {
+  type: "recursionTarget";
+  refId: number;
+  inner: SchemaIR;
 }
-export interface StringBoolIR {
-    type: "stringBool";
-    truthy: string[];
-    falsy: string[];
-    caseSensitive: boolean;
+interface StringBoolIR {
+  type: "stringBool";
+  truthy: string[];
+  falsy: string[];
+  caseSensitive: boolean;
 }
 /**
  * Optional schema-level static error message (z.string({ error: "..." })).
@@ -425,46 +426,48 @@ export interface StringBoolIR {
  * error > schema error > locale default). Dynamic schema-level error maps
  * force fallback instead.
  */
-export interface TypeMessageCarrier {
-    typeMessage?: string;
-}
-export type SchemaIR = TypeMessageCarrier & (StringIR | NumberIR | BooleanIR | BigIntIR | DateIR | SymbolIR | NullIR | UndefinedIR | VoidIR | NanIR | NeverIR | AnyIR | UnknownIR | LiteralIR | EnumIR | ObjectIR | ArrayIR | TupleIR | RecordIR | SetIR | MapIR | FileIR | UnionIR | DiscriminatedUnionIR | IntersectionIR | OptionalIR | NullableIR | ReadonlyIR | DefaultIR | PipeIR | TransformEffectIR | TemplateLiteralIR | CatchIR | FallbackIR | RecursiveRefIR | RecursionTargetIR | StringBoolIR);
-export interface SafeParseSuccess<T> {
-    success: true;
-    data: T;
-}
-export interface SafeParseError {
-    success: false;
-    error: ZodErrorLike;
-}
-export type SafeParseResult<T> = SafeParseSuccess<T> | SafeParseError;
-export interface ZodIssueLike {
-    code: string;
-    path: (string | number)[];
-    message: string;
-    [key: string]: unknown;
-}
-export interface ZodErrorLike {
-    issues: ZodIssueLike[];
-}
-export interface DiscoveredSchema {
-    exportName: string;
-    schema: unknown;
-}
-export interface CompiledSchema<T> {
-    parse(input: unknown): T;
-    parseAsync(input: unknown): Promise<T>;
-    safeParse(input: unknown): SafeParseResult<T>;
-    safeParseAsync(input: unknown): Promise<SafeParseResult<T>>;
-    /**
-     * Zero-allocation boolean type guard. For schemas with a total Fast Path
-     * (the common case — objects, primitives, arrays, enums without
-     * coerce/default/catch/transform), this IS the compiled fast-check function:
-     * one boolean expression, no result object, no issues array — the cheapest
-     * possible "does this match?" check, on par with typia's `is<T>()`. Schemas
-     * without a total Fast Path fall back to `safeParse(input).success`
-     * (correct, still allocation-light). Narrows `input` to `T` on `true`.
-     */
-    is(input: unknown): input is T;
-}
+interface TypeMessageCarrier {
+  typeMessage?: string;
+}
+type SchemaIR = TypeMessageCarrier & (StringIR | NumberIR | BooleanIR | BigIntIR | DateIR | SymbolIR | NullIR | UndefinedIR | VoidIR | NanIR | NeverIR | AnyIR | UnknownIR | LiteralIR | EnumIR | ObjectIR | ArrayIR | TupleIR | RecordIR | SetIR | MapIR | FileIR | UnionIR | DiscriminatedUnionIR | IntersectionIR | OptionalIR | NullableIR | ReadonlyIR | DefaultIR | PipeIR | TransformEffectIR | TemplateLiteralIR | CatchIR | FallbackIR | RecursiveRefIR | RecursionTargetIR | StringBoolIR);
+interface SafeParseSuccess<T> {
+  success: true;
+  data: T;
+}
+interface SafeParseError {
+  success: false;
+  error: ZodErrorLike;
+}
+type SafeParseResult<T> = SafeParseSuccess<T> | SafeParseError;
+interface ZodIssueLike {
+  code: string;
+  path: (string | number)[];
+  message: string;
+  [key: string]: unknown;
+}
+interface ZodErrorLike {
+  issues: ZodIssueLike[];
+}
+interface DiscoveredSchema {
+  exportName: string;
+  schema: unknown;
+}
+interface CompiledSchema<T> {
+  parse(input: unknown): T;
+  parseAsync(input: unknown): Promise<T>;
+  safeParse(input: unknown): SafeParseResult<T>;
+  safeParseAsync(input: unknown): Promise<SafeParseResult<T>>;
+  /**
+   * Zero-allocation boolean type guard. For schemas with a total Fast Path
+   * (the common case — objects, primitives, arrays, enums without
+   * coerce/default/catch/transform), this IS the compiled fast-check function:
+   * one boolean expression, no result object, no issues array — the cheapest
+   * possible "does this match?" check, on par with typia's `is<T>()`. Schemas
+   * without a total Fast Path fall back to `safeParse(input).success`
+   * (correct, still allocation-light). Narrows `input` to `T` on `true`.
+   */
+  is(input: unknown): input is T;
+}
+//#endregion
+export { AnyIR, ArrayIR, BigIntCheckIR, BigIntIR, BooleanIR, CatchIR, CheckBase, CheckBigIntGreaterThan, CheckBigIntLessThan, CheckBigIntMultipleOf, CheckDateGreaterThan, CheckDateLessThan, CheckEndsWith, CheckGreaterThan, CheckIR, CheckIncludes, CheckLengthEquals, CheckLessThan, CheckMaxLength, CheckMaxSize, CheckMimeType, CheckMinLength, CheckMinSize, CheckMultipleOf, CheckNumberFormat, CheckOrEffectIR, CheckSizeEquals, CheckStartsWith, CheckStringFormat, CompiledSchema, DateCheckIR, DateIR, DefaultIR, DiscoveredSchema, DiscriminatedUnionIR, EnumIR, FallbackIR, FileCheckIR, FileIR, IntersectionIR, LiteralIR, MapIR, NanIR, NeverIR, NullIR, NullableIR, NumberIR, ObjectIR, OptionalIR, OverwriteEffectCheckIR, PipeIR, ReadonlyIR, RecordIR, RecursionTargetIR, RecursiveRefIR, RefineEffectCheckIR, SafeParseError, SafeParseResult, SafeParseSuccess, SchemaIR, SetCheckIR, SetIR, StringBoolIR, StringIR, SuperRefineEffectCheckIR, SymbolIR, TemplateLiteralIR, TransformEffectIR, TupleIR, TypeMessageCarrier, UndefinedIR, UnionIR, UnknownIR, VoidIR, ZodErrorLike, ZodIssueLike };
 //# sourceMappingURL=types.d.ts.map