zod-compiler 1.28.0 → 2.0.1

package/dist/core/codegen/schemas/record.js

@@ -1,7 +1,7 @@
 import { declareFastTemps, emitRuntimeHelper, extendPath, hasMutation } from "../context.js";
 import { emit } from "../emit.js";
-import { invalidType } from "../emit-issue.js";
-import { ZC_FZ_DECL, ZC_HOP_DECL, ZC_PLAIN_DECL } from "../issue-decls.js";
+import { invalidType, unrecognizedKeys } from "../emit-issue.js";
+import { ZC_FZ_DECL, ZC_HOP_DECL, ZC_PLAIN_DECL, ZC_PROTO_SCRUB_DECL } from "../issue-decls.js";
 //#region src/core/codegen/schemas/record.ts
 /**
 * `$ZodRecord` gates on `util.isPlainObject`, NOT the looser `util.isObject`
@@ -26,13 +26,17 @@ function slowRecord(ir, g) {
       ${invalidType(g, "record")}
     }else{`;
 	if (hasMutation(ir.valueType)) code += `${g.output}={...${g.input}};`;
+	code += `${g.output}=${emitRuntimeHelper(g.ctx, "__zcPs", ZC_PROTO_SCRUB_DECL)}(${g.input});`;
 	const keyVar = g.temp("rkey");
 	const keyIssuesVar = g.temp("rki");
 	const keyPath = extendPath(g.path, keyVar);
 	const valExpr = `${g.input}[${keyVar}]`;
 	const hop = emitRuntimeHelper(g.ctx, "__zcHop", ZC_HOP_DECL);
 	const fz = emitRuntimeHelper(g.ctx, "__zcFz", ZC_FZ_DECL);
+	const unrecognizedVar = ir.enumerableKeys ? g.temp("ruk") : null;
+	const onKeyFailure = unrecognizedVar === null ? `${g.issues}.push({code:"invalid_key",origin:"record",issues:${fz}(${keyIssuesVar}),input:${keyVar},path:${keyPath}${g.typeMsg === void 0 ? "" : `,message:${JSON.stringify(g.typeMsg)}`}});` : `(${unrecognizedVar}=${unrecognizedVar}||[]).push(${keyVar});`;
 	code += emit`
+    ${unrecognizedVar === null ? "" : `var ${unrecognizedVar}=null;`}
     for(var ${keyVar} in ${g.input}){
       if(!${hop}.call(${g.input},${keyVar}))continue;
       ${PROTO_SKIP(keyVar)}
@@ -44,7 +48,7 @@ function slowRecord(ir, g) {
 		issues: keyIssuesVar
 	})}
       if(${keyIssuesVar}.length>0){
-        ${g.issues}.push({code:"invalid_key",origin:"record",issues:${fz}(${keyIssuesVar}),input:${keyVar},path:${keyPath}${g.typeMsg === void 0 ? "" : `,message:${JSON.stringify(g.typeMsg)}`}});
+        ${onKeyFailure}
       }else{
         ${g.visit(ir.valueType, {
 		input: valExpr,
@@ -53,6 +57,7 @@ function slowRecord(ir, g) {
 	})}
       }
     }
+    ${unrecognizedVar === null ? "" : `if(${unrecognizedVar}!==null){${unrecognizedKeys(g, unrecognizedVar)}}`}
   }`;
 	return `${code}\n`;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"record.js","names":[],"sources":["../../../../src/core/codegen/schemas/record.ts"],"sourcesContent":["import type { RecordIR, SchemaIR } from \"../../types.js\";\nimport type { FastGen, SlowGen } from \"../context.js\";\nimport { declareFastTemps, emitRuntimeHelper, extendPath, hasMutation } from \"../context.js\";\nimport { emit } from \"../emit.js\";\nimport { invalidType } from \"../emit-issue.js\";\nimport { ZC_FZ_DECL, ZC_HOP_DECL, ZC_PLAIN_DECL } from \"../issue-decls.js\";\n\n/**\n * `$ZodRecord` gates on `util.isPlainObject`, NOT the looser `util.isObject`\n * that `$ZodObject` uses — see {@link ZC_PLAIN_DECL} for why the two differ and\n * what accepting the wrong one lets through.\n */\nfunction plainObjectTest(g: SlowGen | FastGen, input: string): string {\n  return `${emitRuntimeHelper(g.ctx, \"__zcPlain\", ZC_PLAIN_DECL)}(${input})`;\n}\n\n/**\n * Zod's record walk opens with `if (key === \"__proto__\") continue`, so an own\n * `__proto__` data property (which `JSON.parse('{\"__proto__\":…}')` creates) is\n * neither key-validated nor value-validated nor copied. Without this the\n * compiled walk reported issues zod does not: `z.record(z.string(), z.number())`\n * over such an object raised a SECOND `invalid_type`, and a constrained key\n * schema a second `invalid_key`, for a key zod never looks at.\n */\nconst PROTO_SKIP = (keyVar: string): string => `if(${keyVar}===\"__proto__\")continue;`;\n\nexport function slowRecord(ir: SchemaIR & { type: \"record\" }, g: SlowGen): string {\n  let code = emit`\n    if(!${plainObjectTest(g, g.input)}){\n      ${invalidType(g, \"record\")}\n    }else{`;\n\n  if (hasMutation(ir.valueType)) {\n    code += `${g.output}={...${g.input}};`;\n  }\n\n  const keyVar = g.temp(\"rkey\");\n  const keyIssuesVar = g.temp(\"rki\");\n  const keyPath = extendPath(g.path, keyVar);\n  const valExpr = `${g.input}[${keyVar}]`;\n  // for-in + hasOwnProperty guard instead of Object.keys(): identical\n  // own-enumerable string-key set and iteration order, no keys-array\n  // allocation. When the value type mutates (coerce/default/.trim()) the clone\n  // above has already replaced g.input, so this iterates the clone exactly as\n  // the Object.keys form did — the key set is stable (values change, keys\n  // don't). Records whose values mutate run this path eagerly, so they get the\n  // same speedup the fast path does.\n  const hop = emitRuntimeHelper(g.ctx, \"__zcHop\", ZC_HOP_DECL);\n\n  // The key is validated at a RELATIVE path and its issues are finalized before\n  // being nested, mirroring zod: `issues: keyResult.issues.map(finalizeIssue)`\n  // over a payload zod ran fresh. Nested issues never reach the top-level\n  // finalization loop (it walks only the outer array), so an unfinalized nest\n  // leaked absolute paths and the raw `input` into the reported error.\n  const fz = emitRuntimeHelper(g.ctx, \"__zcFz\", ZC_FZ_DECL);\n\n  code += emit`\n    for(var ${keyVar} in ${g.input}){\n      if(!${hop}.call(${g.input},${keyVar}))continue;\n      ${PROTO_SKIP(keyVar)}\n      var ${keyIssuesVar}=[];\n      ${g.visit(ir.keyType, { input: keyVar, output: keyVar, path: \"[]\", issues: keyIssuesVar })}\n      if(${keyIssuesVar}.length>0){\n        ${g.issues}.push({code:\"invalid_key\",origin:\"record\",issues:${fz}(${keyIssuesVar}),input:${keyVar},path:${keyPath}${g.typeMsg === undefined ? \"\" : `,message:${JSON.stringify(g.typeMsg)}`}});\n      }else{\n        ${g.visit(ir.valueType, { input: valExpr, output: valExpr, path: keyPath })}\n      }\n    }\n  }`;\n  return `${code}\\n`;\n}\n\nexport function fastRecord(ir: RecordIR, g: FastGen): string | null {\n  const x = g.input;\n  const parts: string[] = [plainObjectTest(g, x)];\n\n  // Object.keys only yields strings — a plain unconstrained string key schema\n  // is always satisfied, so skip generating its check entirely.\n  const plainStringKey =\n    ir.keyType.type === \"string\" && ir.keyType.checks.length === 0 && ir.keyType.coerce !== true;\n\n  const kv = g.temp(\"rk\");\n  const vv = g.temp(\"rv\");\n  // Key + value checks share one fresh scope — they live in the same emitted\n  // helper function, size-gated independently of the caller.\n  const body = g.scoped(kv);\n  const keyCheck = plainStringKey ? \"true\" : body.visit(ir.keyType, { input: kv });\n  // Hoist o[k] into a loop variable: computed-key lookups don't get V8's load\n  // elimination across check boundaries, so each repeated o[k] would re-walk\n  // the (often dictionary-mode) object.\n  const valCheck = body.visit(ir.valueType, { input: vv });\n  if (keyCheck === null || valCheck === null) return null;\n\n  const conditions: string[] = [];\n  if (keyCheck !== \"true\") conditions.push(keyCheck);\n  if (valCheck !== \"true\") conditions.push(valCheck);\n\n  if (conditions.length > 0) {\n    const helperName = g.temp(\"rf\");\n    const valAssign = valCheck !== \"true\" ? `${vv}=o[${kv}];` : \"\";\n    // for-in (no Object.keys array allocation) + hasOwnProperty guard. The\n    // guard restricts iteration to own enumerable string keys — the exact set\n    // Object.keys/the slow path produce — so inherited enumerable props can't\n    // make the fast check disagree with the deferred slow walk. Measured 2.9x\n    // (5 keys) to 5.8x (20 keys) faster than the Object.keys form; the hoisted\n    // __zcHop.call inlines, making the guard ~free vs an unguarded for-in.\n    const hop = emitRuntimeHelper(g.ctx, \"__zcHop\", ZC_HOP_DECL);\n    g.ctx.preamble.push(\n      `function ${helperName}(o){${declareFastTemps(body.scope)}var ${kv},${vv};for(${kv} in o){${PROTO_SKIP(kv)}if(${hop}.call(o,${kv})){${valAssign}if(!(${conditions.join(\"&&\")})){return false;}}}return true;}`,\n    );\n    parts.push(`${helperName}(${x})`);\n  }\n\n  return parts.join(\"&&\");\n}\n"],"mappings":";;;;;;;;;;AAYA,SAAS,gBAAgB,GAAsB,OAAuB;CACpE,OAAO,GAAG,kBAAkB,EAAE,KAAK,aAAa,aAAa,EAAE,GAAG,MAAM;AAC1E;;;;;;;;;AAUA,MAAM,cAAc,WAA2B,MAAM,OAAO;AAE5D,SAAgB,WAAW,IAAmC,GAAoB;CAChF,IAAI,OAAO,IAAI;UACP,gBAAgB,GAAG,EAAE,KAAK,EAAE;QAC9B,YAAY,GAAG,QAAQ,EAAE;;CAG/B,IAAI,YAAY,GAAG,SAAS,GAC1B,QAAQ,GAAG,EAAE,OAAO,OAAO,EAAE,MAAM;CAGrC,MAAM,SAAS,EAAE,KAAK,MAAM;CAC5B,MAAM,eAAe,EAAE,KAAK,KAAK;CACjC,MAAM,UAAU,WAAW,EAAE,MAAM,MAAM;CACzC,MAAM,UAAU,GAAG,EAAE,MAAM,GAAG,OAAO;CAQrC,MAAM,MAAM,kBAAkB,EAAE,KAAK,WAAW,WAAW;CAO3D,MAAM,KAAK,kBAAkB,EAAE,KAAK,UAAU,UAAU;CAExD,QAAQ,IAAI;cACA,OAAO,MAAM,EAAE,MAAM;YACvB,IAAI,QAAQ,EAAE,MAAM,GAAG,OAAO;QAClC,WAAW,MAAM,EAAE;YACf,aAAa;QACjB,EAAE,MAAM,GAAG,SAAS;EAAE,OAAO;EAAQ,QAAQ;EAAQ,MAAM;EAAM,QAAQ;CAAa,CAAC,EAAE;WACtF,aAAa;UACd,EAAE,OAAO,mDAAmD,GAAG,GAAG,aAAa,UAAU,OAAO,QAAQ,UAAU,EAAE,YAAY,KAAA,IAAY,KAAK,YAAY,KAAK,UAAU,EAAE,OAAO,IAAI;;UAEzL,EAAE,MAAM,GAAG,WAAW;EAAE,OAAO;EAAS,QAAQ;EAAS,MAAM;CAAQ,CAAC,EAAE;;;;CAIlF,OAAO,GAAG,KAAK;AACjB;AAEA,SAAgB,WAAW,IAAc,GAA2B;CAClE,MAAM,IAAI,EAAE;CACZ,MAAM,QAAkB,CAAC,gBAAgB,GAAG,CAAC,CAAC;CAI9C,MAAM,iBACJ,GAAG,QAAQ,SAAS,YAAY,GAAG,QAAQ,OAAO,WAAW,KAAK,GAAG,QAAQ,WAAW;CAE1F,MAAM,KAAK,EAAE,KAAK,IAAI;CACtB,MAAM,KAAK,EAAE,KAAK,IAAI;CAGtB,MAAM,OAAO,EAAE,OAAO,EAAE;CACxB,MAAM,WAAW,iBAAiB,SAAS,KAAK,MAAM,GAAG,SAAS,EAAE,OAAO,GAAG,CAAC;CAI/E,MAAM,WAAW,KAAK,MAAM,GAAG,WAAW,EAAE,OAAO,GAAG,CAAC;CACvD,IAAI,aAAa,QAAQ,aAAa,MAAM,OAAO;CAEnD,MAAM,aAAuB,CAAC;CAC9B,IAAI,aAAa,QAAQ,WAAW,KAAK,QAAQ;CACjD,IAAI,aAAa,QAAQ,WAAW,KAAK,QAAQ;CAEjD,IAAI,WAAW,SAAS,GAAG;EACzB,MAAM,aAAa,EAAE,KAAK,IAAI;EAC9B,MAAM,YAAY,aAAa,SAAS,GAAG,GAAG,KAAK,GAAG,MAAM;EAO5D,MAAM,MAAM,kBAAkB,EAAE,KAAK,WAAW,WAAW;EAC3D,EAAE,IAAI,SAAS,KACb,YAAY,WAAW,MAAM,iBAAiB,KAAK,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,OAAO,GAAG,SAAS,WAAW,EAAE,EAAE,KAAK,IAAI,UAAU,GAAG,KAAK,UAAU,OAAO,WAAW,KAAK,IAAI,EAAE,iCAC/K;EACA,MAAM,KAAK,GAAG,WAAW,GAAG,EAAE,EAAE;CAClC;CAEA,OAAO,MAAM,KAAK,IAAI;AACxB"}
+{"version":3,"file":"record.js","names":[],"sources":["../../../../src/core/codegen/schemas/record.ts"],"sourcesContent":["import type { RecordIR, SchemaIR } from \"../../types.js\";\nimport type { FastGen, SlowGen } from \"../context.js\";\nimport { declareFastTemps, emitRuntimeHelper, extendPath, hasMutation } from \"../context.js\";\nimport { emit } from \"../emit.js\";\nimport { invalidType, unrecognizedKeys } from \"../emit-issue.js\";\nimport { ZC_FZ_DECL, ZC_HOP_DECL, ZC_PLAIN_DECL, ZC_PROTO_SCRUB_DECL } from \"../issue-decls.js\";\n\n/**\n * `$ZodRecord` gates on `util.isPlainObject`, NOT the looser `util.isObject`\n * that `$ZodObject` uses — see {@link ZC_PLAIN_DECL} for why the two differ and\n * what accepting the wrong one lets through.\n */\nfunction plainObjectTest(g: SlowGen | FastGen, input: string): string {\n  return `${emitRuntimeHelper(g.ctx, \"__zcPlain\", ZC_PLAIN_DECL)}(${input})`;\n}\n\n/**\n * Zod's record walk opens with `if (key === \"__proto__\") continue`, so an own\n * `__proto__` data property (which `JSON.parse('{\"__proto__\":…}')` creates) is\n * neither key-validated nor value-validated nor copied. Without this the\n * compiled walk reported issues zod does not: `z.record(z.string(), z.number())`\n * over such an object raised a SECOND `invalid_type`, and a constrained key\n * schema a second `invalid_key`, for a key zod never looks at.\n */\nconst PROTO_SKIP = (keyVar: string): string => `if(${keyVar}===\"__proto__\")continue;`;\n\nexport function slowRecord(ir: SchemaIR & { type: \"record\" }, g: SlowGen): string {\n  let code = emit`\n    if(!${plainObjectTest(g, g.input)}){\n      ${invalidType(g, \"record\")}\n    }else{`;\n\n  if (hasMutation(ir.valueType)) {\n    code += `${g.output}={...${g.input}};`;\n  }\n  // PROTO_SKIP keeps `__proto__` out of the WALK; this keeps it out of the\n  // OUTPUT, which zod also does — it copies into a fresh `{}` and skips the key\n  // (see ZC_PROTO_SCRUB_DECL). Runs before the walk so the loop iterates the\n  // same container the caller gets back.\n  code += `${g.output}=${emitRuntimeHelper(g.ctx, \"__zcPs\", ZC_PROTO_SCRUB_DECL)}(${g.input});`;\n\n  const keyVar = g.temp(\"rkey\");\n  const keyIssuesVar = g.temp(\"rki\");\n  const keyPath = extendPath(g.path, keyVar);\n  const valExpr = `${g.input}[${keyVar}]`;\n  // for-in + hasOwnProperty guard instead of Object.keys(): identical\n  // own-enumerable string-key set and iteration order, no keys-array\n  // allocation. When the value type mutates (coerce/default/.trim()) the clone\n  // above has already replaced g.input, so this iterates the clone exactly as\n  // the Object.keys form did — the key set is stable (values change, keys\n  // don't). Records whose values mutate run this path eagerly, so they get the\n  // same speedup the fast path does.\n  const hop = emitRuntimeHelper(g.ctx, \"__zcHop\", ZC_HOP_DECL);\n\n  // The key is validated at a RELATIVE path and its issues are finalized before\n  // being nested, mirroring zod: `issues: keyResult.issues.map(finalizeIssue)`\n  // over a payload zod ran fresh. Nested issues never reach the top-level\n  // finalization loop (it walks only the outer array), so an unfinalized nest\n  // leaked absolute paths and the raw `input` into the reported error.\n  const fz = emitRuntimeHelper(g.ctx, \"__zcFz\", ZC_FZ_DECL);\n\n  // A key the enumerable key schema rejects is unrecognized, not invalid: zod\n  // collects those and pushes ONE `unrecognized_keys` after the walk, so it\n  // trails every value issue (see RecordIR.enumerableKeys).\n  const unrecognizedVar = ir.enumerableKeys ? g.temp(\"ruk\") : null;\n  const onKeyFailure =\n    unrecognizedVar === null\n      ? `${g.issues}.push({code:\"invalid_key\",origin:\"record\",issues:${fz}(${keyIssuesVar}),input:${keyVar},path:${keyPath}${g.typeMsg === undefined ? \"\" : `,message:${JSON.stringify(g.typeMsg)}`}});`\n      : `(${unrecognizedVar}=${unrecognizedVar}||[]).push(${keyVar});`;\n\n  code += emit`\n    ${unrecognizedVar === null ? \"\" : `var ${unrecognizedVar}=null;`}\n    for(var ${keyVar} in ${g.input}){\n      if(!${hop}.call(${g.input},${keyVar}))continue;\n      ${PROTO_SKIP(keyVar)}\n      var ${keyIssuesVar}=[];\n      ${g.visit(ir.keyType, { input: keyVar, output: keyVar, path: \"[]\", issues: keyIssuesVar })}\n      if(${keyIssuesVar}.length>0){\n        ${onKeyFailure}\n      }else{\n        ${g.visit(ir.valueType, { input: valExpr, output: valExpr, path: keyPath })}\n      }\n    }\n    ${unrecognizedVar === null ? \"\" : `if(${unrecognizedVar}!==null){${unrecognizedKeys(g, unrecognizedVar)}}`}\n  }`;\n  return `${code}\\n`;\n}\n\nexport function fastRecord(ir: RecordIR, g: FastGen): string | null {\n  const x = g.input;\n  const parts: string[] = [plainObjectTest(g, x)];\n\n  // Object.keys only yields strings — a plain unconstrained string key schema\n  // is always satisfied, so skip generating its check entirely.\n  const plainStringKey =\n    ir.keyType.type === \"string\" && ir.keyType.checks.length === 0 && ir.keyType.coerce !== true;\n\n  const kv = g.temp(\"rk\");\n  const vv = g.temp(\"rv\");\n  // Key + value checks share one fresh scope — they live in the same emitted\n  // helper function, size-gated independently of the caller.\n  const body = g.scoped(kv);\n  const keyCheck = plainStringKey ? \"true\" : body.visit(ir.keyType, { input: kv });\n  // Hoist o[k] into a loop variable: computed-key lookups don't get V8's load\n  // elimination across check boundaries, so each repeated o[k] would re-walk\n  // the (often dictionary-mode) object.\n  const valCheck = body.visit(ir.valueType, { input: vv });\n  if (keyCheck === null || valCheck === null) return null;\n\n  const conditions: string[] = [];\n  if (keyCheck !== \"true\") conditions.push(keyCheck);\n  if (valCheck !== \"true\") conditions.push(valCheck);\n\n  if (conditions.length > 0) {\n    const helperName = g.temp(\"rf\");\n    const valAssign = valCheck !== \"true\" ? `${vv}=o[${kv}];` : \"\";\n    // for-in (no Object.keys array allocation) + hasOwnProperty guard. The\n    // guard restricts iteration to own enumerable string keys — the exact set\n    // Object.keys/the slow path produce — so inherited enumerable props can't\n    // make the fast check disagree with the deferred slow walk. Measured 2.9x\n    // (5 keys) to 5.8x (20 keys) faster than the Object.keys form; the hoisted\n    // __zcHop.call inlines, making the guard ~free vs an unguarded for-in.\n    const hop = emitRuntimeHelper(g.ctx, \"__zcHop\", ZC_HOP_DECL);\n    g.ctx.preamble.push(\n      `function ${helperName}(o){${declareFastTemps(body.scope)}var ${kv},${vv};for(${kv} in o){${PROTO_SKIP(kv)}if(${hop}.call(o,${kv})){${valAssign}if(!(${conditions.join(\"&&\")})){return false;}}}return true;}`,\n    );\n    parts.push(`${helperName}(${x})`);\n  }\n\n  return parts.join(\"&&\");\n}\n"],"mappings":"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"}

package/dist/core/codegen/schemas/sizeable.d.ts

@@ -1,6 +1,46 @@
 import { CheckOrEffectIR, FileCheckIR, SetCheckIR } from "../../types.js";
-import { SlowGen } from "../context.js";
+import { CodeGenContext, SlowGen } from "../context.js";
 //#region src/core/codegen/schemas/sizeable.d.ts
+/**
+ * String length tests over Unicode CODE POINTS, gated so the count is only
+ * paid for when the UTF-16 unit count leaves the verdict in doubt.
+ *
+ * zod measures `z.string().min()/.max()/.length()` in code points
+ * (`util.codePointLength`), so `"😀"` has length 1, and it computes that count
+ * only when the unit count could sit on the other side of the bound. A code
+ * point is one or two units, so `units/2 <= codePoints <= units` — which pins
+ * the doubtful band tighter than zod's own gate without changing a verdict:
+ * `min(N)` is settled outside `N <= units < 2*ceil(N)-1` (so `min(1)` stays a
+ * plain `length>=1`; see {@link certainlyAtLeast} for the fractional case),
+ * `max(N)` outside `N < units <= 2N`, and `length(N)` outside `N <= units <=
+ * 2N`. Every test leads with the plain unit comparison, so an ASCII string of
+ * ordinary length never reaches the helper.
+ *
+ * `mayNotBeString` adds the `typeof` guard zod applies (`typeof input ===
+ * "string" && …`) for a site whose input is not statically a string — a
+ * length check firing on the wrong type through its `when` predicate; an array
+ * measures elements, never code points. Only the failure-direction forms take
+ * it: `min`/`max`/`equals` are reached solely from `fastStringCheck`, whose
+ * input is statically a string.
+ */
+declare const stringLengthTests: {
+  min(x: string, min: number, ctx: CodeGenContext): string;
+  max(x: string, max: number, ctx: CodeGenContext): string;
+  equals(x: string, length: number, ctx: CodeGenContext): string;
+  /**
+   * The FAILING condition of `min`/`max`, with the negation pushed inward so a
+   * check with no doubtful band emits the plain comparison the slow path always
+   * used (`x.length<1`, not `!(x.length>=1)`).
+   */
+  minFails(x: string, min: number, ctx: CodeGenContext, mayNotBeString?: boolean): string;
+  maxFails(x: string, max: number, ctx: CodeGenContext, mayNotBeString?: boolean): string;
+  /**
+   * The measured length zod compares in `$ZodCheckLengthEquals` — code points
+   * inside the doubtful band, units outside it — for the slow path, which has
+   * to know WHICH side of the bound the value fell on.
+   */
+  measure(x: string, length: number, ctx: CodeGenContext, mayNotBeString?: boolean): string;
+};
 /**
  * Length/size checks re-emitted for the branch where the node's TYPE CHECK
  * ALREADY FAILED.
@@ -30,8 +70,14 @@ import { SlowGen } from "../context.js";
  *
  * `origin` is computed at runtime here (see ZC_LENGTH_ORIGIN_DECL), because the
  * value that reached this branch is by definition not the schema's own type.
+ *
+ * `mayBeString` is set by a non-string node whose length checks can fire on a
+ * string (`z.array(…).min(2)` over `"😀"`): zod then measures it in code
+ * points, so those tests take the guarded form of {@link stringLengthTests}. A
+ * string node's own failure branch never holds a string and keeps the plain
+ * unit comparison.
  */
-declare function whenGatedSizeChecks(checks: readonly (CheckOrEffectIR | SetCheckIR | FileCheckIR)[], g: SlowGen, family: "length" | "size"): string;
+declare function whenGatedSizeChecks(checks: readonly (CheckOrEffectIR | SetCheckIR | FileCheckIR)[], g: SlowGen, family: "length" | "size", mayBeString?: boolean): string;
 //#endregion
-export { whenGatedSizeChecks };
+export { stringLengthTests, whenGatedSizeChecks };
 //# sourceMappingURL=sizeable.d.ts.map

package/dist/core/codegen/schemas/sizeable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sizeable.d.ts","names":[],"sources":["../../../../src/core/codegen/schemas/sizeable.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqCgB,oBACd,kBAAkB,kBAAkB,aAAa,gBACjD,GAAG,SACH"}
+{"version":3,"file":"sizeable.d.ts","names":[],"sources":["../../../../src/core/codegen/schemas/sizeable.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;cA4Ca;EACJ,IAAA,WAAM,aAAa,KAAO;EAM1B,IAAA,WAAM,aAAa,KAAO;EAMvB,OAAA,WAAM,gBAAgB,KAAO;;;;;;EAe3B,SAAA,WAAM,aAAa,KAAO,gBAAc;EAOxC,SAAA,WAAM,aAAa,KAAO,gBAAc;;;;;;EAYzC,QAAA,WAAM,gBAAgB,KAAO,gBAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8CxC,oBACd,kBAAkB,kBAAkB,aAAa,gBACjD,GAAG,SACH,2BACA"}

package/dist/core/codegen/schemas/sizeable.js

@@ -1,9 +1,94 @@
 import { emitRuntimeHelper } from "../context.js";
 import { emit } from "../emit.js";
 import { tooBig, tooSmall } from "../emit-issue.js";
-import { ZC_LENGTH_ORIGIN_DECL, ZC_SIZE_ORIGIN_DECL } from "../issue-decls.js";
+import { ZC_CPL_DECL, ZC_LENGTH_ORIGIN_DECL, ZC_SIZE_ORIGIN_DECL } from "../issue-decls.js";
 //#region src/core/codegen/schemas/sizeable.ts
 /**
+* The UTF-16 unit count from which a string is CERTAINLY at least `min` code
+* points, so the count can be skipped.
+*
+* A code point is one or two units, so `codePoints >= ceil(units / 2)`, and
+* that ceiling is an integer: `ceil(units/2) >= min` holds exactly when
+* `ceil(units/2) >= Math.ceil(min)`, i.e. `units >= 2 * ceil(min) - 1`.
+* Rounding `min` up is what makes a FRACTIONAL bound safe — `min(2.5)` is
+* settled at 5 units, not the 4 that `2 * min - 1` would have claimed, where
+* two astral characters are only 2 code points and zod reports `too_small`.
+*/
+function certainlyAtLeast(min) {
+	return 2 * Math.ceil(min) - 1;
+}
+/**
+* String length tests over Unicode CODE POINTS, gated so the count is only
+* paid for when the UTF-16 unit count leaves the verdict in doubt.
+*
+* zod measures `z.string().min()/.max()/.length()` in code points
+* (`util.codePointLength`), so `"😀"` has length 1, and it computes that count
+* only when the unit count could sit on the other side of the bound. A code
+* point is one or two units, so `units/2 <= codePoints <= units` — which pins
+* the doubtful band tighter than zod's own gate without changing a verdict:
+* `min(N)` is settled outside `N <= units < 2*ceil(N)-1` (so `min(1)` stays a
+* plain `length>=1`; see {@link certainlyAtLeast} for the fractional case),
+* `max(N)` outside `N < units <= 2N`, and `length(N)` outside `N <= units <=
+* 2N`. Every test leads with the plain unit comparison, so an ASCII string of
+* ordinary length never reaches the helper.
+*
+* `mayNotBeString` adds the `typeof` guard zod applies (`typeof input ===
+* "string" && …`) for a site whose input is not statically a string — a
+* length check firing on the wrong type through its `when` predicate; an array
+* measures elements, never code points. Only the failure-direction forms take
+* it: `min`/`max`/`equals` are reached solely from `fastStringCheck`, whose
+* input is statically a string.
+*/
+const stringLengthTests = {
+	min(x, min, ctx) {
+		const units = `${x}.length>=${min}`;
+		if (min <= 1) return units;
+		const cpl = emitRuntimeHelper(ctx, "__zcCpl", ZC_CPL_DECL);
+		return `${units}&&(${x}.length>=${certainlyAtLeast(min)}||${cpl}(${x})>=${min})`;
+	},
+	max(x, max, ctx) {
+		const units = `${x}.length<=${max}`;
+		if (max <= 0) return units;
+		const cpl = emitRuntimeHelper(ctx, "__zcCpl", ZC_CPL_DECL);
+		return `(${units}||(${x}.length<=${2 * max}&&${cpl}(${x})<=${max}))`;
+	},
+	equals(x, length, ctx) {
+		if (length <= 0) return `${x}.length===${length}`;
+		const cpl = emitRuntimeHelper(ctx, "__zcCpl", ZC_CPL_DECL);
+		if (length === 1) return `(${x}.length===1||(${x}.length===2&&${cpl}(${x})===1))`;
+		return `(${x}.length>=${length}&&${x}.length<=${2 * length}&&${cpl}(${x})===${length})`;
+	},
+	/**
+	* The FAILING condition of `min`/`max`, with the negation pushed inward so a
+	* check with no doubtful band emits the plain comparison the slow path always
+	* used (`x.length<1`, not `!(x.length>=1)`).
+	*/
+	minFails(x, min, ctx, mayNotBeString = false) {
+		const units = `${x}.length<${min}`;
+		if (min <= 1) return units;
+		const cpl = emitRuntimeHelper(ctx, "__zcCpl", ZC_CPL_DECL);
+		const guard = mayNotBeString ? `typeof ${x}==="string"&&` : "";
+		return `${units}||(${x}.length<${certainlyAtLeast(min)}&&${guard}${cpl}(${x})<${min})`;
+	},
+	maxFails(x, max, ctx, mayNotBeString = false) {
+		const units = `${x}.length>${max}`;
+		if (max <= 0) return units;
+		const cpl = emitRuntimeHelper(ctx, "__zcCpl", ZC_CPL_DECL);
+		const guard = mayNotBeString ? `typeof ${x}!=="string"||` : "";
+		return `${units}&&(${x}.length>${2 * max}||${guard}${cpl}(${x})>${max})`;
+	},
+	/**
+	* The measured length zod compares in `$ZodCheckLengthEquals` — code points
+	* inside the doubtful band, units outside it — for the slow path, which has
+	* to know WHICH side of the bound the value fell on.
+	*/
+	measure(x, length, ctx, mayNotBeString = false) {
+		if (length <= 0) return `${x}.length`;
+		const cpl = emitRuntimeHelper(ctx, "__zcCpl", ZC_CPL_DECL);
+		return `(${mayNotBeString ? `typeof ${x}==="string"&&` : ""}${length === 1 ? `${x}.length===2` : `${x}.length>=${length}&&${x}.length<=${2 * length}`}?${cpl}(${x}):${x}.length)`;
+	}
+};
+/**
 * Length/size checks re-emitted for the branch where the node's TYPE CHECK
 * ALREADY FAILED.
 *
@@ -32,8 +117,14 @@ import { ZC_LENGTH_ORIGIN_DECL, ZC_SIZE_ORIGIN_DECL } from "../issue-decls.js";
 *
 * `origin` is computed at runtime here (see ZC_LENGTH_ORIGIN_DECL), because the
 * value that reached this branch is by definition not the schema's own type.
+*
+* `mayBeString` is set by a non-string node whose length checks can fire on a
+* string (`z.array(…).min(2)` over `"😀"`): zod then measures it in code
+* points, so those tests take the guarded form of {@link stringLengthTests}. A
+* string node's own failure branch never holds a string and keeps the plain
+* unit comparison.
 */
-function whenGatedSizeChecks(checks, g, family) {
+function whenGatedSizeChecks(checks, g, family, mayBeString = false) {
 	const KINDS = family === "length" ? /* @__PURE__ */ new Set([
 		"min_length",
 		"max_length",
@@ -51,30 +142,32 @@ function whenGatedSizeChecks(checks, g, family) {
 	for (const check of checks) switch (check.kind) {
 		case "min_length":
 			body += emit`
-          if(${measure}<${check.minimum}){
+          if(${mayBeString ? stringLengthTests.minFails(g.input, check.minimum, g.ctx, true) : `${measure}<${check.minimum}`}){
             ${tooSmall(g, check.minimum, origin, true, { message: check.message })}
           }`;
 			break;
 		case "max_length":
 			body += emit`
-          if(${measure}>${check.maximum}){
+          if(${mayBeString ? stringLengthTests.maxFails(g.input, check.maximum, g.ctx, true) : `${measure}>${check.maximum}`}){
             ${tooBig(g, check.maximum, origin, true, { message: check.message })}
           }`;
 			break;
-		case "length_equals":
+		case "length_equals": {
+			const length = mayBeString ? stringLengthTests.measure(g.input, check.length, g.ctx, true) : measure;
 			body += emit`
-          if(${measure}<${check.length}){
+          if(${length}<${check.length}){
             ${tooSmall(g, check.length, origin, true, {
 				exact: true,
 				message: check.message
 			})}
-          }else if(${measure}>${check.length}){
+          }else if(${length}>${check.length}){
             ${tooBig(g, check.length, origin, true, {
 				exact: true,
 				message: check.message
 			})}
           }`;
 			break;
+		}
 		case "min_size":
 			body += emit`
           if(${measure}<${check.minimum}){
@@ -110,6 +203,6 @@ function whenGatedSizeChecks(checks, g, family) {
     }`;
 }
 //#endregion
-export { whenGatedSizeChecks };
+export { stringLengthTests, whenGatedSizeChecks };
 
 //# sourceMappingURL=sizeable.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"sizeable.js","names":[],"sources":["../../../../src/core/codegen/schemas/sizeable.ts"],"sourcesContent":["import type { CheckOrEffectIR, FileCheckIR, SetCheckIR } from \"../../types.js\";\nimport type { SlowGen } from \"../context.js\";\nimport { emitRuntimeHelper } from \"../context.js\";\nimport { emit } from \"../emit.js\";\nimport { tooBig, tooSmall } from \"../emit-issue.js\";\nimport { ZC_LENGTH_ORIGIN_DECL, ZC_SIZE_ORIGIN_DECL } from \"../issue-decls.js\";\n\n/**\n * Length/size checks re-emitted for the branch where the node's TYPE CHECK\n * ALREADY FAILED.\n *\n * zod skips a schema's checks once its parse aborted — except the ones carrying\n * a `when` predicate, which `runChecks` consults instead of the abort flag:\n *\n * ```js\n * if (ch._zod.def.when) { if (!ch._zod.def.when(payload)) continue; }\n * else if (isAborted) continue;\n * ```\n *\n * and `$ZodCheckMinLength` & co. install exactly such a predicate —\n * `!nullish(value) && value.length !== undefined` (`.size` for the size family)\n * — so they run on ANY input carrying that property, of any type. Hence\n * `z.string().min(2).safeParse([])` reports TWO issues in zod: the\n * `invalid_type`, and a `too_small` whose `origin` is `\"array\"`, because the\n * empty array satisfied the `when`. Compiled output kept every check inside the\n * matched-type branch and reported only the first. Same for\n * `z.array(…).min(3)` over a short string, `z.set(…).min(2)` over a `Map`, and\n * `z.file().min(2)` over a `Set`.\n *\n * Emitted as a SEPARATE copy in the failure branch rather than hoisted out of\n * both, so the success path — where the origin is statically known and the guard\n * is trivially true — stays byte-for-byte what it was. This is cold code: it\n * runs only for input the node has already rejected.\n *\n * `origin` is computed at runtime here (see ZC_LENGTH_ORIGIN_DECL), because the\n * value that reached this branch is by definition not the schema's own type.\n */\nexport function whenGatedSizeChecks(\n  checks: readonly (CheckOrEffectIR | SetCheckIR | FileCheckIR)[],\n  g: SlowGen,\n  family: \"length\" | \"size\",\n): string {\n  const KINDS =\n    family === \"length\"\n      ? new Set([\"min_length\", \"max_length\", \"length_equals\"])\n      : new Set([\"min_size\", \"max_size\", \"size_equals\"]);\n  // Checked BEFORE touching the context: `emitRuntimeHelper` pushes its\n  // declaration on sight, so asking for the origin helper up front left a dead\n  // `__zcLo` in the preamble of every schema with a plain `z.string()` in it.\n  if (!checks.some((check) => KINDS.has(check.kind))) return \"\";\n\n  const property = family === \"length\" ? \"length\" : \"size\";\n  const originHelper =\n    family === \"length\"\n      ? emitRuntimeHelper(g.ctx, \"__zcLo\", ZC_LENGTH_ORIGIN_DECL)\n      : emitRuntimeHelper(g.ctx, \"__zcSo\", ZC_SIZE_ORIGIN_DECL);\n  const origin = { expr: `${originHelper}(${g.input})` };\n  const measure = `${g.input}.${property}`;\n\n  let body = \"\";\n  for (const check of checks) {\n    // Kept in DECLARATION order: `runChecks` walks the check array, so two\n    // failing length checks report in the order they were declared.\n    switch (check.kind) {\n      case \"min_length\":\n        body += emit`\n          if(${measure}<${check.minimum}){\n            ${tooSmall(g, check.minimum, origin, true, { message: check.message })}\n          }`;\n        break;\n      case \"max_length\":\n        body += emit`\n          if(${measure}>${check.maximum}){\n            ${tooBig(g, check.maximum, origin, true, { message: check.message })}\n          }`;\n        break;\n      case \"length_equals\":\n        body += emit`\n          if(${measure}<${check.length}){\n            ${tooSmall(g, check.length, origin, true, { exact: true, message: check.message })}\n          }else if(${measure}>${check.length}){\n            ${tooBig(g, check.length, origin, true, { exact: true, message: check.message })}\n          }`;\n        break;\n      case \"min_size\":\n        body += emit`\n          if(${measure}<${check.minimum}){\n            ${tooSmall(g, check.minimum, origin, true, { message: check.message })}\n          }`;\n        break;\n      case \"max_size\":\n        body += emit`\n          if(${measure}>${check.maximum}){\n            ${tooBig(g, check.maximum, origin, true, { message: check.message })}\n          }`;\n        break;\n      case \"size_equals\":\n        body += emit`\n          if(${measure}<${check.size}){\n            ${tooSmall(g, check.size, origin, true, { exact: true, message: check.message })}\n          }else if(${measure}>${check.size}){\n            ${tooBig(g, check.size, origin, true, { exact: true, message: check.message })}\n          }`;\n        break;\n      default:\n        break;\n    }\n  }\n  if (body === \"\") return \"\";\n  // zod's own `when`, verbatim: `!util.nullish(value) && value.<prop> !== undefined`.\n  return emit`\n    if(${g.input}!==undefined&&${g.input}!==null&&${measure}!==undefined){\n      ${body}\n    }`;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,SAAgB,oBACd,QACA,GACA,QACQ;CACR,MAAM,QACJ,WAAW,2BACP,IAAI,IAAI;EAAC;EAAc;EAAc;CAAe,CAAC,oBACrD,IAAI,IAAI;EAAC;EAAY;EAAY;CAAa,CAAC;CAIrD,IAAI,CAAC,OAAO,MAAM,UAAU,MAAM,IAAI,MAAM,IAAI,CAAC,GAAG,OAAO;CAE3D,MAAM,WAAW,WAAW,WAAW,WAAW;CAKlD,MAAM,SAAS,EAAE,MAAM,GAHrB,WAAW,WACP,kBAAkB,EAAE,KAAK,UAAU,qBAAqB,IACxD,kBAAkB,EAAE,KAAK,UAAU,mBAAmB,EACrB,GAAG,EAAE,MAAM,GAAG;CACrD,MAAM,UAAU,GAAG,EAAE,MAAM,GAAG;CAE9B,IAAI,OAAO;CACX,KAAK,MAAM,SAAS,QAGlB,QAAQ,MAAM,MAAd;EACE,KAAK;GACH,QAAQ,IAAI;eACL,QAAQ,GAAG,MAAM,QAAQ;cAC1B,SAAS,GAAG,MAAM,SAAS,QAAQ,MAAM,EAAE,SAAS,MAAM,QAAQ,CAAC,EAAE;;GAE3E;EACF,KAAK;GACH,QAAQ,IAAI;eACL,QAAQ,GAAG,MAAM,QAAQ;cAC1B,OAAO,GAAG,MAAM,SAAS,QAAQ,MAAM,EAAE,SAAS,MAAM,QAAQ,CAAC,EAAE;;GAEzE;EACF,KAAK;GACH,QAAQ,IAAI;eACL,QAAQ,GAAG,MAAM,OAAO;cACzB,SAAS,GAAG,MAAM,QAAQ,QAAQ,MAAM;IAAE,OAAO;IAAM,SAAS,MAAM;GAAQ,CAAC,EAAE;qBAC1E,QAAQ,GAAG,MAAM,OAAO;cAC/B,OAAO,GAAG,MAAM,QAAQ,QAAQ,MAAM;IAAE,OAAO;IAAM,SAAS,MAAM;GAAQ,CAAC,EAAE;;GAErF;EACF,KAAK;GACH,QAAQ,IAAI;eACL,QAAQ,GAAG,MAAM,QAAQ;cAC1B,SAAS,GAAG,MAAM,SAAS,QAAQ,MAAM,EAAE,SAAS,MAAM,QAAQ,CAAC,EAAE;;GAE3E;EACF,KAAK;GACH,QAAQ,IAAI;eACL,QAAQ,GAAG,MAAM,QAAQ;cAC1B,OAAO,GAAG,MAAM,SAAS,QAAQ,MAAM,EAAE,SAAS,MAAM,QAAQ,CAAC,EAAE;;GAEzE;EACF,KAAK;GACH,QAAQ,IAAI;eACL,QAAQ,GAAG,MAAM,KAAK;cACvB,SAAS,GAAG,MAAM,MAAM,QAAQ,MAAM;IAAE,OAAO;IAAM,SAAS,MAAM;GAAQ,CAAC,EAAE;qBACxE,QAAQ,GAAG,MAAM,KAAK;cAC7B,OAAO,GAAG,MAAM,MAAM,QAAQ,MAAM;IAAE,OAAO;IAAM,SAAS,MAAM;GAAQ,CAAC,EAAE;;GAEnF;EACF,SACE;CACJ;CAEF,IAAI,SAAS,IAAI,OAAO;CAExB,OAAO,IAAI;SACJ,EAAE,MAAM,gBAAgB,EAAE,MAAM,WAAW,QAAQ;QACpD,KAAK;;AAEb"}
+{"version":3,"file":"sizeable.js","names":[],"sources":["../../../../src/core/codegen/schemas/sizeable.ts"],"sourcesContent":["import type { CheckOrEffectIR, FileCheckIR, SetCheckIR } from \"../../types.js\";\nimport type { CodeGenContext, SlowGen } from \"../context.js\";\nimport { emitRuntimeHelper } from \"../context.js\";\nimport { emit } from \"../emit.js\";\nimport { tooBig, tooSmall } from \"../emit-issue.js\";\nimport { ZC_CPL_DECL, ZC_LENGTH_ORIGIN_DECL, ZC_SIZE_ORIGIN_DECL } from \"../issue-decls.js\";\n\n/**\n * The UTF-16 unit count from which a string is CERTAINLY at least `min` code\n * points, so the count can be skipped.\n *\n * A code point is one or two units, so `codePoints >= ceil(units / 2)`, and\n * that ceiling is an integer: `ceil(units/2) >= min` holds exactly when\n * `ceil(units/2) >= Math.ceil(min)`, i.e. `units >= 2 * ceil(min) - 1`.\n * Rounding `min` up is what makes a FRACTIONAL bound safe — `min(2.5)` is\n * settled at 5 units, not the 4 that `2 * min - 1` would have claimed, where\n * two astral characters are only 2 code points and zod reports `too_small`.\n */\nfunction certainlyAtLeast(min: number): number {\n  return 2 * Math.ceil(min) - 1;\n}\n\n/**\n * String length tests over Unicode CODE POINTS, gated so the count is only\n * paid for when the UTF-16 unit count leaves the verdict in doubt.\n *\n * zod measures `z.string().min()/.max()/.length()` in code points\n * (`util.codePointLength`), so `\"😀\"` has length 1, and it computes that count\n * only when the unit count could sit on the other side of the bound. A code\n * point is one or two units, so `units/2 <= codePoints <= units` — which pins\n * the doubtful band tighter than zod's own gate without changing a verdict:\n * `min(N)` is settled outside `N <= units < 2*ceil(N)-1` (so `min(1)` stays a\n * plain `length>=1`; see {@link certainlyAtLeast} for the fractional case),\n * `max(N)` outside `N < units <= 2N`, and `length(N)` outside `N <= units <=\n * 2N`. Every test leads with the plain unit comparison, so an ASCII string of\n * ordinary length never reaches the helper.\n *\n * `mayNotBeString` adds the `typeof` guard zod applies (`typeof input ===\n * \"string\" && …`) for a site whose input is not statically a string — a\n * length check firing on the wrong type through its `when` predicate; an array\n * measures elements, never code points. Only the failure-direction forms take\n * it: `min`/`max`/`equals` are reached solely from `fastStringCheck`, whose\n * input is statically a string.\n */\nexport const stringLengthTests = {\n  min(x: string, min: number, ctx: CodeGenContext): string {\n    const units = `${x}.length>=${min}`;\n    if (min <= 1) return units;\n    const cpl = emitRuntimeHelper(ctx, \"__zcCpl\", ZC_CPL_DECL);\n    return `${units}&&(${x}.length>=${certainlyAtLeast(min)}||${cpl}(${x})>=${min})`;\n  },\n  max(x: string, max: number, ctx: CodeGenContext): string {\n    const units = `${x}.length<=${max}`;\n    if (max <= 0) return units;\n    const cpl = emitRuntimeHelper(ctx, \"__zcCpl\", ZC_CPL_DECL);\n    return `(${units}||(${x}.length<=${2 * max}&&${cpl}(${x})<=${max}))`;\n  },\n  equals(x: string, length: number, ctx: CodeGenContext): string {\n    if (length <= 0) return `${x}.length===${length}`;\n    const cpl = emitRuntimeHelper(ctx, \"__zcCpl\", ZC_CPL_DECL);\n    // A single unit is always one code point, so `length(1)` is only in doubt\n    // at exactly two units.\n    if (length === 1) {\n      return `(${x}.length===1||(${x}.length===2&&${cpl}(${x})===1))`;\n    }\n    return `(${x}.length>=${length}&&${x}.length<=${2 * length}&&${cpl}(${x})===${length})`;\n  },\n  /**\n   * The FAILING condition of `min`/`max`, with the negation pushed inward so a\n   * check with no doubtful band emits the plain comparison the slow path always\n   * used (`x.length<1`, not `!(x.length>=1)`).\n   */\n  minFails(x: string, min: number, ctx: CodeGenContext, mayNotBeString = false): string {\n    const units = `${x}.length<${min}`;\n    if (min <= 1) return units;\n    const cpl = emitRuntimeHelper(ctx, \"__zcCpl\", ZC_CPL_DECL);\n    const guard = mayNotBeString ? `typeof ${x}===\"string\"&&` : \"\";\n    return `${units}||(${x}.length<${certainlyAtLeast(min)}&&${guard}${cpl}(${x})<${min})`;\n  },\n  maxFails(x: string, max: number, ctx: CodeGenContext, mayNotBeString = false): string {\n    const units = `${x}.length>${max}`;\n    if (max <= 0) return units;\n    const cpl = emitRuntimeHelper(ctx, \"__zcCpl\", ZC_CPL_DECL);\n    const guard = mayNotBeString ? `typeof ${x}!==\"string\"||` : \"\";\n    return `${units}&&(${x}.length>${2 * max}||${guard}${cpl}(${x})>${max})`;\n  },\n  /**\n   * The measured length zod compares in `$ZodCheckLengthEquals` — code points\n   * inside the doubtful band, units outside it — for the slow path, which has\n   * to know WHICH side of the bound the value fell on.\n   */\n  measure(x: string, length: number, ctx: CodeGenContext, mayNotBeString = false): string {\n    if (length <= 0) return `${x}.length`;\n    const cpl = emitRuntimeHelper(ctx, \"__zcCpl\", ZC_CPL_DECL);\n    const guard = mayNotBeString ? `typeof ${x}===\"string\"&&` : \"\";\n    const band =\n      length === 1 ? `${x}.length===2` : `${x}.length>=${length}&&${x}.length<=${2 * length}`;\n    return `(${guard}${band}?${cpl}(${x}):${x}.length)`;\n  },\n};\n\n/**\n * Length/size checks re-emitted for the branch where the node's TYPE CHECK\n * ALREADY FAILED.\n *\n * zod skips a schema's checks once its parse aborted — except the ones carrying\n * a `when` predicate, which `runChecks` consults instead of the abort flag:\n *\n * ```js\n * if (ch._zod.def.when) { if (!ch._zod.def.when(payload)) continue; }\n * else if (isAborted) continue;\n * ```\n *\n * and `$ZodCheckMinLength` & co. install exactly such a predicate —\n * `!nullish(value) && value.length !== undefined` (`.size` for the size family)\n * — so they run on ANY input carrying that property, of any type. Hence\n * `z.string().min(2).safeParse([])` reports TWO issues in zod: the\n * `invalid_type`, and a `too_small` whose `origin` is `\"array\"`, because the\n * empty array satisfied the `when`. Compiled output kept every check inside the\n * matched-type branch and reported only the first. Same for\n * `z.array(…).min(3)` over a short string, `z.set(…).min(2)` over a `Map`, and\n * `z.file().min(2)` over a `Set`.\n *\n * Emitted as a SEPARATE copy in the failure branch rather than hoisted out of\n * both, so the success path — where the origin is statically known and the guard\n * is trivially true — stays byte-for-byte what it was. This is cold code: it\n * runs only for input the node has already rejected.\n *\n * `origin` is computed at runtime here (see ZC_LENGTH_ORIGIN_DECL), because the\n * value that reached this branch is by definition not the schema's own type.\n *\n * `mayBeString` is set by a non-string node whose length checks can fire on a\n * string (`z.array(…).min(2)` over `\"😀\"`): zod then measures it in code\n * points, so those tests take the guarded form of {@link stringLengthTests}. A\n * string node's own failure branch never holds a string and keeps the plain\n * unit comparison.\n */\nexport function whenGatedSizeChecks(\n  checks: readonly (CheckOrEffectIR | SetCheckIR | FileCheckIR)[],\n  g: SlowGen,\n  family: \"length\" | \"size\",\n  mayBeString = false,\n): string {\n  const KINDS =\n    family === \"length\"\n      ? new Set([\"min_length\", \"max_length\", \"length_equals\"])\n      : new Set([\"min_size\", \"max_size\", \"size_equals\"]);\n  // Checked BEFORE touching the context: `emitRuntimeHelper` pushes its\n  // declaration on sight, so asking for the origin helper up front left a dead\n  // `__zcLo` in the preamble of every schema with a plain `z.string()` in it.\n  if (!checks.some((check) => KINDS.has(check.kind))) return \"\";\n\n  const property = family === \"length\" ? \"length\" : \"size\";\n  const originHelper =\n    family === \"length\"\n      ? emitRuntimeHelper(g.ctx, \"__zcLo\", ZC_LENGTH_ORIGIN_DECL)\n      : emitRuntimeHelper(g.ctx, \"__zcSo\", ZC_SIZE_ORIGIN_DECL);\n  const origin = { expr: `${originHelper}(${g.input})` };\n  const measure = `${g.input}.${property}`;\n\n  let body = \"\";\n  for (const check of checks) {\n    // Kept in DECLARATION order: `runChecks` walks the check array, so two\n    // failing length checks report in the order they were declared.\n    switch (check.kind) {\n      case \"min_length\":\n        body += emit`\n          if(${mayBeString ? stringLengthTests.minFails(g.input, check.minimum, g.ctx, true) : `${measure}<${check.minimum}`}){\n            ${tooSmall(g, check.minimum, origin, true, { message: check.message })}\n          }`;\n        break;\n      case \"max_length\":\n        body += emit`\n          if(${mayBeString ? stringLengthTests.maxFails(g.input, check.maximum, g.ctx, true) : `${measure}>${check.maximum}`}){\n            ${tooBig(g, check.maximum, origin, true, { message: check.message })}\n          }`;\n        break;\n      case \"length_equals\": {\n        const length = mayBeString\n          ? stringLengthTests.measure(g.input, check.length, g.ctx, true)\n          : measure;\n        body += emit`\n          if(${length}<${check.length}){\n            ${tooSmall(g, check.length, origin, true, { exact: true, message: check.message })}\n          }else if(${length}>${check.length}){\n            ${tooBig(g, check.length, origin, true, { exact: true, message: check.message })}\n          }`;\n        break;\n      }\n      case \"min_size\":\n        body += emit`\n          if(${measure}<${check.minimum}){\n            ${tooSmall(g, check.minimum, origin, true, { message: check.message })}\n          }`;\n        break;\n      case \"max_size\":\n        body += emit`\n          if(${measure}>${check.maximum}){\n            ${tooBig(g, check.maximum, origin, true, { message: check.message })}\n          }`;\n        break;\n      case \"size_equals\":\n        body += emit`\n          if(${measure}<${check.size}){\n            ${tooSmall(g, check.size, origin, true, { exact: true, message: check.message })}\n          }else if(${measure}>${check.size}){\n            ${tooBig(g, check.size, origin, true, { exact: true, message: check.message })}\n          }`;\n        break;\n      default:\n        break;\n    }\n  }\n  if (body === \"\") return \"\";\n  // zod's own `when`, verbatim: `!util.nullish(value) && value.<prop> !== undefined`.\n  return emit`\n    if(${g.input}!==undefined&&${g.input}!==null&&${measure}!==undefined){\n      ${body}\n    }`;\n}\n"],"mappings":"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"}

package/dist/core/codegen/schemas/string-bool.d.ts

@@ -3,8 +3,19 @@ import { CodeGenContext, SlowGen } from "../context.js";
 //#region src/core/codegen/schemas/string-bool.d.ts
 declare function slowStringBool(ir: StringBoolIR, g: SlowGen): string;
 declare function stringBoolUsesInline(ir: StringBoolIR): boolean;
+/**
+ * Boolean expression: is `input` verbatim one of an INLINE codec's spellings?
+ *
+ * The accepted lists come from probing the schema with lowercase candidates
+ * (see extractStringBool), so for a case-insensitive codec an exact hit is
+ * exactly what `input.toLowerCase()` would have produced — and a handful of
+ * `===` on internalized strings is cheaper than the `toLowerCase()` call. The
+ * hashed form has no use for this: there the verbatim `Map.get` IS the lookup,
+ * retried on the lowercased string only when it misses.
+ */
+declare function stringBoolInlineHit(ir: StringBoolIR, input: string): string;
 /** One lookup distinguishes true, false and absent; shared by hot and issue walks. */
 declare function emitStringBoolMap(ir: StringBoolIR, ctx: CodeGenContext): string;
 //#endregion
-export { emitStringBoolMap, slowStringBool, stringBoolUsesInline };
+export { emitStringBoolMap, slowStringBool, stringBoolInlineHit, stringBoolUsesInline };
 //# sourceMappingURL=string-bool.d.ts.map

package/dist/core/codegen/schemas/string-bool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"string-bool.d.ts","names":[],"sources":["../../../../src/core/codegen/schemas/string-bool.ts"],"mappings":";;;iBAMgB,eAAe,IAAI,cAAc,GAAG;iBA+CpC,qBAAqB,IAAI;;iBAKzB,kBAAkB,IAAI,cAAc,KAAK"}
+{"version":3,"file":"string-bool.d.ts","names":[],"sources":["../../../../src/core/codegen/schemas/string-bool.ts"],"mappings":";;;iBAMgB,eAAe,IAAI,cAAc,GAAG;iBAyDpC,qBAAqB,IAAI;;;;;;;;;;;iBAczB,oBAAoB,IAAI,cAAc;;iBAKtC,kBAAkB,IAAI,cAAc,KAAK"}

package/dist/core/codegen/schemas/string-bool.js

@@ -9,12 +9,12 @@ function slowStringBool(ir, g) {
       ${invalidType(g, "string")}
     }else{
   `;
-	const normalized = ir.caseSensitive ? g.input : g.temp("sbn");
-	if (!ir.caseSensitive) code += `var ${normalized}=${g.input}.toLowerCase();`;
 	const allValues = [...ir.truthy, ...ir.falsy];
 	const valuesExpr = JSON.stringify(allValues);
 	const expectedExtra = "expected:\"stringbool\"";
 	if (stringBoolUsesInline(ir)) {
+		const normalized = ir.caseSensitive ? g.input : g.temp("sbn");
+		if (!ir.caseSensitive) code += `var ${normalized}=${stringBoolInlineHit(ir, g.input)}?${g.input}:${g.input}.toLowerCase();`;
 		const truthyCondition = ir.truthy.map((v) => `${normalized}===${escapeString(v)}`).join("||");
 		const falsyCondition = ir.falsy.map((v) => `${normalized}===${escapeString(v)}`).join("||");
 		code += emit`
@@ -25,8 +25,10 @@ function slowStringBool(ir, g) {
 	} else {
 		const value = g.temp("sbv");
 		const lookup = emitStringBoolMap(ir, g.ctx);
+		const lowered = g.temp("sbn");
+		const retry = ir.caseSensitive ? "" : `if(${value}===undefined){var ${lowered}=${g.input}.toLowerCase();if(${lowered}!==${g.input}){${value}=${lookup}.get(${lowered});}}`;
 		code += emit`
-      var ${value}=${lookup}.get(${normalized});
+      var ${value}=${lookup}.get(${g.input});${retry}
       if(${value}===undefined){${invalidValue(g, valuesExpr, { extra: expectedExtra })}}
       else{${g.output}=${value};}
     `;
@@ -37,12 +39,25 @@ function slowStringBool(ir, g) {
 function stringBoolUsesInline(ir) {
 	return ir.truthy.length <= 5 && ir.falsy.length <= 5;
 }
+/**
+* Boolean expression: is `input` verbatim one of an INLINE codec's spellings?
+*
+* The accepted lists come from probing the schema with lowercase candidates
+* (see extractStringBool), so for a case-insensitive codec an exact hit is
+* exactly what `input.toLowerCase()` would have produced — and a handful of
+* `===` on internalized strings is cheaper than the `toLowerCase()` call. The
+* hashed form has no use for this: there the verbatim `Map.get` IS the lookup,
+* retried on the lowercased string only when it misses.
+*/
+function stringBoolInlineHit(ir, input) {
+	return [...ir.truthy, ...ir.falsy].map((v) => `${input}===${escapeString(v)}`).join("||");
+}
 /** One lookup distinguishes true, false and absent; shared by hot and issue walks. */
 function emitStringBoolMap(ir, ctx) {
 	const pairs = [...ir.truthy.map((value) => [value, true]), ...ir.falsy.map((value) => [value, false])];
 	return emitConstant(ctx, "map_sb", `new Map(${JSON.stringify(pairs)})`);
 }
 //#endregion
-export { emitStringBoolMap, slowStringBool, stringBoolUsesInline };
+export { emitStringBoolMap, slowStringBool, stringBoolInlineHit, stringBoolUsesInline };
 
 //# sourceMappingURL=string-bool.js.map

package/dist/core/codegen/schemas/string-bool.js.map

@@ -1 +1 @@
-{"version":3,"file":"string-bool.js","names":[],"sources":["../../../../src/core/codegen/schemas/string-bool.ts"],"sourcesContent":["import type { StringBoolIR } from \"../../types.js\";\nimport type { CodeGenContext, SlowGen } from \"../context.js\";\nimport { ENUM_INLINE_THRESHOLD, emitConstant, escapeString } from \"../context.js\";\nimport { emit } from \"../emit.js\";\nimport { invalidType, invalidValue } from \"../emit-issue.js\";\n\nexport function slowStringBool(ir: StringBoolIR, g: SlowGen): string {\n  let code = \"\";\n\n  // Type check: input must be a string\n  code += emit`\n    if(typeof ${g.input}!==\"string\"){\n      ${invalidType(g, \"string\")}\n    }else{\n  `;\n\n  // Normalize input for case-insensitive matching\n  const normalized = ir.caseSensitive ? g.input : g.temp(\"sbn\");\n  if (!ir.caseSensitive) code += `var ${normalized}=${g.input}.toLowerCase();`;\n  const allValues = [...ir.truthy, ...ir.falsy];\n  const valuesExpr = JSON.stringify(allValues);\n  // z.stringbool() is a Codec whose transform pushes\n  // `{ code: \"invalid_value\", expected: \"stringbool\", values: [...] }` — the\n  // only invalid_value producer that carries an `expected` (enum and literal\n  // push `values` alone), and zod's locale keys off it. Both emitted lookups\n  // below share this so the two code paths cannot drift apart.\n  const expectedExtra = 'expected:\"stringbool\"';\n\n  // Compare per-side counts against threshold (not the combined total)\n  const useInline = stringBoolUsesInline(ir);\n\n  if (useInline) {\n    const truthyCondition = ir.truthy.map((v) => `${normalized}===${escapeString(v)}`).join(\"||\");\n    const falsyCondition = ir.falsy.map((v) => `${normalized}===${escapeString(v)}`).join(\"||\");\n    code += emit`\n      if(${truthyCondition}){${g.output}=true;}\n      else if(${falsyCondition}){${g.output}=false;}\n      else{${invalidValue(g, valuesExpr, { extra: expectedExtra })}}\n    `;\n  } else {\n    const value = g.temp(\"sbv\");\n    const lookup = emitStringBoolMap(ir, g.ctx);\n    code += emit`\n      var ${value}=${lookup}.get(${normalized});\n      if(${value}===undefined){${invalidValue(g, valuesExpr, { extra: expectedExtra })}}\n      else{${g.output}=${value};}\n    `;\n  }\n\n  code += emit`}`;\n  return `${code}\\n`;\n}\n\nexport function stringBoolUsesInline(ir: StringBoolIR): boolean {\n  return ir.truthy.length <= ENUM_INLINE_THRESHOLD && ir.falsy.length <= ENUM_INLINE_THRESHOLD;\n}\n\n/** One lookup distinguishes true, false and absent; shared by hot and issue walks. */\nexport function emitStringBoolMap(ir: StringBoolIR, ctx: CodeGenContext): string {\n  const pairs = [\n    ...ir.truthy.map((value) => [value, true]),\n    ...ir.falsy.map((value) => [value, false]),\n  ];\n  return emitConstant(ctx, \"map_sb\", `new Map(${JSON.stringify(pairs)})`);\n}\n"],"mappings":";;;;AAMA,SAAgB,eAAe,IAAkB,GAAoB;CACnE,IAAI,OAAO;CAGX,QAAQ,IAAI;gBACE,EAAE,MAAM;QAChB,YAAY,GAAG,QAAQ,EAAE;;;CAK/B,MAAM,aAAa,GAAG,gBAAgB,EAAE,QAAQ,EAAE,KAAK,KAAK;CAC5D,IAAI,CAAC,GAAG,eAAe,QAAQ,OAAO,WAAW,GAAG,EAAE,MAAM;CAC5D,MAAM,YAAY,CAAC,GAAG,GAAG,QAAQ,GAAG,GAAG,KAAK;CAC5C,MAAM,aAAa,KAAK,UAAU,SAAS;CAM3C,MAAM,gBAAgB;CAKtB,IAFkB,qBAAqB,EAE3B,GAAG;EACb,MAAM,kBAAkB,GAAG,OAAO,KAAK,MAAM,GAAG,WAAW,KAAK,aAAa,CAAC,GAAG,CAAC,CAAC,KAAK,IAAI;EAC5F,MAAM,iBAAiB,GAAG,MAAM,KAAK,MAAM,GAAG,WAAW,KAAK,aAAa,CAAC,GAAG,CAAC,CAAC,KAAK,IAAI;EAC1F,QAAQ,IAAI;WACL,gBAAgB,IAAI,EAAE,OAAO;gBACxB,eAAe,IAAI,EAAE,OAAO;aAC/B,aAAa,GAAG,YAAY,EAAE,OAAO,cAAc,CAAC,EAAE;;CAEjE,OAAO;EACL,MAAM,QAAQ,EAAE,KAAK,KAAK;EAC1B,MAAM,SAAS,kBAAkB,IAAI,EAAE,GAAG;EAC1C,QAAQ,IAAI;YACJ,MAAM,GAAG,OAAO,OAAO,WAAW;WACnC,MAAM,gBAAgB,aAAa,GAAG,YAAY,EAAE,OAAO,cAAc,CAAC,EAAE;aAC1E,EAAE,OAAO,GAAG,MAAM;;CAE7B;CAEA,QAAQ,IAAI;CACZ,OAAO,GAAG,KAAK;AACjB;AAEA,SAAgB,qBAAqB,IAA2B;CAC9D,OAAO,GAAG,OAAO,UAAA,KAAmC,GAAG,MAAM,UAAA;AAC/D;;AAGA,SAAgB,kBAAkB,IAAkB,KAA6B;CAC/E,MAAM,QAAQ,CACZ,GAAG,GAAG,OAAO,KAAK,UAAU,CAAC,OAAO,IAAI,CAAC,GACzC,GAAG,GAAG,MAAM,KAAK,UAAU,CAAC,OAAO,KAAK,CAAC,CAC3C;CACA,OAAO,aAAa,KAAK,UAAU,WAAW,KAAK,UAAU,KAAK,EAAE,EAAE;AACxE"}
+{"version":3,"file":"string-bool.js","names":[],"sources":["../../../../src/core/codegen/schemas/string-bool.ts"],"sourcesContent":["import type { StringBoolIR } from \"../../types.js\";\nimport type { CodeGenContext, SlowGen } from \"../context.js\";\nimport { ENUM_INLINE_THRESHOLD, emitConstant, escapeString } from \"../context.js\";\nimport { emit } from \"../emit.js\";\nimport { invalidType, invalidValue } from \"../emit-issue.js\";\n\nexport function slowStringBool(ir: StringBoolIR, g: SlowGen): string {\n  let code = \"\";\n\n  // Type check: input must be a string\n  code += emit`\n    if(typeof ${g.input}!==\"string\"){\n      ${invalidType(g, \"string\")}\n    }else{\n  `;\n\n  const allValues = [...ir.truthy, ...ir.falsy];\n  const valuesExpr = JSON.stringify(allValues);\n  // z.stringbool() is a Codec whose transform pushes\n  // `{ code: \"invalid_value\", expected: \"stringbool\", values: [...] }` — the\n  // only invalid_value producer that carries an `expected` (enum and literal\n  // push `values` alone), and zod's locale keys off it. Both emitted lookups\n  // below share this so the two code paths cannot drift apart.\n  const expectedExtra = 'expected:\"stringbool\"';\n\n  // Compare per-side counts against threshold (not the combined total)\n  const useInline = stringBoolUsesInline(ir);\n\n  // Case-insensitive matching tries the input VERBATIM before lowercasing it:\n  // the accepted spellings are all lowercase, so an exact hit and the\n  // lowercased hit are the same string. See buildStringBool for the measured\n  // trade; this is the same shape on the eager walk.\n  if (useInline) {\n    const normalized = ir.caseSensitive ? g.input : g.temp(\"sbn\");\n    if (!ir.caseSensitive) {\n      code += `var ${normalized}=${stringBoolInlineHit(ir, g.input)}?${g.input}:${g.input}.toLowerCase();`;\n    }\n    const truthyCondition = ir.truthy.map((v) => `${normalized}===${escapeString(v)}`).join(\"||\");\n    const falsyCondition = ir.falsy.map((v) => `${normalized}===${escapeString(v)}`).join(\"||\");\n    code += emit`\n      if(${truthyCondition}){${g.output}=true;}\n      else if(${falsyCondition}){${g.output}=false;}\n      else{${invalidValue(g, valuesExpr, { extra: expectedExtra })}}\n    `;\n  } else {\n    const value = g.temp(\"sbv\");\n    const lookup = emitStringBoolMap(ir, g.ctx);\n    const lowered = g.temp(\"sbn\");\n    const retry = ir.caseSensitive\n      ? \"\"\n      : `if(${value}===undefined){var ${lowered}=${g.input}.toLowerCase();` +\n        `if(${lowered}!==${g.input}){${value}=${lookup}.get(${lowered});}}`;\n    code += emit`\n      var ${value}=${lookup}.get(${g.input});${retry}\n      if(${value}===undefined){${invalidValue(g, valuesExpr, { extra: expectedExtra })}}\n      else{${g.output}=${value};}\n    `;\n  }\n\n  code += emit`}`;\n  return `${code}\\n`;\n}\n\nexport function stringBoolUsesInline(ir: StringBoolIR): boolean {\n  return ir.truthy.length <= ENUM_INLINE_THRESHOLD && ir.falsy.length <= ENUM_INLINE_THRESHOLD;\n}\n\n/**\n * Boolean expression: is `input` verbatim one of an INLINE codec's spellings?\n *\n * The accepted lists come from probing the schema with lowercase candidates\n * (see extractStringBool), so for a case-insensitive codec an exact hit is\n * exactly what `input.toLowerCase()` would have produced — and a handful of\n * `===` on internalized strings is cheaper than the `toLowerCase()` call. The\n * hashed form has no use for this: there the verbatim `Map.get` IS the lookup,\n * retried on the lowercased string only when it misses.\n */\nexport function stringBoolInlineHit(ir: StringBoolIR, input: string): string {\n  return [...ir.truthy, ...ir.falsy].map((v) => `${input}===${escapeString(v)}`).join(\"||\");\n}\n\n/** One lookup distinguishes true, false and absent; shared by hot and issue walks. */\nexport function emitStringBoolMap(ir: StringBoolIR, ctx: CodeGenContext): string {\n  const pairs = [\n    ...ir.truthy.map((value) => [value, true]),\n    ...ir.falsy.map((value) => [value, false]),\n  ];\n  return emitConstant(ctx, \"map_sb\", `new Map(${JSON.stringify(pairs)})`);\n}\n"],"mappings":";;;;AAMA,SAAgB,eAAe,IAAkB,GAAoB;CACnE,IAAI,OAAO;CAGX,QAAQ,IAAI;gBACE,EAAE,MAAM;QAChB,YAAY,GAAG,QAAQ,EAAE;;;CAI/B,MAAM,YAAY,CAAC,GAAG,GAAG,QAAQ,GAAG,GAAG,KAAK;CAC5C,MAAM,aAAa,KAAK,UAAU,SAAS;CAM3C,MAAM,gBAAgB;CAStB,IANkB,qBAAqB,EAM3B,GAAG;EACb,MAAM,aAAa,GAAG,gBAAgB,EAAE,QAAQ,EAAE,KAAK,KAAK;EAC5D,IAAI,CAAC,GAAG,eACN,QAAQ,OAAO,WAAW,GAAG,oBAAoB,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM;EAEtF,MAAM,kBAAkB,GAAG,OAAO,KAAK,MAAM,GAAG,WAAW,KAAK,aAAa,CAAC,GAAG,CAAC,CAAC,KAAK,IAAI;EAC5F,MAAM,iBAAiB,GAAG,MAAM,KAAK,MAAM,GAAG,WAAW,KAAK,aAAa,CAAC,GAAG,CAAC,CAAC,KAAK,IAAI;EAC1F,QAAQ,IAAI;WACL,gBAAgB,IAAI,EAAE,OAAO;gBACxB,eAAe,IAAI,EAAE,OAAO;aAC/B,aAAa,GAAG,YAAY,EAAE,OAAO,cAAc,CAAC,EAAE;;CAEjE,OAAO;EACL,MAAM,QAAQ,EAAE,KAAK,KAAK;EAC1B,MAAM,SAAS,kBAAkB,IAAI,EAAE,GAAG;EAC1C,MAAM,UAAU,EAAE,KAAK,KAAK;EAC5B,MAAM,QAAQ,GAAG,gBACb,KACA,MAAM,MAAM,oBAAoB,QAAQ,GAAG,EAAE,MAAM,oBAC7C,QAAQ,KAAK,EAAE,MAAM,IAAI,MAAM,GAAG,OAAO,OAAO,QAAQ;EAClE,QAAQ,IAAI;YACJ,MAAM,GAAG,OAAO,OAAO,EAAE,MAAM,IAAI,MAAM;WAC1C,MAAM,gBAAgB,aAAa,GAAG,YAAY,EAAE,OAAO,cAAc,CAAC,EAAE;aAC1E,EAAE,OAAO,GAAG,MAAM;;CAE7B;CAEA,QAAQ,IAAI;CACZ,OAAO,GAAG,KAAK;AACjB;AAEA,SAAgB,qBAAqB,IAA2B;CAC9D,OAAO,GAAG,OAAO,UAAA,KAAmC,GAAG,MAAM,UAAA;AAC/D;;;;;;;;;;;AAYA,SAAgB,oBAAoB,IAAkB,OAAuB;CAC3E,OAAO,CAAC,GAAG,GAAG,QAAQ,GAAG,GAAG,KAAK,CAAC,CAAC,KAAK,MAAM,GAAG,MAAM,KAAK,aAAa,CAAC,GAAG,CAAC,CAAC,KAAK,IAAI;AAC1F;;AAGA,SAAgB,kBAAkB,IAAkB,KAA6B;CAC/E,MAAM,QAAQ,CACZ,GAAG,GAAG,OAAO,KAAK,UAAU,CAAC,OAAO,IAAI,CAAC,GACzC,GAAG,GAAG,MAAM,KAAK,UAAU,CAAC,OAAO,KAAK,CAAC,CAC3C;CACA,OAAO,aAAa,KAAK,UAAU,WAAW,KAAK,UAAU,KAAK,EAAE,EAAE;AACxE"}

package/dist/core/codegen/schemas/string.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"string.d.ts","names":[],"sources":["../../../../src/core/codegen/schemas/string.ts"],"mappings":";;;iBAuEgB,WAAW,IAAI,UAAU,GAAG;;;;;;;;;;;iBAmJ5B,gBAAgB,OAAO,SAAS,WAAW,KAAK;iBAkDhD,WAAW,IAAI,UAAU,GAAG"}
+{"version":3,"file":"string.d.ts","names":[],"sources":["../../../../src/core/codegen/schemas/string.ts"],"mappings":";;;iBA2GgB,WAAW,IAAI,UAAU,GAAG;;;;;;;;;;;iBAmK5B,gBAAgB,OAAO,SAAS,WAAW,KAAK;iBAuDhD,WAAW,IAAI,UAAU,GAAG"}