zod-compiler 1.23.0 → 1.23.2

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

@@ -1 +1 @@
-{"version":3,"file":"well-known-regex.js","sourceRoot":"","sources":["../../../src/core/codegen/well-known-regex.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"well-known-regex.js","names":[],"sources":["../../../src/core/codegen/well-known-regex.ts"],"sourcesContent":["/**\n * Well-known regex sources hosted in the virtual module \"virtual:zod-compiler/runtime\".\n *\n * In lean mode (unplugin), `g.regex()` consults this registry and emits a reference\n * like `__zcReEmail` instead of declaring `var __re_email_*=new RegExp(...)`.\n * The bundler then deduplicates the regex literal across all transformed files.\n *\n * Pattern sources are matched verbatim (string equality). Add new entries as Zod\n * exposes additional well-known formats and we want bundle-wide dedup.\n */\n\nimport { unrollRepeats } from \"./regex-unroll.js\";\n\n/** Zod v4's email regex source (string.ts uses this directly when format === \"email\"). */\nexport 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,}$`;\n\n/**\n * Behavior-equivalent rewrite of EMAIL_REGEX_SOURCE that runs ~1.45x faster on V8.\n *\n * Zod's pattern fronts two lookaheads; `(?!.*\\.\\.)` re-scans the entire string\n * before matching starts. The rewrite encodes the same constraints structurally:\n * the local part is dot-separated runs of `[A-Za-z0-9_'+-]` (no leading dot, no\n * empty run ⇒ no `..`) ending in `[A-Za-z0-9_+-]`, and the domain grammar already\n * makes `..` impossible (every label starts with an alphanumeric).\n *\n * Equivalence is enforced by tests/core/codegen/email-fast-regex.test.ts\n * (exhaustive short-string sweep + structured cases + random fuzz).\n */\nexport const EMAIL_FAST_REGEX_SOURCE = String.raw`^(?:[A-Za-z0-9_'+\\-]+\\.)*[A-Za-z0-9_'+\\-]*[A-Za-z0-9_+-]@(?:[A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$`;\n\n/** Fallback UUID regex used when the extractor doesn't provide a pattern (e.g. in unit tests). */\nexport const UUID_REGEX_SOURCE =\n  \"^([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)$\";\n\nexport interface WellKnownRegex {\n  /** Stable virtual-module export name. Always starts with \"__zcRe\". */\n  name: string;\n  /** Pattern source string (verbatim match against `g.regex()` 2nd argument). */\n  source: string;\n  /**\n   * Behavior-equivalent faster pattern used for the actual `.test()` regex.\n   * Issue reporting (`pattern:` field) always uses `source` so generated\n   * issues stay byte-identical to zod's.\n   */\n  testSource?: string;\n}\n\nexport const WELL_KNOWN_REGEXES: readonly WellKnownRegex[] = [\n  { name: \"__zcReEmail\", source: EMAIL_REGEX_SOURCE, testSource: EMAIL_FAST_REGEX_SOURCE },\n  { name: \"__zcReUuid\", source: UUID_REGEX_SOURCE },\n  { name: \"__zcReCuid\", source: \"^[cC][^\\\\s-]{8,}$\" },\n  { name: \"__zcReCuid2\", source: \"^[0-9a-z]+$\" },\n  { name: \"__zcReUlid\", source: \"^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$\" },\n  { name: \"__zcReNanoid\", source: \"^[a-zA-Z0-9_-]{21}$\" },\n  { name: \"__zcReXid\", source: \"^[0-9a-vA-V]{20}$\" },\n  { name: \"__zcReKsuid\", source: \"^[A-Za-z0-9]{27}$\" },\n  {\n    name: \"__zcReIpv4\",\n    source:\n      \"^(?:(?: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])$\",\n  },\n  {\n    name: \"__zcReIpv6\",\n    source:\n      \"^(([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}|:))$\",\n  },\n  {\n    name: \"__zcReBase64\",\n    source: \"^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$\",\n  },\n  { name: \"__zcReBase64Url\", source: \"^[A-Za-z0-9_-]*$\" },\n  { name: \"__zcReE164\", source: \"^\\\\+[1-9]\\\\d{6,14}$\" },\n  {\n    name: \"__zcReGuid\",\n    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})$\",\n  },\n];\n\nconst SOURCE_TO_NAME: ReadonlyMap<string, string> = new Map(\n  WELL_KNOWN_REGEXES.map((r) => [r.source, r.name]),\n);\n\nconst SOURCE_TO_TEST_SOURCE: ReadonlyMap<string, string> = new Map(\n  WELL_KNOWN_REGEXES.filter((r) => r.testSource !== undefined).map((r) => [\n    r.source,\n    r.testSource as string,\n  ]),\n);\n\n/**\n * Look up a well-known regex by its pattern source string.\n * Returns the virtual-module export name or null if the pattern is user-defined.\n */\nexport function lookupWellKnownRegex(source: string): string | null {\n  return SOURCE_TO_NAME.get(source) ?? null;\n}\n\n/**\n * Look up the hand-written behavior-equivalent test pattern for a regex source.\n * Returns null when no rewrite is registered in {@link WELL_KNOWN_REGEXES}.\n *\n * This is the TABLE lookup only. Codegen calls {@link fastTestSource}, which\n * layers automatic repeat unrolling on top and also covers user-supplied\n * patterns that are in no table.\n */\nexport function lookupFastRegexSource(source: string): string | null {\n  return SOURCE_TO_TEST_SOURCE.get(source) ?? null;\n}\n\n/**\n * The pattern a generated `.test()` should actually run for `source`, or null\n * when `source` is already the best form.\n *\n * Two behavior-preserving rewrites compose here: the hand-written table entry\n * above (currently just email), then {@link unrollRepeats}, which turns bounded\n * repeats of single-character atoms into explicit repetition — worth 1.3-3.4x\n * on the string formats everyday schemas use (uuid, guid, ulid, nanoid, xid,\n * ksuid, base64, e164, iso.date). Unrolling runs on the table rewrite when\n * there is one, so the two stack.\n *\n * Callers must apply this only to flag-less regexes (the flagged form would\n * need its flags carried into the reported pattern too) and must keep\n * reporting the ORIGINAL source in issues — see `emitRegexSourceString`.\n */\nexport function fastTestSource(source: string): string | null {\n  const tableRewrite = SOURCE_TO_TEST_SOURCE.get(source) ?? null;\n  return unrollRepeats(tableRewrite ?? source) ?? tableRewrite;\n}\n\n/**\n * Virtual-module export name for the ORIGINAL `/source/` pattern string of a\n * rewritten well-known regex (e.g. \"__zcReEmailSrc\"). Issue sites reference it\n * so the original pattern stays a single bundle-wide string even though the\n * runtime regex object is built from testSource.\n */\nexport function wellKnownRegexSourceName(source: string): string | null {\n  const name = SOURCE_TO_NAME.get(source);\n  if (name === undefined) return null;\n  return fastTestSource(source) !== null ? `${name}Src` : null;\n}\n"],"mappings":";;;;;;;;;;;;;AAcA,MAAa,qBAAqB,OAAO,GAAG;;;;;;;;;;;;;AAc5C,MAAa,0BAA0B,OAAO,GAAG;;AAGjD,MAAa,oBACX;AAeF,MAAa,qBAAgD;CAC3D;EAAE,MAAM;EAAe,QAAQ;EAAoB,YAAY;CAAwB;CACvF;EAAE,MAAM;EAAc,QAAQ;CAAkB;CAChD;EAAE,MAAM;EAAc,QAAQ;CAAoB;CAClD;EAAE,MAAM;EAAe,QAAQ;CAAc;CAC7C;EAAE,MAAM;EAAc,QAAQ;CAAwC;CACtE;EAAE,MAAM;EAAgB,QAAQ;CAAsB;CACtD;EAAE,MAAM;EAAa,QAAQ;CAAoB;CACjD;EAAE,MAAM;EAAe,QAAQ;CAAoB;CACnD;EACE,MAAM;EACN,QACE;CACJ;CACA;EACE,MAAM;EACN,QACE;CACJ;CACA;EACE,MAAM;EACN,QAAQ;CACV;CACA;EAAE,MAAM;EAAmB,QAAQ;CAAmB;CACtD;EAAE,MAAM;EAAc,QAAQ;CAAsB;CACpD;EACE,MAAM;EACN,QAAQ;CACV;AACF;AAEA,MAAM,iBAA8C,IAAI,IACtD,mBAAmB,KAAK,MAAM,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,CAClD;AAEA,MAAM,wBAAqD,IAAI,IAC7D,mBAAmB,QAAQ,MAAM,EAAE,eAAe,KAAA,CAAS,CAAC,CAAC,KAAK,MAAM,CACtE,EAAE,QACF,EAAE,UACJ,CAAC,CACH;;;;;AAMA,SAAgB,qBAAqB,QAA+B;CAClE,OAAO,eAAe,IAAI,MAAM,KAAK;AACvC;;;;;;;;;AAUA,SAAgB,sBAAsB,QAA+B;CACnE,OAAO,sBAAsB,IAAI,MAAM,KAAK;AAC9C;;;;;;;;;;;;;;;;AAiBA,SAAgB,eAAe,QAA+B;CAC5D,MAAM,eAAe,sBAAsB,IAAI,MAAM,KAAK;CAC1D,OAAO,cAAc,gBAAgB,MAAM,KAAK;AAClD;;;;;;;AAQA,SAAgB,yBAAyB,QAA+B;CACtE,MAAM,OAAO,eAAe,IAAI,MAAM;CACtC,IAAI,SAAS,KAAA,GAAW,OAAO;CAC/B,OAAO,eAAe,MAAM,MAAM,OAAO,GAAG,KAAK,OAAO;AAC1D"}

package/dist/core/compile.d.ts

@@ -1,5 +1,6 @@
-import type { output, ZodType } from "zod";
-import type { CompiledSchema } from "./types.js";
+import { CompiledSchema } from "./types.js";
+import { ZodType, output } from "zod";
+//#region src/core/compile.d.ts
 /**
  * Compile a Zod schema into an optimized validator.
  *
@@ -11,10 +12,12 @@ import type { CompiledSchema } from "./types.js";
  * 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>>;
+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>;
+declare function isCompiledSchema(value: unknown): value is CompiledSchema<unknown>;
+//#endregion
+export { compile, isCompiledSchema };
 //# sourceMappingURL=compile.d.ts.map

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

@@ -1 +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;AAmCjD;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,OAAO,EAAE,SAAS,EAAE,CAAC,GAAG,CAAC,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAMtF;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc,CAAC,OAAO,CAAC,CAEjF"}
+{"version":3,"file":"compile.d.ts","names":[],"sources":["../../src/core/compile.ts"],"mappings":";;;;;;;;;;;;;;iBA+CgB,QAAQ,UAAU,SAAS,WAAW,IAAI,IAAI,eAAe,OAAO;;;;;iBAYpE,iBAAiB,iBAAiB,SAAS"}

package/dist/core/compile.js

@@ -1,57 +1,57 @@
+//#region src/core/compile.ts
 const COMPILED_MARKER = Symbol.for("zod-compiler:compiled");
 /**
- * Dev-time fallback: returns the ORIGINAL schema object, augmented with a
- * non-enumerable `schema` self-reference (CLI emitter discovery reads
- * `(__src_X as any).schema`) and the compiled marker.
- *
- * Identity preservation is load-bearing: zod v4 keys toJSONSchema's
- * processing context and globalRegistry/.meta() on schema object identity —
- * an Object.create facade crashes toJSONSchema the moment the compiled
- * schema is composed into another schema, and silently loses .meta()
- * metadata. parse/safeParse/... remain the schema's own zod methods.
- */
+* Dev-time fallback: returns the ORIGINAL schema object, augmented with a
+* non-enumerable `schema` self-reference (CLI emitter discovery reads
+* `(__src_X as any).schema`) and the compiled marker.
+*
+* Identity preservation is load-bearing: zod v4 keys toJSONSchema's
+* processing context and globalRegistry/.meta() on schema object identity —
+* an Object.create facade crashes toJSONSchema the moment the compiled
+* schema is composed into another schema, and silently loses .meta()
+* metadata. parse/safeParse/... remain the schema's own zod methods.
+*/
 function createFallback(zodSchema) {
-    const facade = zodSchema;
-    if (!("schema" in facade)) {
-        Object.defineProperty(facade, "schema", { value: zodSchema, enumerable: false });
-    }
-    // Dev-time `.is`: delegates to zod's own safeParse so the boolean guard works
-    // before `zod-compiler generate` runs. The build replaces this with the
-    // compiled fast-check (zero-allocation) via __zcMkv. Non-enumerable to keep
-    // the augmentation invisible on the identity-preserved schema object.
-    if (!("is" in facade)) {
-        Object.defineProperty(facade, "is", {
-            value: (input) => facade.safeParse(input).success,
-            enumerable: false,
-            configurable: true,
-            writable: true,
-        });
-    }
-    return facade;
+	const facade = zodSchema;
+	if (!("schema" in facade)) Object.defineProperty(facade, "schema", {
+		value: zodSchema,
+		enumerable: false
+	});
+	if (!("is" in facade)) Object.defineProperty(facade, "is", {
+		value: (input) => facade.safeParse(input).success,
+		enumerable: false,
+		configurable: true,
+		writable: true
+	});
+	return facade;
 }
 /**
- * Compile a Zod schema into an optimized validator.
- *
- * At dev-time, falls back to Zod's runtime validation: the schema itself is
- * returned (identity-preserving for toJSONSchema/.meta()), tagged with the
- * compiled marker so build-time discovery can find it.
- * 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);
-    if (!(COMPILED_MARKER in result)) {
-        Object.defineProperty(result, COMPILED_MARKER, { value: true, enumerable: false });
-    }
-    return result;
+* Compile a Zod schema into an optimized validator.
+*
+* At dev-time, falls back to Zod's runtime validation: the schema itself is
+* returned (identity-preserving for toJSONSchema/.meta()), tagged with the
+* compiled marker so build-time discovery can find it.
+* 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`.
+*/
+function compile(zodSchema) {
+	const result = createFallback(zodSchema);
+	if (!(COMPILED_MARKER in result)) 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;
+* Check if a value is a CompiledSchema created by compile().
+* Used by the CLI to discover schemas in source files.
+*/
+function isCompiledSchema(value) {
+	return typeof value === "object" && value !== null && COMPILED_MARKER in value;
 }
+//#endregion
+export { compile, isCompiledSchema };
+
 //# sourceMappingURL=compile.js.map

package/dist/core/compile.js.map

@@ -1 +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;;;;;;;;;;GAUG;AACH,SAAS,cAAc,CAAI,SAAkB;IAC3C,MAAM,MAAM,GAAG,SAA8B,CAAC;IAC9C,IAAI,CAAC,CAAC,QAAQ,IAAK,MAAiB,CAAC,EAAE,CAAC;QACtC,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC;IACnF,CAAC;IACD,8EAA8E;IAC9E,wEAAwE;IACxE,4EAA4E;IAC5E,sEAAsE;IACtE,IAAI,CAAC,CAAC,IAAI,IAAK,MAAiB,CAAC,EAAE,CAAC;QAClC,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,IAAI,EAAE;YAClC,KAAK,EAAE,CAAC,KAAc,EAAW,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,OAAO;YACnE,UAAU,EAAE,KAAK;YACjB,YAAY,EAAE,IAAI;YAClB,QAAQ,EAAE,IAAI;SACf,CAAC,CAAC;IACL,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,OAAO,CAAoB,SAAY;IACrD,MAAM,MAAM,GAAG,cAAc,CAAY,SAAS,CAAC,CAAC;IACpD,IAAI,CAAC,CAAC,eAAe,IAAK,MAAiB,CAAC,EAAE,CAAC;QAC7C,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,eAAe,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC;IACrF,CAAC;IACD,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"}
+{"version":3,"file":"compile.js","names":[],"sources":["../../src/core/compile.ts"],"sourcesContent":["import type { output, ZodType } from \"zod\";\nimport type { CompiledSchema } from \"./types.js\";\n\nconst COMPILED_MARKER = Symbol.for(\"zod-compiler:compiled\");\n\n/**\n * Dev-time fallback: returns the ORIGINAL schema object, augmented with a\n * non-enumerable `schema` self-reference (CLI emitter discovery reads\n * `(__src_X as any).schema`) and the compiled marker.\n *\n * Identity preservation is load-bearing: zod v4 keys toJSONSchema's\n * processing context and globalRegistry/.meta() on schema object identity —\n * an Object.create facade crashes toJSONSchema the moment the compiled\n * schema is composed into another schema, and silently loses .meta()\n * metadata. parse/safeParse/... remain the schema's own zod methods.\n */\nfunction createFallback<T>(zodSchema: unknown): CompiledSchema<T> {\n  const facade = zodSchema as CompiledSchema<T>;\n  if (!(\"schema\" in (facade as object))) {\n    Object.defineProperty(facade, \"schema\", { value: zodSchema, enumerable: false });\n  }\n  // Dev-time `.is`: delegates to zod's own safeParse so the boolean guard works\n  // before `zod-compiler generate` runs. The build replaces this with the\n  // compiled fast-check (zero-allocation) via __zcMkv. Non-enumerable to keep\n  // the augmentation invisible on the identity-preserved schema object.\n  if (!(\"is\" in (facade as object))) {\n    Object.defineProperty(facade, \"is\", {\n      value: (input: unknown): boolean => facade.safeParse(input).success,\n      enumerable: false,\n      configurable: true,\n      writable: true,\n    });\n  }\n  return facade;\n}\n\n/**\n * Compile a Zod schema into an optimized validator.\n *\n * At dev-time, falls back to Zod's runtime validation: the schema itself is\n * returned (identity-preserving for toJSONSchema/.meta()), tagged with the\n * compiled marker so build-time discovery can find it.\n * After `npx zod-compiler generate`, import from the `.compiled.ts` file instead.\n *\n * The return type is `T & CompiledSchema<output<T>>`, preserving the original\n * Zod schema type for compatibility with libraries like `@hono/zod-validator`.\n */\nexport function compile<T extends ZodType>(zodSchema: T): T & CompiledSchema<output<T>> {\n  const result = createFallback<output<T>>(zodSchema);\n  if (!(COMPILED_MARKER in (result as object))) {\n    Object.defineProperty(result, COMPILED_MARKER, { value: true, enumerable: false });\n  }\n  return result as T & CompiledSchema<output<T>>;\n}\n\n/**\n * Check if a value is a CompiledSchema created by compile().\n * Used by the CLI to discover schemas in source files.\n */\nexport function isCompiledSchema(value: unknown): value is CompiledSchema<unknown> {\n  return typeof value === \"object\" && value !== null && COMPILED_MARKER in value;\n}\n"],"mappings":";AAGA,MAAM,kBAAkB,OAAO,IAAI,uBAAuB;;;;;;;;;;;;AAa1D,SAAS,eAAkB,WAAuC;CAChE,MAAM,SAAS;CACf,IAAI,EAAE,YAAa,SACjB,OAAO,eAAe,QAAQ,UAAU;EAAE,OAAO;EAAW,YAAY;CAAM,CAAC;CAMjF,IAAI,EAAE,QAAS,SACb,OAAO,eAAe,QAAQ,MAAM;EAClC,QAAQ,UAA4B,OAAO,UAAU,KAAK,CAAC,CAAC;EAC5D,YAAY;EACZ,cAAc;EACd,UAAU;CACZ,CAAC;CAEH,OAAO;AACT;;;;;;;;;;;;AAaA,SAAgB,QAA2B,WAA6C;CACtF,MAAM,SAAS,eAA0B,SAAS;CAClD,IAAI,EAAE,mBAAoB,SACxB,OAAO,eAAe,QAAQ,iBAAiB;EAAE,OAAO;EAAM,YAAY;CAAM,CAAC;CAEnF,OAAO;AACT;;;;;AAMA,SAAgB,iBAAiB,OAAkD;CACjF,OAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,mBAAmB;AAC3E"}

package/dist/core/diagnostic.d.ts

@@ -1,46 +1,45 @@
-/**
- * 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[];
+import { SchemaIR } from "./types.js";
+//#region src/core/diagnostic.d.ts
+type NodeStatus = "compiled" | "fallback";
+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;
-    }[];
+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;
+declare function diagnoseSchema(ir: SchemaIR): DiagnosticResult;
+//#endregion
+export { DiagnosticNode, DiagnosticResult, NodeStatus, diagnoseSchema };
 //# sourceMappingURL=diagnostic.d.ts.map

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

@@ -1 +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;AAoLD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,QAAQ,GAAG,gBAAgB,CAgB7D"}
+{"version":3,"file":"diagnostic.d.ts","names":[],"sources":["../../src/core/diagnostic.ts"],"mappings":";;KASY;UAEK;;EAEf;;EAEA;;EAEA,QAAQ;;EAER;;EAEA;;EAEA,UAAU;;UAGK;;EAEf,MAAM;;EAEN;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;IAAa;IAAgB;IAAc;;;;;;;iBAyL7B,eAAe,IAAI,WAAW"}

package/dist/core/diagnostic.js

@@ -1,180 +1,156 @@
-/**
- * Schema diagnostic utilities for the `check` command.
- * Walks SchemaIR in a single pass and collects per-node diagnostic info.
- */
-// ─── Fast Path Eligibility ──────────────────────────────────────────────────
+//#region src/core/diagnostic.ts
 /** Schema types that block Fast Path eligibility. */
-const FAST_PATH_BLOCKERS = new Set(["fallback", "effect", "stringBool"]);
+const FAST_PATH_BLOCKERS = /* @__PURE__ */ new Set([
+	"fallback",
+	"effect",
+	"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;
+	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})`;
+	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: "Ensure the lazy getter resolves to a static schema (recursion compiles automatically)",
-    unsupported: "This schema type is not yet supported by zod-compiler",
-    coalesced: "Every property falls back to Zod, so the whole object is delegated once (faster than per-field delegation)",
+	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: "Ensure the lazy getter resolves to a static schema (recursion compiles automatically)",
+	unsupported: "This schema type is not yet supported by zod-compiler",
+	coalesced: "Every property falls back to Zod, so the whole object is delegated once (faster than per-field delegation)"
 };
 function getHint(reason) {
-    return FALLBACK_HINTS[reason] ?? "Check zod-compiler documentation for supported schemas";
+	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;
-        case "recursionTarget":
-            // Transparent wrapper around a non-root recursive sub-schema: descend so
-            // coverage and any inner fallbacks are reported at the same path.
-            yield [parentPath, ir.inner];
-            break;
-    }
+	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;
+		case "recursionTarget":
+			yield [parentPath, 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,
-    };
+	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})`
+		};
+	}
+	let fastPathBlocker = detectFastPathBlocker(ir);
+	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;
+	}
+	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;
+* Diagnose a SchemaIR in a single pass.
+* Returns a diagnostic tree with coverage stats, Fast Path eligibility, and actionable hints.
+*/
+function diagnoseSchema(ir) {
+	const { node: root, total, compilable, fallbacks, fastPathBlocker } = walkIR(ir, "");
+	const result = {
+		root,
+		total,
+		compilable,
+		coveragePct: total > 0 ? Math.round(compilable / total * 100) : 100,
+		fastPathEligible: fastPathBlocker === null,
+		fallbacks
+	};
+	if (fastPathBlocker !== null) result.fastPathBlocker = fastPathBlocker;
+	return result;
 }
+//#endregion
+export { diagnoseSchema };
+
 //# sourceMappingURL=diagnostic.js.map