zod-compiler 0.1.1 → 1.0.1

package/dist/core/codegen/schemas/void.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"void.js","sourceRoot":"","sources":["../../../../src/core/codegen/schemas/void.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAClC,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,MAAM,UAAU,QAAQ,CAAC,GAAW,EAAE,CAAU;IAC9C,OAAO,GAAG,IAAI,CAAA;SACP,CAAC,CAAC,KAAK;QACR,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC;;GAE3B,IAAI,CAAC;AACR,CAAC;AAED,MAAM,UAAU,QAAQ,CAAC,GAAW,EAAE,CAAU;IAC9C,OAAO,GAAG,CAAC,CAAC,KAAK,cAAc,CAAC;AAClC,CAAC"}

package/dist/core/codegen/slow-path.d.ts

@@ -0,0 +1,5 @@
+import type { SchemaIR } from "../types.js";
+import type { CodeGenContext, SlowGen } from "./context.js";
+export declare function createSlowGen(inputExpr: string, outputExpr: string, pathExpr: string, issuesVar: string, ctx: CodeGenContext): SlowGen;
+export declare function generateSlow(ir: SchemaIR, g: SlowGen): string;
+//# sourceMappingURL=slow-path.d.ts.map

package/dist/core/codegen/slow-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slow-path.d.ts","sourceRoot":"","sources":["../../../src/core/codegen/slow-path.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAE,cAAc,EAAE,OAAO,EAAiB,MAAM,cAAc,CAAC;AA+F3E,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,cAAc,GAClB,OAAO,CAuBT;AAID,wBAAgB,YAAY,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,EAAE,OAAO,GAAG,MAAM,CAO7D"}

package/dist/core/codegen/slow-path.js

@@ -0,0 +1,113 @@
+import { emitRegex, emitSet, emitTemp } from "./context.js";
+import { slowAny } from "./schemas/any.js";
+import { slowArray } from "./schemas/array.js";
+import { slowBigInt } from "./schemas/bigint.js";
+import { slowBoolean } from "./schemas/boolean.js";
+import { slowCatch } from "./schemas/catch.js";
+import { slowDate } from "./schemas/date.js";
+import { slowDefault } from "./schemas/default.js";
+import { slowDiscriminatedUnion } from "./schemas/discriminated-union.js";
+import { slowEffect } from "./schemas/effect.js";
+import { slowEnum } from "./schemas/enum.js";
+import { slowFallback } from "./schemas/fallback.js";
+import { slowFile } from "./schemas/file.js";
+import { slowIntersection } from "./schemas/intersection.js";
+import { slowLiteral } from "./schemas/literal.js";
+import { slowMap } from "./schemas/map.js";
+import { slowNan } from "./schemas/nan.js";
+import { slowNever } from "./schemas/never.js";
+import { slowNull } from "./schemas/null.js";
+import { slowNullable } from "./schemas/nullable.js";
+import { slowNumber } from "./schemas/number.js";
+import { slowObject } from "./schemas/object.js";
+import { slowOptional } from "./schemas/optional.js";
+import { slowPipe } from "./schemas/pipe.js";
+import { slowReadonly } from "./schemas/readonly.js";
+import { slowRecord } from "./schemas/record.js";
+import { slowRecursiveRef } from "./schemas/recursive-ref.js";
+import { slowSet } from "./schemas/set.js";
+import { slowString } from "./schemas/string.js";
+import { slowStringBool } from "./schemas/string-bool.js";
+import { slowSymbol } from "./schemas/symbol.js";
+import { slowTemplateLiteral } from "./schemas/template-literal.js";
+import { slowTuple } from "./schemas/tuple.js";
+import { slowUndefined } from "./schemas/undefined.js";
+import { slowUnion } from "./schemas/union.js";
+import { slowUnknown } from "./schemas/unknown.js";
+import { slowVoid } from "./schemas/void.js";
+// ─── Typed registry ─────────────────────────────────────────────────────────
+// Adding a new SchemaIR type without registering a generator here causes a
+// compile error, preventing the silent-missing-case bugs that plagued the old
+// switch-based dispatch.
+const slowRegistry = {
+    // Primitives (order follows SchemaIR union in types.ts)
+    string: slowString,
+    number: slowNumber,
+    boolean: slowBoolean,
+    bigint: slowBigInt,
+    date: slowDate,
+    symbol: slowSymbol,
+    null: slowNull,
+    undefined: slowUndefined,
+    void: slowVoid,
+    nan: slowNan,
+    never: slowNever,
+    any: slowAny,
+    unknown: slowUnknown,
+    literal: slowLiteral,
+    enum: slowEnum,
+    // Containers
+    object: slowObject,
+    array: slowArray,
+    tuple: slowTuple,
+    record: slowRecord,
+    set: slowSet,
+    map: slowMap,
+    file: slowFile,
+    // Unions & Intersections
+    union: slowUnion,
+    discriminatedUnion: slowDiscriminatedUnion,
+    intersection: slowIntersection,
+    // Modifiers
+    optional: slowOptional,
+    nullable: slowNullable,
+    readonly: slowReadonly,
+    default: slowDefault,
+    pipe: slowPipe,
+    // Effects
+    effect: slowEffect,
+    // Special
+    templateLiteral: slowTemplateLiteral,
+    catch: slowCatch,
+    fallback: slowFallback,
+    recursiveRef: slowRecursiveRef,
+    stringBool: slowStringBool,
+};
+// ─── Factory ─────────────────────────────────────────────────────────────────
+// Lives here (not in context.ts) to avoid circular imports:
+// visit() → generateSlow() → imports from context.ts
+export function createSlowGen(inputExpr, outputExpr, pathExpr, issuesVar, ctx) {
+    return {
+        input: inputExpr,
+        output: outputExpr,
+        path: pathExpr,
+        issues: issuesVar,
+        ctx,
+        visit(ir, overrides) {
+            return generateSlow(ir, createSlowGen(overrides?.input ?? inputExpr, overrides?.output ?? outputExpr, overrides?.path ?? pathExpr, overrides?.issues ?? issuesVar, ctx));
+        },
+        temp: (prefix) => emitTemp(ctx, prefix),
+        regex: (prefix, pattern, flags) => emitRegex(ctx, prefix, pattern, flags),
+        set: (prefix, values) => emitSet(ctx, prefix, values),
+    };
+}
+// ─── Dispatch ────────────────────────────────────────────────────────────────
+export function generateSlow(ir, g) {
+    // Surface the node's schema-level error message to issue emission. visit()
+    // always builds a fresh context, so typeMsg never leaks into child nodes.
+    const gen0 = ir.typeMessage !== g.typeMsg ? { ...g, typeMsg: ir.typeMessage } : g;
+    const gen = slowRegistry[ir.type];
+    // biome-ignore lint/suspicious/noExplicitAny: registry dispatch requires type erasure at call site
+    return gen(ir, gen0);
+}
+//# sourceMappingURL=slow-path.js.map

package/dist/core/codegen/slow-path.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slow-path.js","sourceRoot":"","sources":["../../../src/core/codegen/slow-path.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAC5D,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAC1E,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACpE,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C,+EAA+E;AAC/E,2EAA2E;AAC3E,8EAA8E;AAC9E,yBAAyB;AAEzB,MAAM,YAAY,GAAG;IACnB,wDAAwD;IACxD,MAAM,EAAE,UAAU;IAClB,MAAM,EAAE,UAAU;IAClB,OAAO,EAAE,WAAW;IACpB,MAAM,EAAE,UAAU;IAClB,IAAI,EAAE,QAAQ;IACd,MAAM,EAAE,UAAU;IAClB,IAAI,EAAE,QAAQ;IACd,SAAS,EAAE,aAAa;IACxB,IAAI,EAAE,QAAQ;IACd,GAAG,EAAE,OAAO;IACZ,KAAK,EAAE,SAAS;IAChB,GAAG,EAAE,OAAO;IACZ,OAAO,EAAE,WAAW;IACpB,OAAO,EAAE,WAAW;IACpB,IAAI,EAAE,QAAQ;IACd,aAAa;IACb,MAAM,EAAE,UAAU;IAClB,KAAK,EAAE,SAAS;IAChB,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,UAAU;IAClB,GAAG,EAAE,OAAO;IACZ,GAAG,EAAE,OAAO;IACZ,IAAI,EAAE,QAAQ;IACd,yBAAyB;IACzB,KAAK,EAAE,SAAS;IAChB,kBAAkB,EAAE,sBAAsB;IAC1C,YAAY,EAAE,gBAAgB;IAC9B,YAAY;IACZ,QAAQ,EAAE,YAAY;IACtB,QAAQ,EAAE,YAAY;IACtB,QAAQ,EAAE,YAAY;IACtB,OAAO,EAAE,WAAW;IACpB,IAAI,EAAE,QAAQ;IACd,UAAU;IACV,MAAM,EAAE,UAAU;IAClB,UAAU;IACV,eAAe,EAAE,mBAAmB;IACpC,KAAK,EAAE,SAAS;IAChB,QAAQ,EAAE,YAAY;IACtB,YAAY,EAAE,gBAAgB;IAC9B,UAAU,EAAE,cAAc;CAG3B,CAAC;AAEF,gFAAgF;AAChF,4DAA4D;AAC5D,qDAAqD;AAErD,MAAM,UAAU,aAAa,CAC3B,SAAiB,EACjB,UAAkB,EAClB,QAAgB,EAChB,SAAiB,EACjB,GAAmB;IAEnB,OAAO;QACL,KAAK,EAAE,SAAS;QAChB,MAAM,EAAE,UAAU;QAClB,IAAI,EAAE,QAAQ;QACd,MAAM,EAAE,SAAS;QACjB,GAAG;QACH,KAAK,CAAC,EAAE,EAAE,SAAS;YACjB,OAAO,YAAY,CACjB,EAAE,EACF,aAAa,CACX,SAAS,EAAE,KAAK,IAAI,SAAS,EAC7B,SAAS,EAAE,MAAM,IAAI,UAAU,EAC/B,SAAS,EAAE,IAAI,IAAI,QAAQ,EAC3B,SAAS,EAAE,MAAM,IAAI,SAAS,EAC9B,GAAG,CACJ,CACF,CAAC;QACJ,CAAC;QACD,IAAI,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QACvC,KAAK,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC;QACzE,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC;KACtD,CAAC;AACJ,CAAC;AAED,gFAAgF;AAEhF,MAAM,UAAU,YAAY,CAAC,EAAY,EAAE,CAAU;IACnD,2EAA2E;IAC3E,0EAA0E;IAC1E,MAAM,IAAI,GAAG,EAAE,CAAC,WAAW,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAClF,MAAM,GAAG,GAAG,YAAY,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;IAClC,mGAAmG;IACnG,OAAQ,GAAW,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;AAChC,CAAC"}

package/dist/core/codegen/well-known-regex.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Well-known regex sources hosted in the virtual module "virtual:zod-compiler/runtime".
+ *
+ * In lean mode (unplugin), `g.regex()` consults this registry and emits a reference
+ * like `__zaReEmail` instead of declaring `var __re_email_*=new RegExp(...)`.
+ * The bundler then deduplicates the regex literal across all transformed files.
+ *
+ * Pattern sources are matched verbatim (string equality). Add new entries as Zod
+ * exposes additional well-known formats and we want bundle-wide dedup.
+ */
+/** Zod v4's email regex source (string.ts uses this directly when format === "email"). */
+export declare const EMAIL_REGEX_SOURCE: string;
+/** Fallback UUID regex used when the extractor doesn't provide a pattern (e.g. in unit tests). */
+export declare const UUID_REGEX_SOURCE = "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$";
+export interface WellKnownRegex {
+    /** Stable virtual-module export name. Always starts with "__zaRe". */
+    name: string;
+    /** Pattern source string (verbatim match against `g.regex()` 2nd argument). */
+    source: string;
+}
+export declare const WELL_KNOWN_REGEXES: readonly WellKnownRegex[];
+/**
+ * Look up a well-known regex by its pattern source string.
+ * Returns the virtual-module export name or null if the pattern is user-defined.
+ */
+export declare function lookupWellKnownRegex(source: string): string | null;
+//# sourceMappingURL=well-known-regex.d.ts.map

package/dist/core/codegen/well-known-regex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"well-known-regex.d.ts","sourceRoot":"","sources":["../../../src/core/codegen/well-known-regex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,0FAA0F;AAC1F,eAAO,MAAM,kBAAkB,QAA+G,CAAC;AAE/I,kGAAkG;AAClG,eAAO,MAAM,iBAAiB,2KAC4I,CAAC;AAE3K,MAAM,WAAW,cAAc;IAC7B,sEAAsE;IACtE,IAAI,EAAE,MAAM,CAAC;IACb,+EAA+E;IAC/E,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,kBAAkB,EAAE,SAAS,cAAc,EA6BvD,CAAC;AAMF;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAElE"}

package/dist/core/codegen/well-known-regex.js

@@ -0,0 +1,51 @@
+/**
+ * Well-known regex sources hosted in the virtual module "virtual:zod-compiler/runtime".
+ *
+ * In lean mode (unplugin), `g.regex()` consults this registry and emits a reference
+ * like `__zaReEmail` instead of declaring `var __re_email_*=new RegExp(...)`.
+ * The bundler then deduplicates the regex literal across all transformed files.
+ *
+ * Pattern sources are matched verbatim (string equality). Add new entries as Zod
+ * exposes additional well-known formats and we want bundle-wide dedup.
+ */
+/** Zod v4's email regex source (string.ts uses this directly when format === "email"). */
+export const EMAIL_REGEX_SOURCE = String.raw `^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$`;
+/** Fallback UUID regex used when the extractor doesn't provide a pattern (e.g. in unit tests). */
+export const UUID_REGEX_SOURCE = "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$";
+export const WELL_KNOWN_REGEXES = [
+    { name: "__zaReEmail", source: EMAIL_REGEX_SOURCE },
+    { name: "__zaReUuid", source: UUID_REGEX_SOURCE },
+    { name: "__zaReCuid", source: "^[cC][^\\s-]{8,}$" },
+    { name: "__zaReCuid2", source: "^[0-9a-z]+$" },
+    { name: "__zaReUlid", source: "^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$" },
+    { name: "__zaReNanoid", source: "^[a-zA-Z0-9_-]{21}$" },
+    { name: "__zaReXid", source: "^[0-9a-vA-V]{20}$" },
+    { name: "__zaReKsuid", source: "^[A-Za-z0-9]{27}$" },
+    {
+        name: "__zaReIpv4",
+        source: "^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$",
+    },
+    {
+        name: "__zaReIpv6",
+        source: "^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$",
+    },
+    {
+        name: "__zaReBase64",
+        source: "^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$",
+    },
+    { name: "__zaReBase64Url", source: "^[A-Za-z0-9_-]*$" },
+    { name: "__zaReE164", source: "^\\+[1-9]\\d{6,14}$" },
+    {
+        name: "__zaReGuid",
+        source: "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$",
+    },
+];
+const SOURCE_TO_NAME = new Map(WELL_KNOWN_REGEXES.map((r) => [r.source, r.name]));
+/**
+ * Look up a well-known regex by its pattern source string.
+ * Returns the virtual-module export name or null if the pattern is user-defined.
+ */
+export function lookupWellKnownRegex(source) {
+    return SOURCE_TO_NAME.get(source) ?? null;
+}
+//# sourceMappingURL=well-known-regex.js.map

package/dist/core/codegen/well-known-regex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"well-known-regex.js","sourceRoot":"","sources":["../../../src/core/codegen/well-known-regex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,0FAA0F;AAC1F,MAAM,CAAC,MAAM,kBAAkB,GAAG,MAAM,CAAC,GAAG,CAAA,kGAAkG,CAAC;AAE/I,kGAAkG;AAClG,MAAM,CAAC,MAAM,iBAAiB,GAC5B,wKAAwK,CAAC;AAS3K,MAAM,CAAC,MAAM,kBAAkB,GAA8B;IAC3D,EAAE,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,kBAAkB,EAAE;IACnD,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,iBAAiB,EAAE;IACjD,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,mBAAmB,EAAE;IACnD,EAAE,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE;IAC9C,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,uCAAuC,EAAE;IACvE,EAAE,IAAI,EAAE,cAAc,EAAE,MAAM,EAAE,qBAAqB,EAAE;IACvD,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,mBAAmB,EAAE;IAClD,EAAE,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,mBAAmB,EAAE;IACpD;QACE,IAAI,EAAE,YAAY;QAClB,MAAM,EACJ,sHAAsH;KACzH;IACD;QACE,IAAI,EAAE,YAAY;QAClB,MAAM,EACJ,8XAA8X;KACjY;IACD;QACE,IAAI,EAAE,cAAc;QACpB,MAAM,EAAE,6EAA6E;KACtF;IACD,EAAE,IAAI,EAAE,iBAAiB,EAAE,MAAM,EAAE,kBAAkB,EAAE;IACvD,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,qBAAqB,EAAE;IACrD;QACE,IAAI,EAAE,YAAY;QAClB,MAAM,EAAE,iFAAiF;KAC1F;CACF,CAAC;AAEF,MAAM,cAAc,GAAgC,IAAI,GAAG,CACzD,kBAAkB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAClD,CAAC;AAEF;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CAAC,MAAc;IACjD,OAAO,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC;AAC5C,CAAC"}

package/dist/core/compile.d.ts

@@ -0,0 +1,19 @@
+import type { output, ZodType } from "zod";
+import type { CompiledSchema } from "./types.js";
+/**
+ * Compile a Zod schema into an optimized validator.
+ *
+ * At dev-time, falls back to Zod's runtime validation via Object.create,
+ * preserving full Zod compatibility (e.g. `_zod`, `shape`, `safeParseAsync`).
+ * After `npx zod-compiler generate`, import from the `.compiled.ts` file instead.
+ *
+ * The return type is `T & CompiledSchema<output<T>>`, preserving the original
+ * Zod schema type for compatibility with libraries like `@hono/zod-validator`.
+ */
+export declare function compile<T extends ZodType>(zodSchema: T): T & CompiledSchema<output<T>>;
+/**
+ * Check if a value is a CompiledSchema created by compile().
+ * Used by the CLI to discover schemas in source files.
+ */
+export declare function isCompiledSchema(value: unknown): value is CompiledSchema<unknown>;
+//# sourceMappingURL=compile.d.ts.map

package/dist/core/compile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/core/compile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;AAC3C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAkBjD;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,OAAO,EAAE,SAAS,EAAE,CAAC,GAAG,CAAC,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAItF;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc,CAAC,OAAO,CAAC,CAEjF"}

package/dist/core/compile.js

@@ -0,0 +1,37 @@
+const COMPILED_MARKER = Symbol.for("zod-compiler:compiled");
+/**
+ * Dev-time fallback: wraps Zod schema via Object.create to provide the CompiledSchema interface
+ * while preserving full Zod compatibility (e.g. `_zod`, `shape`, `safeParseAsync`).
+ *
+ * parse/safeParse/parseAsync/safeParseAsync fall through to the original Zod schema via prototype.
+ * Only `schema` is added as an own property.
+ */
+function createFallback(zodSchema) {
+    const facade = Object.create(zodSchema);
+    // Retained for CLI emitter discovery: (__src_X as any).schema resolves the original Zod schema.
+    facade["schema"] = zodSchema;
+    return facade;
+}
+/**
+ * Compile a Zod schema into an optimized validator.
+ *
+ * At dev-time, falls back to Zod's runtime validation via Object.create,
+ * preserving full Zod compatibility (e.g. `_zod`, `shape`, `safeParseAsync`).
+ * After `npx zod-compiler generate`, import from the `.compiled.ts` file instead.
+ *
+ * The return type is `T & CompiledSchema<output<T>>`, preserving the original
+ * Zod schema type for compatibility with libraries like `@hono/zod-validator`.
+ */
+export function compile(zodSchema) {
+    const result = createFallback(zodSchema);
+    Object.defineProperty(result, COMPILED_MARKER, { value: true, enumerable: false });
+    return result;
+}
+/**
+ * Check if a value is a CompiledSchema created by compile().
+ * Used by the CLI to discover schemas in source files.
+ */
+export function isCompiledSchema(value) {
+    return typeof value === "object" && value !== null && COMPILED_MARKER in value;
+}
+//# sourceMappingURL=compile.js.map

package/dist/core/compile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.js","sourceRoot":"","sources":["../../src/core/compile.ts"],"names":[],"mappings":"AAGA,MAAM,eAAe,GAAG,MAAM,CAAC,GAAG,CAAC,uBAAuB,CAAC,CAAC;AAE5D;;;;;;GAMG;AACH,SAAS,cAAc,CAAI,SAAkB;IAC3C,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,SAAmB,CAAsB,CAAC;IACvE,gGAAgG;IAC/F,MAA6C,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAC;IACrE,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,OAAO,CAAoB,SAAY;IACrD,MAAM,MAAM,GAAG,cAAc,CAAY,SAAS,CAAC,CAAC;IACpD,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,eAAe,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC;IACnF,OAAO,MAAuC,CAAC;AACjD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC7C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,eAAe,IAAI,KAAK,CAAC;AACjF,CAAC"}

package/dist/core/diagnostic.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Schema diagnostic utilities for the `check` command.
+ * Walks SchemaIR in a single pass and collects per-node diagnostic info.
+ */
+import type { SchemaIR } from "./types.js";
+export type NodeStatus = "compiled" | "fallback";
+export interface DiagnosticNode {
+    /** SchemaIR type (e.g. "string", "object", "fallback") */
+    type: string;
+    /** Dot-separated path from root (e.g. ".name", ".addresses[]") */
+    path: string;
+    /** Whether this node is compiled or falls back to Zod */
+    status: NodeStatus;
+    /** Fallback reason when status is "fallback" */
+    reason?: string;
+    /** Actionable hint for fixing the fallback */
+    hint?: string;
+    /** Child diagnostic nodes */
+    children: DiagnosticNode[];
+}
+export interface DiagnosticResult {
+    /** Root diagnostic tree */
+    root: DiagnosticNode;
+    /** Total leaf node count */
+    total: number;
+    /** Number of compiled leaf nodes */
+    compilable: number;
+    /** Coverage percentage (0-100) */
+    coveragePct: number;
+    /** Whether the schema is eligible for Fast Path */
+    fastPathEligible: boolean;
+    /** Reason Fast Path is ineligible (when fastPathEligible is false) */
+    fastPathBlocker?: string;
+    /** Flat list of fallback entries for summary display */
+    fallbacks: {
+        reason: string;
+        path: string;
+        hint: string;
+    }[];
+}
+/**
+ * Diagnose a SchemaIR in a single pass.
+ * Returns a diagnostic tree with coverage stats, Fast Path eligibility, and actionable hints.
+ */
+export declare function diagnoseSchema(ir: SchemaIR): DiagnosticResult;
+//# sourceMappingURL=diagnostic.d.ts.map

package/dist/core/diagnostic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostic.d.ts","sourceRoot":"","sources":["../../src/core/diagnostic.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAI3C,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,UAAU,CAAC;AAEjD,MAAM,WAAW,cAAc;IAC7B,0DAA0D;IAC1D,IAAI,EAAE,MAAM,CAAC;IACb,kEAAkE;IAClE,IAAI,EAAE,MAAM,CAAC;IACb,yDAAyD;IACzD,MAAM,EAAE,UAAU,CAAC;IACnB,gDAAgD;IAChD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8CAA8C;IAC9C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,6BAA6B;IAC7B,QAAQ,EAAE,cAAc,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,gBAAgB;IAC/B,2BAA2B;IAC3B,IAAI,EAAE,cAAc,CAAC;IACrB,4BAA4B;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,oCAAoC;IACpC,UAAU,EAAE,MAAM,CAAC;IACnB,kCAAkC;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,mDAAmD;IACnD,gBAAgB,EAAE,OAAO,CAAC;IAC1B,sEAAsE;IACtE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,wDAAwD;IACxD,SAAS,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC7D;AA6KD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,QAAQ,GAAG,gBAAgB,CAgB7D"}

package/dist/core/diagnostic.js

@@ -0,0 +1,174 @@
+/**
+ * Schema diagnostic utilities for the `check` command.
+ * Walks SchemaIR in a single pass and collects per-node diagnostic info.
+ */
+// ─── Fast Path Eligibility ──────────────────────────────────────────────────
+/** Schema types that block Fast Path eligibility. */
+const FAST_PATH_BLOCKERS = new Set(["fallback", "effect", "recursiveRef", "stringBool"]);
+/** Check if a single node blocks Fast Path (without recursing). */
+function detectFastPathBlocker(ir) {
+    if (FAST_PATH_BLOCKERS.has(ir.type)) {
+        return ir.type === "fallback" ? `fallback (${ir.reason})` : ir.type;
+    }
+    if ("coerce" in ir && ir.coerce) {
+        return `coerce (${ir.type})`;
+    }
+    // Value-mutating string checks make the schema slow-path only: overwrite
+    // effects (.trim()/.toLowerCase()) rewrite the value and url checks trim it,
+    // while the fast path returns input unchanged.
+    if (ir.type === "string") {
+        for (const check of ir.checks) {
+            if (check.kind === "overwrite_effect")
+                return "overwrite (.trim()/.toLowerCase())";
+            if (check.kind === "string_format" && check.format === "url")
+                return "url (trims value)";
+        }
+    }
+    return null;
+}
+// ─── Hint Generation ────────────────────────────────────────────────────────
+const FALLBACK_HINTS = {
+    transform: "Extract transform into a separate post-processing step",
+    refine: "Replace .refine() with built-in checks (e.g. .min(), .max(), .regex())",
+    superRefine: "Replace .superRefine() with built-in checks if possible",
+    custom: "Replace z.custom() with a supported schema type",
+    lazy: "Use self-recursive lazy for automatic recursiveRef compilation",
+    unsupported: "This schema type is not yet supported by zod-compiler",
+};
+function getHint(reason) {
+    return FALLBACK_HINTS[reason] ?? "Check zod-compiler documentation for supported schemas";
+}
+// ─── Child Iteration (with path computation) ───────────────────────────────
+/** Yields [childPath, childIR] pairs for a given SchemaIR node. */
+function* iterChildren(ir, parentPath) {
+    switch (ir.type) {
+        case "object":
+            for (const [key, child] of Object.entries(ir.properties)) {
+                yield [`${parentPath}.${key}`, child];
+            }
+            break;
+        case "array":
+            yield [`${parentPath}[]`, ir.element];
+            break;
+        case "tuple":
+            for (const [i, item] of ir.items.entries()) {
+                yield [`${parentPath}[${i}]`, item];
+            }
+            if (ir.rest)
+                yield [`${parentPath}[...rest]`, ir.rest];
+            break;
+        case "record":
+            yield [`${parentPath}[key]`, ir.keyType];
+            yield [`${parentPath}[value]`, ir.valueType];
+            break;
+        case "set":
+            yield [`${parentPath}[element]`, ir.valueType];
+            break;
+        case "map":
+            yield [`${parentPath}[key]`, ir.keyType];
+            yield [`${parentPath}[value]`, ir.valueType];
+            break;
+        case "union":
+        case "discriminatedUnion":
+            for (const [i, opt] of ir.options.entries()) {
+                yield [`${parentPath}[${i}]`, opt];
+            }
+            break;
+        case "intersection":
+            yield [`${parentPath}[left]`, ir.left];
+            yield [`${parentPath}[right]`, ir.right];
+            break;
+        case "optional":
+        case "nullable":
+        case "readonly":
+            yield [parentPath, ir.inner];
+            break;
+        case "default":
+        case "catch":
+            yield [parentPath, ir.inner];
+            break;
+        case "pipe":
+            yield [`${parentPath}[in]`, ir.in];
+            yield [`${parentPath}[out]`, ir.out];
+            break;
+        case "effect":
+            yield [`${parentPath}[inner]`, ir.inner];
+            break;
+    }
+}
+function walkIR(ir, currentPath) {
+    // Fallback leaf
+    if (ir.type === "fallback") {
+        const hint = getHint(ir.reason);
+        const nodePath = currentPath || "(root)";
+        return {
+            node: {
+                type: ir.type,
+                path: nodePath,
+                status: "fallback",
+                reason: ir.reason,
+                hint,
+                children: [],
+            },
+            total: 1,
+            compilable: 0,
+            fallbacks: [{ reason: ir.reason, path: nodePath, hint }],
+            fastPathBlocker: `fallback (${ir.reason})`,
+        };
+    }
+    // Check if this node itself blocks Fast Path
+    let fastPathBlocker = detectFastPathBlocker(ir);
+    // Recurse into children
+    const children = [];
+    let total = 0;
+    let compilable = 0;
+    const fallbacks = [];
+    for (const [childPath, child] of iterChildren(ir, currentPath)) {
+        const r = walkIR(child, childPath);
+        children.push(r.node);
+        total += r.total;
+        compilable += r.compilable;
+        fallbacks.push(...r.fallbacks);
+        if (fastPathBlocker === null && r.fastPathBlocker !== null) {
+            fastPathBlocker = r.fastPathBlocker;
+        }
+    }
+    // Leaf node (no children produced by iterChildren)
+    if (children.length === 0) {
+        total = 1;
+        compilable = 1;
+    }
+    return {
+        node: {
+            type: ir.type,
+            path: currentPath || "(root)",
+            status: "compiled",
+            children,
+        },
+        total,
+        compilable,
+        fallbacks,
+        fastPathBlocker,
+    };
+}
+/**
+ * Diagnose a SchemaIR in a single pass.
+ * Returns a diagnostic tree with coverage stats, Fast Path eligibility, and actionable hints.
+ */
+export function diagnoseSchema(ir) {
+    const { node: root, total, compilable, fallbacks, fastPathBlocker } = walkIR(ir, "");
+    const coveragePct = total > 0 ? Math.round((compilable / total) * 100) : 100;
+    const result = {
+        root,
+        total,
+        compilable,
+        coveragePct,
+        fastPathEligible: fastPathBlocker === null,
+        fallbacks,
+    };
+    if (fastPathBlocker !== null) {
+        result.fastPathBlocker = fastPathBlocker;
+    }
+    return result;
+}
+//# sourceMappingURL=diagnostic.js.map

package/dist/core/diagnostic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostic.js","sourceRoot":"","sources":["../../src/core/diagnostic.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,35 @@
+import type { CheckOrEffectIR } from "../types.js";
+import type { ZodCheckDef, ZodCheckSchema } from "./types.js";
+/** True when a check carries a runtime `when` predicate we cannot reproduce. */
+export declare function hasUserWhen(def: ZodCheckDef): boolean;
+/**
+ * True when a check can't be compiled because of runtime modifiers:
+ * a user-supplied `when` predicate, or `abort: true` (which stops later
+ * checks and marks the option as aborted in union pruning — compiled
+ * output always runs every check).
+ */
+export declare function hasUncompilableModifiers(def: ZodCheckDef): boolean;
+export declare function extractChecks(checks: ZodCheckSchema[]): {
+    checkIRs: CheckOrEffectIR[];
+    hasFallback: boolean;
+};
+export type ResolvedMessage = {
+    kind: "none";
+} | {
+    kind: "static";
+    message: string;
+} | {
+    kind: "dynamic";
+};
+/**
+ * Classify a check/schema-level `error` param.
+ *
+ * Zod normalizes `.min(3, "msg")` / `{ error: "msg" }` / `{ message: "msg" }`
+ * into an error-map function that ignores its issue argument and returns the
+ * string. We call the function with an access-tracking Proxy: if it never
+ * inspects the issue, its return value is a constant we can bake into the
+ * generated issue. If it reads any issue property (input-dependent message),
+ * it is dynamic and the schema must fall back to Zod for exact messages.
+ */
+export declare function resolveCheckMessage(error: unknown): ResolvedMessage;
+//# sourceMappingURL=checks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"checks.d.ts","sourceRoot":"","sources":["../../../src/core/extract/checks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAqB,MAAM,aAAa,CAAC;AAEtE,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAkC9D,gFAAgF;AAChF,wBAAgB,WAAW,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAErD;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAElE;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,cAAc,EAAE,GAAG;IACvD,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,WAAW,EAAE,OAAO,CAAC;CACtB,CAyIA;AAaD,MAAM,MAAM,eAAe,GACvB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACnC;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAAC;AAExB;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CAqDnE"}