@amritk/generate-validators 0.13.1 → 0.14.0

package/dist/generators/generate-validator-function.js

@@ -1,6 +1,7 @@
 import { regexFlagsFor, regexLiteral } from "@amritk/helpers/escape-regex-pattern";
 import { getMjstInstanceOf, getMjstPrimitive, MJST_EXTENSION_KEY } from "@amritk/helpers/mjst-extension";
 import { multipleOfFailExpr, multipleOfPassExpr } from "@amritk/helpers/multiple-of-check";
+import { declaresKey, readKey } from "@amritk/helpers/read-key";
 import { refToName } from "@amritk/helpers/ref-to-name";
 import { safeAccessor } from "@amritk/helpers/safe-accessor";
 import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasDependentRequired, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMaxProperties, hasMinItems, hasMinimum, hasMinLength, hasMinProperties, hasMultipleOf, hasOneOf, hasPattern, hasProperties, hasPropertyNames, hasRef, hasRequired, hasStrictExclusiveMaximum, hasStrictExclusiveMinimum, hasType, hasUniqueItems, isObjectSchema, isSchemaObject } from "@amritk/helpers/schema-guards";
@@ -49,7 +50,7 @@ const SCALAR_ITEM_TYPES = /* @__PURE__ */ new Set(["string", "number", "integer"
 const schemaIsScalarOnly = (schema) => {
   if (!isSchemaObject(schema))
     return false;
-  const t = schema["type"];
+  const t = readKey(schema, "type");
   if (t === void 0)
     return false;
   const types = Array.isArray(t) ? t : [t];
@@ -89,31 +90,40 @@ const wrongTypeCondition = (accessor, type) => {
 const declaresObjectType = (schema) => hasType(schema) && schema.type === "object";
 const objectRootIsSelfContained = (schema) => !hasRef(schema) && !hasConst(schema) && !hasEnum(schema) && getMjstInstanceOf(schema) === void 0 && getMjstPrimitive(schema) === void 0;
 const getTypeArray = (schema) => {
-  if (!isSchemaObject(schema) || !("type" in schema) || !Array.isArray(schema.type))
+  if (!isSchemaObject(schema) || !declaresKey(schema, "type") || !Array.isArray(schema.type))
     return null;
   return schema.type;
 };
+const ROOT_ERROR_SINK = "(errors ??= [])";
+const MATCH_ERROR_SINK = "_m";
 const createRootContext = (rootSchema) => ({
   objVar: "obj",
   pathPrefix: "${_path}",
   depth: 0,
   hoisted: [],
-  rootSchema
+  rootSchema,
+  sink: ROOT_ERROR_SINK
 });
-const pointerSegment = (key) => key.replace(/~/g, "~0").replace(/\//g, "~1").replace(/[\\`$]/g, "\\$&");
+const pointerSegment = (key) => {
+  const pointer = key.replace(/~/g, "~0").replace(/\//g, "~1");
+  return JSON.stringify(pointer).slice(1, -1).replace(/[`$]/g, "\\$&");
+};
 const patternPropertySources = (schema) => {
-  if (!isSchemaObject(schema) || !("patternProperties" in schema))
+  if (!isSchemaObject(schema) || !declaresKey(schema, "patternProperties"))
     return [];
   const patterns = schema.patternProperties;
   if (typeof patterns !== "object" || patterns === null)
     return [];
   return Object.keys(patterns);
 };
-const readsObjBinding = (text) => /\bobj\b/.test(text);
+const readsBinding = (name, text) => new RegExp(`\\b${name}\\b`).test(text);
+const readsObjBinding = (text) => readsBinding("obj", text);
 const withHoisted = (hoisted, text) => {
   const kept = hoisted.filter((entry) => text.includes(entry.reference)).map((entry) => entry.declaration);
-  const reads = text.replaceAll("(input: unknown", "(");
-  const body = /\binput\b/.test(reads) ? text : text.replaceAll("(input: unknown", "(_input: unknown");
+  const firstBreak = text.indexOf("\n");
+  const signature = firstBreak === -1 ? text : text.slice(0, firstBreak);
+  const rest = firstBreak === -1 ? "" : text.slice(firstBreak);
+  const body = /\binput\b/.test(rest) ? text : signature.replace("(input: unknown", "(_input: unknown") + rest;
   return kept.length > 0 ? `${kept.join("\n")}
 
 ${body}` : body;
@@ -145,7 +155,7 @@ const generateStrictKeyChecks = (schema, ctx) => {
   return [
     `  for (const _key${d} in ${ctx.objVar}) {`,
     `    if (${unknownTest}${patternGuard}) {`,
-    `      errors.push({ message: 'must NOT have additional properties', path: \`${ctx.pathPrefix}/\${escapePointer(_key${d})}\` })`,
+    `      ${ctx.sink}.push({ message: 'must NOT have additional properties', path: \`${ctx.pathPrefix}/\${escapePointer(_key${d})}\` })`,
     `    }`,
     `  }`
   ];
@@ -160,7 +170,7 @@ const generateMissingRequiredChecks = (schema, ctx) => {
     if (Object.hasOwn(props, key))
       continue;
     lines.push(`  if (${missingCheck(ctx.objVar, key)}) {`);
-    lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
+    lines.push(`    ${ctx.sink}.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
     lines.push(`  }`);
   }
   return lines;
@@ -172,15 +182,15 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix, ctx) => {
     if (isRequired) {
       return [
         `  if (${missingCheck(ctx.objVar, key)}) {`,
-        `    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`,
+        `    ${ctx.sink}.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`,
         `  } else {`,
-        `    errors.push({ message: ${JSON.stringify(FALSE_SCHEMA_MESSAGE)}, path: ${path} })`,
+        `    ${ctx.sink}.push({ message: ${JSON.stringify(FALSE_SCHEMA_MESSAGE)}, path: ${path} })`,
         `  }`
       ];
     }
     return [
       `  if (${hasOwnCheck(ctx.objVar, key)}) {`,
-      `    errors.push({ message: ${JSON.stringify(FALSE_SCHEMA_MESSAGE)}, path: ${path} })`,
+      `    ${ctx.sink}.push({ message: ${JSON.stringify(FALSE_SCHEMA_MESSAGE)}, path: ${path} })`,
       `  }`
     ];
   }
@@ -215,35 +225,35 @@ const generateKeywordChecks = (key, raw, path, schema, suffix, ctx, presence) =>
   const lines = [];
   if (hasRef(schema)) {
     const vName = validatorName(refToName(schema.$ref, suffix));
-    const delegate = [`  const _r = ${vName}(${raw}, ${path})`, `  if (_r !== true) errors.push(..._r.errors)`];
+    const delegate = [`  const _r = ${vName}(${raw}, ${path})`, `  if (_r !== true) ${ctx.sink}.push(..._r.errors)`];
     if (presence === "")
-      lines.push(...delegate);
+      lines.push(`  {`, ...delegate.map((line) => `  ${line}`), `  }`);
     else
       lines.push(`  if (${raw} !== undefined) {`, ...delegate.map((line) => `  ${line}`), `  }`);
   }
   const instanceOf = getMjstInstanceOf(schema);
   if (instanceOf) {
     lines.push(`  if (${presence}!(${raw} instanceof ${instanceOf})) {`);
-    lines.push(`    errors.push({ message: 'must be ${instanceOf}', path: ${path} })`);
+    lines.push(`    ${ctx.sink}.push({ message: 'must be ${instanceOf}', path: ${path} })`);
     lines.push(`  }`);
   }
   const primitive = getMjstPrimitive(schema);
   if (primitive) {
     lines.push(`  if (${presence}typeof ${raw} !== "${primitive}") {`);
-    lines.push(`    errors.push({ message: 'must be ${primitive}', path: ${path} })`);
+    lines.push(`    ${ctx.sink}.push({ message: 'must be ${primitive}', path: ${path} })`);
     lines.push(`  }`);
   }
   if (hasConst(schema)) {
     const mismatch = constMismatchCondition(raw, schema.const);
     const msg = JSON.stringify(`must be ${JSON.stringify(schema.const)}`);
     lines.push(`  if (${presence}${mismatch}) {`);
-    lines.push(`    errors.push({ message: ${msg}, path: ${path} })`);
+    lines.push(`    ${ctx.sink}.push({ message: ${msg}, path: ${path} })`);
     lines.push(`  }`);
   }
   if (hasEnum(schema)) {
     const label = schema.enum.map((v) => JSON.stringify(v)).join(", ");
     lines.push(`  if (${presence}!${enumMembershipExpr(schema.enum, raw)}) {`);
-    lines.push(`    errors.push({ message: ${JSON.stringify(`must be one of: ${label}`)}, path: ${path} })`);
+    lines.push(`    ${ctx.sink}.push({ message: ${JSON.stringify(`must be one of: ${label}`)}, path: ${path} })`);
     lines.push(`  }`);
   }
   if (instanceOf === void 0 && primitive === void 0) {
@@ -252,7 +262,7 @@ const generateKeywordChecks = (key, raw, path, schema, suffix, ctx, presence) =>
       const wrongType = wrongTypeCondition(raw, t);
       if (wrongType) {
         lines.push(`  if (${presence === "" ? wrongType : `${presence}(${wrongType})`}) {`);
-        lines.push(`    errors.push({ message: 'must be ${typeofString(t)}', path: ${path} })`);
+        lines.push(`    ${ctx.sink}.push({ message: 'must be ${typeofString(t)}', path: ${path} })`);
         lines.push(`  }`);
       }
     }
@@ -262,7 +272,7 @@ const generateKeywordChecks = (key, raw, path, schema, suffix, ctx, presence) =>
       if (allWrong) {
         const label = typeArray.map((t) => typeofString(t)).join(" or ");
         lines.push(`  if (${presence === "" ? allWrong : `${presence}(${allWrong})`}) {`);
-        lines.push(`    errors.push({ message: ${JSON.stringify(`must be ${label}`)}, path: ${path} })`);
+        lines.push(`    ${ctx.sink}.push({ message: ${JSON.stringify(`must be ${label}`)}, path: ${path} })`);
         lines.push(`  }`);
       }
     }
@@ -281,7 +291,7 @@ const generatePropertyCheckLines = (key, propSchema, isRequired, suffix, ctx) =>
   const parentPath = ctx.depth === 0 ? "_path" : `\`${ctx.pathPrefix}\``;
   const missing = [
     `  if (${missingCheck(ctx.objVar, key)}) {`,
-    `    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`
+    `    ${ctx.sink}.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`
   ];
   if (!isSchemaObject(propSchema)) {
     if (isRequired && propSchema === true)
@@ -311,17 +321,17 @@ const generateConstraintChecks = (key, raw, path, propSchema, suffix, ctx) => {
       const re = regexLiteral(propSchema.pattern);
       const msg = JSON.stringify(`must match pattern ${propSchema.pattern}`);
       lines.push(`  if (typeof ${raw} === 'string' && !${re}.test(${raw})) {`);
-      lines.push(`    errors.push({ message: ${msg}, path: ${path} })`);
+      lines.push(`    ${ctx.sink}.push({ message: ${msg}, path: ${path} })`);
       lines.push(`  }`);
     }
     if (hasMinLength(propSchema) && propSchema.minLength > 0) {
       lines.push(`  if (typeof ${raw} === 'string' && ${minLengthFailExpr(raw, propSchema.minLength)}) {`);
-      lines.push(`    errors.push({ message: 'must have at least ${propSchema.minLength} characters', path: ${path} })`);
+      lines.push(`    ${ctx.sink}.push({ message: 'must have at least ${propSchema.minLength} characters', path: ${path} })`);
       lines.push(`  }`);
     }
     if (hasMaxLength(propSchema)) {
       lines.push(`  if (typeof ${raw} === 'string' && ${maxLengthFailExpr(raw, propSchema.maxLength)}) {`);
-      lines.push(`    errors.push({ message: 'must have at most ${propSchema.maxLength} characters', path: ${path} })`);
+      lines.push(`    ${ctx.sink}.push({ message: 'must have at most ${propSchema.maxLength} characters', path: ${path} })`);
       lines.push(`  }`);
     }
   }
@@ -330,29 +340,29 @@ const generateConstraintChecks = (key, raw, path, propSchema, suffix, ctx) => {
       const strict = hasStrictExclusiveMinimum(propSchema);
       const rel = strict ? ">" : ">=";
       lines.push(`  if (typeof ${raw} === 'number' && !(${raw} ${rel} ${propSchema.minimum})) {`);
-      lines.push(`    errors.push({ message: 'must be ${rel} ${propSchema.minimum}', path: ${path} })`);
+      lines.push(`    ${ctx.sink}.push({ message: 'must be ${rel} ${propSchema.minimum}', path: ${path} })`);
       lines.push(`  }`);
     }
     if (hasMaximum(propSchema)) {
       const strict = hasStrictExclusiveMaximum(propSchema);
       const rel = strict ? "<" : "<=";
       lines.push(`  if (typeof ${raw} === 'number' && !(${raw} ${rel} ${propSchema.maximum})) {`);
-      lines.push(`    errors.push({ message: 'must be ${rel} ${propSchema.maximum}', path: ${path} })`);
+      lines.push(`    ${ctx.sink}.push({ message: 'must be ${rel} ${propSchema.maximum}', path: ${path} })`);
       lines.push(`  }`);
     }
     if (hasExclusiveMinimum(propSchema)) {
       lines.push(`  if (typeof ${raw} === 'number' && !(${raw} > ${propSchema.exclusiveMinimum})) {`);
-      lines.push(`    errors.push({ message: 'must be > ${propSchema.exclusiveMinimum}', path: ${path} })`);
+      lines.push(`    ${ctx.sink}.push({ message: 'must be > ${propSchema.exclusiveMinimum}', path: ${path} })`);
       lines.push(`  }`);
     }
     if (hasExclusiveMaximum(propSchema)) {
       lines.push(`  if (typeof ${raw} === 'number' && !(${raw} < ${propSchema.exclusiveMaximum})) {`);
-      lines.push(`    errors.push({ message: 'must be < ${propSchema.exclusiveMaximum}', path: ${path} })`);
+      lines.push(`    ${ctx.sink}.push({ message: 'must be < ${propSchema.exclusiveMaximum}', path: ${path} })`);
       lines.push(`  }`);
     }
     if (hasMultipleOf(propSchema)) {
       lines.push(`  if (typeof ${raw} === 'number' && ${multipleOfFailExpr(raw, propSchema.multipleOf)}) {`);
-      lines.push(`    errors.push({ message: 'must be a multiple of ${propSchema.multipleOf}', path: ${path} })`);
+      lines.push(`    ${ctx.sink}.push({ message: 'must be a multiple of ${propSchema.multipleOf}', path: ${path} })`);
       lines.push(`  }`);
     }
   }
@@ -367,7 +377,7 @@ const generateConstraintChecks = (key, raw, path, propSchema, suffix, ctx) => {
       lines.push(`  if (Array.isArray(${raw})) {`);
       lines.push(`    for (let ${iv} = ${firstTailIndex}; ${iv} < ${raw}.length; ${iv}++) {`);
       lines.push(`      const _ir = ${vName}(${raw}[${iv}], ${itemPath})`);
-      lines.push(`      if (_ir !== true) errors.push(..._ir.errors)`);
+      lines.push(`      if (_ir !== true) ${ctx.sink}.push(..._ir.errors)`);
       lines.push(`    }`);
       lines.push(`  }`);
     } else if (isSchemaObject(itemSchema)) {
@@ -376,46 +386,72 @@ const generateConstraintChecks = (key, raw, path, propSchema, suffix, ctx) => {
       if (detail.length > 0) {
         lines.push(`  if (Array.isArray(${raw})) {`);
         lines.push(`    for (let ${iv} = ${firstTailIndex}; ${iv} < ${raw}.length; ${iv}++) {`);
-        lines.push(`      const ${itemVar} = ${raw}[${iv}]`);
+        if (readsBinding(itemVar, detail.join("\n")))
+          lines.push(`      const ${itemVar} = ${raw}[${iv}]`);
         lines.push(...detail.map((l) => `    ${l}`));
         lines.push(`    }`);
         lines.push(`  }`);
       }
     }
   }
-  if (hasMinItems(propSchema) || hasMaxItems(propSchema) || hasUniqueItems(propSchema) && propSchema.uniqueItems === true || "contains" in sp || tuple !== void 0 || tail === false && tuple === void 0) {
+  if (hasMinItems(propSchema) || hasMaxItems(propSchema) || hasUniqueItems(propSchema) && propSchema.uniqueItems === true || declaresKey(sp, "contains") || tuple !== void 0 || tail === false && tuple === void 0) {
     if (tail === false && tuple === void 0) {
       lines.push(`  if (Array.isArray(${raw}) && ${raw}.length > 0) {`);
-      lines.push(`    errors.push({ message: 'must NOT have more than 0 items', path: ${path} })`);
+      lines.push(`    ${ctx.sink}.push({ message: 'must NOT have more than 0 items', path: ${path} })`);
       lines.push(`  }`);
     }
     if (hasMinItems(propSchema)) {
       lines.push(`  if (Array.isArray(${raw}) && ${raw}.length < ${propSchema.minItems}) {`);
-      lines.push(`    errors.push({ message: 'must have at least ${propSchema.minItems} items', path: ${path} })`);
+      lines.push(`    ${ctx.sink}.push({ message: 'must have at least ${propSchema.minItems} items', path: ${path} })`);
       lines.push(`  }`);
     }
     if (hasMaxItems(propSchema)) {
       lines.push(`  if (Array.isArray(${raw}) && ${raw}.length > ${propSchema.maxItems}) {`);
-      lines.push(`    errors.push({ message: 'must have at most ${propSchema.maxItems} items', path: ${path} })`);
+      lines.push(`    ${ctx.sink}.push({ message: 'must have at most ${propSchema.maxItems} items', path: ${path} })`);
       lines.push(`  }`);
     }
     if (hasUniqueItems(propSchema) && propSchema.uniqueItems === true) {
-      const dupCond = arrayItemsAreScalarOnly(sp) ? `new Set((${raw} as unknown[]).map((_u) => JSON.stringify(_u))).size !== ${raw}.length` : `!allUnique(${raw} as unknown[])`;
+      const dupCond = arrayItemsAreScalarOnly(sp) ? `new Set(${raw} as unknown[]).size !== ${raw}.length` : `!allUnique(${raw} as unknown[])`;
       lines.push(`  if (Array.isArray(${raw}) && ${dupCond}) {`);
-      lines.push(`    errors.push({ message: 'must NOT have duplicate items', path: ${path} })`);
+      lines.push(`    ${ctx.sink}.push({ message: 'must NOT have duplicate items', path: ${path} })`);
       lines.push(`  }`);
     }
-    if ("contains" in sp) {
-      const min = typeof sp["minContains"] === "number" ? sp["minContains"] : 1;
-      const max = typeof sp["maxContains"] === "number" ? sp["maxContains"] : void 0;
-      const matchExpr = generateMatchesExpr("_c", sp["contains"], suffix, ctx);
-      const bound = max !== void 0 ? `_cn < ${min} || _cn > ${max}` : `_cn < ${min}`;
-      lines.push(`  if (Array.isArray(${raw})) {`);
-      lines.push(`    const _cn = (${raw} as unknown[]).filter((_c) => ${matchExpr}).length`);
-      lines.push(`    if (${bound}) {`);
-      lines.push(`      errors.push({ message: 'array does not contain the required matching items', path: ${path} })`);
-      lines.push(`    }`);
-      lines.push(`  }`);
+    if (declaresKey(sp, "contains")) {
+      const declaredMin = readKey(sp, "minContains");
+      const declaredMax = readKey(sp, "maxContains");
+      const min = typeof declaredMin === "number" ? declaredMin : 1;
+      const max = typeof declaredMax === "number" ? declaredMax : void 0;
+      if (min > 0 || max !== void 0) {
+        const matchExpr = generateMatchesExpr("_c", readKey(sp, "contains"), suffix, ctx, true);
+        const report = `${ctx.sink}.push({ message: 'array does not contain the required matching items', path: ${path} })`;
+        if (matchExpr === "true") {
+          const bound = max !== void 0 ? `${raw}.length < ${min} || ${raw}.length > ${max}` : `${raw}.length < ${min}`;
+          lines.push(`  if (Array.isArray(${raw}) && (${bound})) {`);
+          lines.push(`    ${report}`);
+          lines.push(`  }`);
+        } else if (matchExpr === "false") {
+          if (0 < min || max !== void 0 && 0 > max) {
+            lines.push(`  if (Array.isArray(${raw})) {`);
+            lines.push(`    ${report}`);
+            lines.push(`  }`);
+          }
+        } else {
+          const bound = max !== void 0 ? `_cn < ${min} || _cn > ${max}` : `_cn < ${min}`;
+          lines.push(`  if (Array.isArray(${raw})) {`);
+          lines.push(`    const _ca = ${raw} as unknown[]`);
+          lines.push(`    let _cn = 0`);
+          lines.push(`    for (let _ci = 0; _ci < _ca.length; _ci++) {`);
+          lines.push(`      const _c = _ca[_ci]`);
+          lines.push(`      if (${matchExpr}) _cn++`);
+          if (max === void 0)
+            lines.push(`      if (_cn >= ${min}) break`);
+          lines.push(`    }`);
+          lines.push(`    if (${bound}) {`);
+          lines.push(`      ${report}`);
+          lines.push(`    }`);
+          lines.push(`  }`);
+        }
+      }
     }
     if (tuple !== void 0) {
       lines.push(`  if (Array.isArray(${raw})) {`);
@@ -429,7 +465,7 @@ const generateConstraintChecks = (key, raw, path, propSchema, suffix, ctx) => {
       }
       if (tailIsClosed) {
         lines.push(`    if (${raw}.length > ${tuple.length}) {`);
-        lines.push(`      errors.push({ message: 'must NOT have more than ${tuple.length} items', path: ${path} })`);
+        lines.push(`      ${ctx.sink}.push({ message: 'must NOT have more than ${tuple.length} items', path: ${path} })`);
         lines.push(`    }`);
       }
       lines.push(`  }`);
@@ -449,9 +485,9 @@ const generateValueChecks = (key, raw, path, propSchema, suffix, ctx, required =
 const generateValueCheckLines = (_key, raw, path, propSchema, suffix, ctx, required = false) => {
   const lines = [];
   if (propSchema === false) {
-    const report = `errors.push({ message: ${JSON.stringify(FALSE_SCHEMA_MESSAGE)}, path: ${path} })`;
+    const report = `${ctx.sink}.push({ message: ${JSON.stringify(FALSE_SCHEMA_MESSAGE)}, path: ${path} })`;
     if (required)
-      return [`  ${report}`];
+      return [`  {`, `    ${report}`, `  }`];
     return [`  if (${raw} !== undefined) {`, `    ${report}`, `  }`];
   }
   if (!isSchemaObject(propSchema))
@@ -462,13 +498,14 @@ const generateValueCheckLines = (_key, raw, path, propSchema, suffix, ctx, requi
     pathPrefix: path.slice(1, -1),
     depth: ctx.depth + 1,
     hoisted: ctx.hoisted,
-    rootSchema: ctx.rootSchema
+    rootSchema: ctx.rootSchema,
+    sink: ctx.sink
   };
   lines.push(...generateKeywordChecks("", raw, path, propSchema, suffix, valueCtx, presence));
   return lines;
 };
 const NARROWABLE_REFERENCE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\[[A-Za-z_$][\w$]*\]|\[\d+\])*$/;
-const generateMatchesExpr = (raw, sub, suffix, ctx) => {
+const generateMatchesExpr = (raw, sub, suffix, ctx, required = false) => {
   if (sub === true)
     return "true";
   if (sub === false)
@@ -476,22 +513,30 @@ const generateMatchesExpr = (raw, sub, suffix, ctx) => {
   if (!isSchemaObject(sub))
     return "true";
   const value = NARROWABLE_REFERENCE.test(raw) ? raw : `_mv${ctx.depth}`;
-  const checks = generateValueChecks("", value, "`${_path}`", sub, suffix, ctx);
+  const checks = generateValueChecks("", value, "`${_path}`", sub, suffix, { ...ctx, sink: MATCH_ERROR_SINK }, required);
   if (checks.length === 0)
     return "true";
-  const body = checks.join("\n").replaceAll("errors.push(", "_m.push(");
+  const body = checks.join("\n");
   const binding = value === raw ? "" : `const ${value}: unknown = ${raw}
 `;
   return `((): boolean => { const _m: ValidationError[] = []
 ${binding}${body}
     return _m.length === 0 })()`;
 };
-const unevaluatedMatcher = (suffix, ctx) => (accessor, schema, depth) => generateMatchesExpr(accessor, schema, suffix, { ...ctx, depth: ctx.depth + depth + 1 });
+const unevaluatedMatcher = (suffix, ctx) => (accessor, schema, depth) => (
+  // Always `required`: every accessor handed to this matcher is a value the
+  // surrounding test has already established is there — the whole instance
+  // inside its type guard, or a key/index the sweep is walking. In optional
+  // mode a property whose value is `undefined` matched every branch, so
+  // `{ a: undefined }` satisfied an `unevaluatedProperties: { type: 'string' }`
+  // that Ajv and the interpreter both reject.
+  generateMatchesExpr(accessor, schema, suffix, { ...ctx, depth: ctx.depth + depth + 1 }, true)
+);
 const generateUnevaluatedChecks = (raw, path, schema, suffix, ctx) => {
   if (!isSchemaObject(schema))
     return [];
   const s = schema;
-  if (!("unevaluatedProperties" in s) && !("unevaluatedItems" in s))
+  if (!declaresKey(s, "unevaluatedProperties") && !declaresKey(s, "unevaluatedItems"))
     return [];
   const match = unevaluatedMatcher(suffix, ctx);
   const lines = [];
@@ -503,7 +548,7 @@ const generateUnevaluatedChecks = (raw, path, schema, suffix, ctx) => {
     for (const statement of properties.setup)
       lines.push(`    ${statement}`);
     lines.push(`    if (!(${properties.expr})) {`);
-    lines.push(`      errors.push({ message: 'must NOT have unevaluated properties', path: ${path} })`);
+    lines.push(`      ${ctx.sink}.push({ message: 'must NOT have unevaluated properties', path: ${path} })`);
     lines.push(`    }`);
     lines.push(`  }`);
   }
@@ -515,7 +560,7 @@ const generateUnevaluatedChecks = (raw, path, schema, suffix, ctx) => {
     for (const statement of items.setup)
       lines.push(`    ${statement}`);
     lines.push(`    if (!(${items.expr})) {`);
-    lines.push(`      errors.push({ message: 'must NOT have unevaluated items', path: ${path} })`);
+    lines.push(`      ${ctx.sink}.push({ message: 'must NOT have unevaluated items', path: ${path} })`);
     lines.push(`    }`);
     lines.push(`  }`);
   }
@@ -527,39 +572,39 @@ const generateCombinatorChecks = (key, raw, path, schema, suffix, ctx) => {
   const lines = [];
   if (hasAllOf(schema)) {
     for (const branch of schema.allOf)
-      lines.push(...generateValueChecks(key, raw, path, branch, suffix, ctx));
+      lines.push(...generateValueChecks(key, raw, path, branch, suffix, ctx, true));
   }
   if (hasAnyOf(schema) && schema.anyOf.length > 0) {
-    const conds = schema.anyOf.map((b) => generateMatchesExpr(raw, b, suffix, ctx));
+    const conds = schema.anyOf.map((b) => generateMatchesExpr(raw, b, suffix, ctx, true));
     if (!conds.includes("true")) {
       lines.push(`  if (!(${conds.join(" || ")})) {`);
-      lines.push(`    errors.push({ message: 'must match a schema in anyOf', path: ${path} })`);
+      lines.push(`    ${ctx.sink}.push({ message: 'must match a schema in anyOf', path: ${path} })`);
       lines.push(`  }`);
     }
   }
   if (hasOneOf(schema) && schema.oneOf.length > 0) {
-    const conds = schema.oneOf.map((b) => `(${generateMatchesExpr(raw, b, suffix, ctx)} ? 1 : 0)`);
+    const conds = schema.oneOf.map((b) => `(${generateMatchesExpr(raw, b, suffix, ctx, true)} ? 1 : 0)`);
     lines.push(`  if ((${conds.join(" + ")}) !== 1) {`);
-    lines.push(`    errors.push({ message: 'must match exactly one schema in oneOf', path: ${path} })`);
+    lines.push(`    ${ctx.sink}.push({ message: 'must match exactly one schema in oneOf', path: ${path} })`);
     lines.push(`  }`);
   }
-  const not = schema["not"];
+  const not = readKey(schema, "not");
   if (not !== void 0 && (isSchemaObject(not) || typeof not === "boolean")) {
-    const cond = generateMatchesExpr(raw, not, suffix, ctx);
+    const cond = generateMatchesExpr(raw, not, suffix, ctx, true);
     if (cond !== "false") {
       lines.push(`  if (${cond}) {`);
-      lines.push(`    errors.push({ message: 'must NOT match the schema in not', path: ${path} })`);
+      lines.push(`    ${ctx.sink}.push({ message: 'must NOT match the schema in not', path: ${path} })`);
       lines.push(`  }`);
     }
   }
-  const ifSchema = schema["if"];
+  const ifSchema = readKey(schema, "if");
   if (ifSchema !== void 0 && (isSchemaObject(ifSchema) || typeof ifSchema === "boolean")) {
-    const thenSchema = schema["then"];
-    const elseSchema = schema["else"];
-    const thenLines = thenSchema !== void 0 ? generateValueChecks(key, raw, path, thenSchema, suffix, ctx) : [];
-    const elseLines = elseSchema !== void 0 ? generateValueChecks(key, raw, path, elseSchema, suffix, ctx) : [];
+    const thenSchema = readKey(schema, "then");
+    const elseSchema = readKey(schema, "else");
+    const thenLines = thenSchema !== void 0 ? generateValueChecks(key, raw, path, thenSchema, suffix, ctx, true) : [];
+    const elseLines = elseSchema !== void 0 ? generateValueChecks(key, raw, path, elseSchema, suffix, ctx, true) : [];
     if (thenLines.length > 0 || elseLines.length > 0) {
-      const cond = generateMatchesExpr(raw, ifSchema, suffix, ctx);
+      const cond = generateMatchesExpr(raw, ifSchema, suffix, ctx, true);
       if (cond === "true") {
         lines.push(...thenLines);
       } else if (cond === "false") {
@@ -580,38 +625,48 @@ const generatePatternAndAdditionalChecks = (schema, suffix, ctx) => {
     return [];
   const obj = ctx.objVar;
   const d = ctx.depth;
-  const lines = [];
-  const patternsRecord = "patternProperties" in schema && typeof schema.patternProperties === "object" && schema.patternProperties !== null ? schema.patternProperties : {};
-  const patternEntries = Object.entries(patternsRecord);
-  for (const [pattern, sub] of patternEntries) {
-    const re = regexLiteral(pattern);
-    const kv = `_pk${d}`;
-    const valueChecks = generateValueChecks(`\${${kv}}`, `${obj}[${kv}]`, `\`${ctx.pathPrefix}/\${escapePointer(${kv})}\``, sub, suffix, ctx);
+  const patternsRecord = declaresKey(schema, "patternProperties") && typeof schema.patternProperties === "object" && schema.patternProperties !== null ? schema.patternProperties : {};
+  const patterns = Object.keys(patternsRecord);
+  const kv = `_pk${d}`;
+  const valueChecksFor = (sub) => (
+    // `required` mode: the key came out of the loop over the object, so its value
+    // is there to be judged. Optional mode wrote `obj[_pk0] !== undefined &&` in
+    // front of every check, and a property whose value *is* `undefined` then
+    // satisfied all of them — `{ a: undefined }` passed a
+    // `patternProperties: { "^a": { type: "string" } }` that Ajv and the
+    // interpreter both reject.
+    generateValueChecks(`\${${kv}}`, `${obj}[${kv}]`, `\`${ctx.pathPrefix}/\${escapePointer(${kv})}\``, sub, suffix, ctx, true)
+  );
+  const body = [];
+  for (const [pattern, sub] of Object.entries(patternsRecord)) {
+    const valueChecks = valueChecksFor(sub);
     if (valueChecks.length === 0)
       continue;
-    lines.push(`  for (const ${kv} in ${obj}) {`);
-    lines.push(`    if (${re}.test(${kv})) {`);
-    lines.push(...valueChecks.map((line) => `    ${line}`));
-    lines.push(`    }`);
-    lines.push(`  }`);
+    body.push(`    if (${regexLiteral(pattern)}.test(${kv})) {`);
+    body.push(...valueChecks.map((line) => `    ${line}`));
+    body.push(`    }`);
   }
   if (hasAdditionalProperties(schema) && isSchemaObject(schema.additionalProperties)) {
-    const additional = schema.additionalProperties;
-    const kv = `_ak${d}`;
-    const valueChecks = generateValueChecks(`\${${kv}}`, `${obj}[${kv}]`, `\`${ctx.pathPrefix}/\${escapePointer(${kv})}\``, additional, suffix, ctx);
+    const valueChecks = valueChecksFor(schema.additionalProperties);
     if (valueChecks.length > 0) {
       const known = Object.keys(hasProperties(schema) ? schema.properties : {});
-      lines.push(`  for (const ${kv} in ${obj}) {`);
-      if (known.length > 0)
-        lines.push(`    if (${JSON.stringify(known)}.includes(${kv})) continue`);
-      for (const pattern of Object.keys(patternsRecord)) {
-        lines.push(`    if (${regexLiteral(pattern)}.test(${kv})) continue`);
+      if (known.length > 0) {
+        const check = unknownKeyCheck(known, `_knownKeys${ctx.hoisted.length}`);
+        const knownTest = check.isKnown(kv);
+        for (const declaration of check.declarations) {
+          ctx.hoisted.push({ declaration, reference: knownTest });
+        }
+        body.push(`    if (${knownTest}) continue`);
       }
-      lines.push(...valueChecks.map((line) => `    ${line}`));
-      lines.push(`  }`);
+      for (const pattern of patterns) {
+        body.push(`    if (${regexLiteral(pattern)}.test(${kv})) continue`);
+      }
+      body.push(...valueChecks.map((line) => `  ${line}`));
     }
   }
-  return lines;
+  if (body.length === 0)
+    return [];
+  return [`  for (const ${kv} in ${obj}) {`, ...body, `  }`];
 };
 const generateInlineObjectChecks = (key, propSchema, raw, suffix, ctx) => {
   if (!isSchemaObject(propSchema))
@@ -624,7 +679,8 @@ const generateInlineObjectChecks = (key, propSchema, raw, suffix, ctx) => {
     pathPrefix: key === "" ? ctx.pathPrefix : `${ctx.pathPrefix}/${pointerSegment(key)}`,
     depth: ctx.depth + 1,
     hoisted: ctx.hoisted,
-    rootSchema: ctx.rootSchema
+    rootSchema: ctx.rootSchema,
+    sink: ctx.sink
   };
   const required = new Set(hasRequired(propSchema) ? propSchema.required : []);
   const properties = hasProperties(propSchema) ? propSchema.properties : {};
@@ -658,7 +714,8 @@ const generatePropertyNameChecks = (nameSchema, suffix, ctx) => {
     pathPrefix: `${ctx.pathPrefix}/\${escapePointer(_name)}`,
     depth: ctx.depth + 1,
     hoisted: ctx.hoisted,
-    rootSchema: ctx.rootSchema
+    rootSchema: ctx.rootSchema,
+    sink: ctx.sink
   };
   const checks = generateValueChecks("", "_name", at, nameSchema, suffix, nameCtx, true);
   if (checks.length === 0)
@@ -677,7 +734,7 @@ const generateDependentRequiredChecks = (schema, ctx) => {
     for (const dep of deps) {
       const msg = JSON.stringify(`must have property '${dep}' when '${trigger}' is present`);
       lines.push(`  if (${hasOwnCheck(obj, trigger)} && ${missingCheck(obj, dep)}) {`);
-      lines.push(`    errors.push({ message: ${msg}, path: ${at} })`);
+      lines.push(`    ${ctx.sink}.push({ message: ${msg}, path: ${at} })`);
       lines.push(`  }`);
     }
   }
@@ -690,7 +747,7 @@ const dependentSelfBinding = (objVar, depth) => {
 const generateDependentSchemasChecks = (schema, suffix, ctx) => {
   if (!isSchemaObject(schema))
     return [];
-  const dep = schema["dependentSchemas"];
+  const dep = readKey(schema, "dependentSchemas");
   if (typeof dep !== "object" || dep === null || Array.isArray(dep))
     return [];
   const obj = ctx.objVar;
@@ -703,7 +760,7 @@ const generateDependentSchemasChecks = (schema, suffix, ctx) => {
     if (sub === false) {
       const msg = JSON.stringify(`must NOT have property '${trigger}'`);
       lines.push(`  if (${hasOwnCheck(obj, trigger)}) {`);
-      lines.push(`    errors.push({ message: ${msg}, path: ${at} })`);
+      lines.push(`    ${ctx.sink}.push({ message: ${msg}, path: ${at} })`);
       lines.push(`  }`);
       continue;
     }
@@ -723,7 +780,7 @@ const generateDependentSchemasChecks = (schema, suffix, ctx) => {
 const generateDependenciesChecks = (schema, suffix, ctx) => {
   if (!isSchemaObject(schema))
     return [];
-  const dep = schema["dependencies"];
+  const dep = readKey(schema, "dependencies");
   if (typeof dep !== "object" || dep === null || Array.isArray(dep))
     return [];
   const obj = ctx.objVar;
@@ -737,7 +794,7 @@ const generateDependenciesChecks = (schema, suffix, ctx) => {
           continue;
         const msg = JSON.stringify(`must have property '${key}' when '${trigger}' is present`);
         lines.push(`  if (${hasOwnCheck(obj, trigger)} && ${missingCheck(obj, key)}) {`);
-        lines.push(`    errors.push({ message: ${msg}, path: ${at} })`);
+        lines.push(`    ${ctx.sink}.push({ message: ${msg}, path: ${at} })`);
         lines.push(`  }`);
       }
       continue;
@@ -747,7 +804,7 @@ const generateDependenciesChecks = (schema, suffix, ctx) => {
     if (value === false) {
       const msg = JSON.stringify(`must NOT have property '${trigger}'`);
       lines.push(`  if (${hasOwnCheck(obj, trigger)}) {`);
-      lines.push(`    errors.push({ message: ${msg}, path: ${at} })`);
+      lines.push(`    ${ctx.sink}.push({ message: ${msg}, path: ${at} })`);
       lines.push(`  }`);
       continue;
     }
@@ -778,13 +835,13 @@ const generateMinMaxPropertiesChecks = (schema, ctx) => {
   if (hasMin) {
     const msg = JSON.stringify(`must have at least ${schema.minProperties} properties`);
     lines.push(`  if (${count} < ${schema.minProperties}) {`);
-    lines.push(`    errors.push({ message: ${msg}, path: ${at} })`);
+    lines.push(`    ${ctx.sink}.push({ message: ${msg}, path: ${at} })`);
     lines.push(`  }`);
   }
   if (hasMax) {
     const msg = JSON.stringify(`must have at most ${schema.maxProperties} properties`);
     lines.push(`  if (${count} > ${schema.maxProperties}) {`);
-    lines.push(`    errors.push({ message: ${msg}, path: ${at} })`);
+    lines.push(`    ${ctx.sink}.push({ message: ${msg}, path: ${at} })`);
     lines.push(`  }`);
   }
   return lines;
@@ -792,19 +849,19 @@ const generateMinMaxPropertiesChecks = (schema, ctx) => {
 const hasObjectLevelCombinator = (schema) => {
   if (!isSchemaObject(schema))
     return false;
-  return hasAllOf(schema) || hasAnyOf(schema) || hasOneOf(schema) || "not" in schema || "if" in schema;
+  return hasAllOf(schema) || hasAnyOf(schema) || hasOneOf(schema) || declaresKey(schema, "not") || declaresKey(schema, "if");
 };
 const carriesUnevaluated = (schema) => {
   if (!isSchemaObject(schema))
     return false;
   const s = schema;
-  return "unevaluatedProperties" in s && s["unevaluatedProperties"] !== true || "unevaluatedItems" in s && s["unevaluatedItems"] !== true;
+  return declaresKey(s, "unevaluatedProperties") && s["unevaluatedProperties"] !== true || declaresKey(s, "unevaluatedItems") && s["unevaluatedItems"] !== true;
 };
 const guardPropConditions = (key, propSchema, objAcc) => {
   if (!isSchemaObject(propSchema))
     return null;
   const raw = safeAccessor(objAcc, key);
-  if (hasRef(propSchema) || hasEnum(propSchema) || hasConst(propSchema) || hasOneOf(propSchema) || hasAnyOf(propSchema) || hasAllOf(propSchema) || "not" in propSchema || "if" in propSchema || getMjstInstanceOf(propSchema) !== void 0 || getMjstPrimitive(propSchema) !== void 0 || hasPattern(propSchema) || hasMinLength(propSchema) || hasMaxLength(propSchema) || hasMinimum(propSchema) || hasMaximum(propSchema) || hasExclusiveMinimum(propSchema) || hasExclusiveMaximum(propSchema) || hasMultipleOf(propSchema) || hasItems(propSchema) || carriesUnevaluated(propSchema)) {
+  if (hasRef(propSchema) || hasEnum(propSchema) || hasConst(propSchema) || hasOneOf(propSchema) || hasAnyOf(propSchema) || hasAllOf(propSchema) || declaresKey(propSchema, "not") || declaresKey(propSchema, "if") || getMjstInstanceOf(propSchema) !== void 0 || getMjstPrimitive(propSchema) !== void 0 || hasPattern(propSchema) || hasMinLength(propSchema) || hasMaxLength(propSchema) || hasMinimum(propSchema) || hasMaximum(propSchema) || hasExclusiveMinimum(propSchema) || hasExclusiveMaximum(propSchema) || hasMultipleOf(propSchema) || hasItems(propSchema) || carriesUnevaluated(propSchema)) {
     return null;
   }
   if (!hasType(propSchema))
@@ -844,11 +901,11 @@ const arrayRejectedByRequiredProp = (keys, required, properties) => {
 const guardObjectConditions = (schema, raw, objAcc) => {
   if (!isObjectSchema(schema))
     return null;
-  if (hasDependentRequired(schema) || hasPropertyNames(schema) || "dependentSchemas" in schema)
+  if (hasDependentRequired(schema) || hasPropertyNames(schema) || declaresKey(schema, "dependentSchemas"))
     return null;
-  if (hasMinProperties(schema) || hasMaxProperties(schema) || "dependencies" in schema)
+  if (hasMinProperties(schema) || hasMaxProperties(schema) || declaresKey(schema, "dependencies"))
     return null;
-  if (isSchemaObject(schema) && "patternProperties" in schema)
+  if (isSchemaObject(schema) && declaresKey(schema, "patternProperties"))
     return null;
   if (hasObjectLevelCombinator(schema))
     return null;
@@ -909,10 +966,11 @@ const generateObjectValidator = (schema, typeName, suffix, rootSchema) => {
   }
   const objectCombinators = generateCombinatorChecks("", "_root", "`${_path}`", schema, suffix, ctx);
   if (objectCombinators.length > 0) {
-    propertyLines.push(`  const _root: unknown = input`);
+    if (readsBinding("_root", objectCombinators.join("\n")))
+      propertyLines.push(`  const _root: unknown = input`);
     propertyLines.push(...objectCombinators);
   }
-  const body = (propertyLines.length > 0 ? "\n" + propertyLines.join("\n") + "\n" : "").replaceAll("errors.push(", "(errors ??= []).push(");
+  const body = propertyLines.length > 0 ? "\n" + propertyLines.join("\n") + "\n" : "";
   const guard = guardObjectConditions(schema, "input", "obj");
   const objBinding = readsObjBinding(body) ? [`  const obj = input as Record<string, unknown>`] : [];
   const collectBody = (name, exported) => [
@@ -971,10 +1029,10 @@ const booleanLeafExpr = (schema, acc, narrowable = true) => {
   if (!isSchemaObject(schema))
     return null;
   const typed = (type) => narrowable ? acc : `(${acc} as ${type})`;
-  if (hasRef(schema) || hasConst(schema) || hasOneOf(schema) || "anyOf" in schema || "allOf" in schema || "not" in schema || "if" in schema || "contains" in schema || "prefixItems" in schema || // A draft-07 tuple: the fixed positions live in an *array* `items` and the
+  if (hasRef(schema) || hasConst(schema) || hasOneOf(schema) || declaresKey(schema, "anyOf") || declaresKey(schema, "allOf") || declaresKey(schema, "not") || declaresKey(schema, "if") || declaresKey(schema, "contains") || declaresKey(schema, "prefixItems") || // A draft-07 tuple: the fixed positions live in an *array* `items` and the
   // tail in `additionalItems`. Neither is expressible flat, and reading past
   // them let the guard accept tuples `validateX` rejects.
-  Array.isArray(schema["items"]) || "additionalItems" in schema || carriesUnevaluated(schema) || getMjstInstanceOf(schema) !== void 0 || getMjstPrimitive(schema) !== void 0) {
+  Array.isArray(readKey(schema, "items")) || declaresKey(schema, "additionalItems") || carriesUnevaluated(schema) || getMjstInstanceOf(schema) !== void 0 || getMjstPrimitive(schema) !== void 0) {
     return null;
   }
   if (!hasType(schema)) {
@@ -1045,10 +1103,10 @@ const booleanArrayExpr = (schema, acc, narrowable = true) => {
   if (hasMaxItems(schema))
     parts.push(`${arr}.length <= ${schema.maxItems}`);
   if (hasUniqueItems(schema) && schema.uniqueItems === true) {
-    parts.push(arrayItemsAreScalarOnly(schema) ? `new Set((${acc} as unknown[]).map((_u) => JSON.stringify(_u))).size === ${arr}.length` : `allUnique(${acc} as unknown[])`);
+    parts.push(arrayItemsAreScalarOnly(schema) ? `new Set(${acc} as unknown[]).size === ${arr}.length` : `allUnique(${acc} as unknown[])`);
   }
   const base = parts.join(" && ");
-  if (schema["items"] === false)
+  if (readKey(schema, "items") === false)
     return `${base} && ${arr}.length === 0`;
   if (!hasItems(schema))
     return base;
@@ -1069,11 +1127,11 @@ const booleanObjectParts = (schema, raw, objAcc, narrowable = true) => {
     return null;
   if (getMjstInstanceOf(schema) !== void 0 || getMjstPrimitive(schema) !== void 0)
     return null;
-  if (hasDependentRequired(schema) || hasPropertyNames(schema) || "dependentSchemas" in schema)
+  if (hasDependentRequired(schema) || hasPropertyNames(schema) || declaresKey(schema, "dependentSchemas"))
     return null;
-  if (hasMinProperties(schema) || hasMaxProperties(schema) || "dependencies" in schema)
+  if (hasMinProperties(schema) || hasMaxProperties(schema) || declaresKey(schema, "dependencies"))
     return null;
-  if (isSchemaObject(schema) && "patternProperties" in schema)
+  if (isSchemaObject(schema) && declaresKey(schema, "patternProperties"))
     return null;
   if (hasObjectLevelCombinator(schema))
     return null;
@@ -1125,16 +1183,16 @@ const typeDescribesEveryAcceptedValue = (schema) => {
   if (!isSchemaObject(schema))
     return true;
   const s = schema;
-  if ("type" in s || "enum" in s || "const" in s || "$ref" in s)
+  if (declaresKey(s, "type") || declaresKey(s, "enum") || declaresKey(s, "const") || declaresKey(s, "$ref"))
     return true;
   for (const keyword of ["allOf", "anyOf", "oneOf"]) {
-    const branches = s[keyword];
+    const branches = readKey(s, keyword);
     if (!Array.isArray(branches))
       continue;
     if (!branches.every((branch) => typeDescribesEveryAcceptedValue(branch)))
       return false;
   }
-  return !IMPLICIT_OBJECT_KEYWORDS.some((keyword) => keyword in s);
+  return !IMPLICIT_OBJECT_KEYWORDS.some((keyword) => declaresKey(s, keyword));
 };
 const generateBooleanGuard = (schema, typeName, _suffix = "") => {
   const name = guardName(typeName);
@@ -1237,7 +1295,7 @@ const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
       `}`
     ].join("\n");
   }
-  if (hasAllOf(schema) || hasAnyOf(schema) || hasOneOf(schema) || "not" in schema || "if" in schema) {
+  if (hasAllOf(schema) || hasAnyOf(schema) || hasOneOf(schema) || declaresKey(schema, "not") || declaresKey(schema, "if")) {
     const ctx = createRootContext(rootSchema);
     const checks = [];
     const rootPath = "`${_path}`";
@@ -1247,7 +1305,7 @@ const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
       if (allWrong) {
         const label = rootTypeArray2.map((t) => typeofString(t)).join(" or ");
         checks.push(`  if (${allWrong}) {`);
-        checks.push(`    errors.push({ message: ${JSON.stringify(`must be ${label}`)}, path: ${rootPath} })`);
+        checks.push(`    ${ctx.sink}.push({ message: ${JSON.stringify(`must be ${label}`)}, path: ${rootPath} })`);
         checks.push(`  }`);
       }
     } else if (hasType(schema)) {
@@ -1255,13 +1313,13 @@ const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
       const wrongType = wrongTypeCondition("input", t);
       if (wrongType) {
         checks.push(`  if (${wrongType}) {`);
-        checks.push(`    errors.push({ message: 'must be ${typeofString(t)}', path: ${rootPath} })`);
+        checks.push(`    ${ctx.sink}.push({ message: 'must be ${typeofString(t)}', path: ${rootPath} })`);
         checks.push(`  }`);
       }
     }
     checks.push(...generateConstraintChecks("", "input", rootPath, schema, suffix, ctx));
     checks.push(...generateCombinatorChecks("", "input", rootPath, schema, suffix, ctx));
-    const body = checks.join("\n").replaceAll("errors.push(", "(errors ??= []).push(");
+    const body = checks.join("\n");
     return withHoisted(ctx.hoisted, [
       `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
       `  let errors: ValidationError[] | undefined`,
@@ -1279,7 +1337,7 @@ const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
     if (allWrong) {
       const label = rootTypeArray.map((t) => typeofString(t)).join(" or ");
       checks.push(`  if (${allWrong}) {`);
-      checks.push(`    errors.push({ message: ${JSON.stringify(`must be ${label}`)}, path: ${rootPath} })`);
+      checks.push(`    ${ctx.sink}.push({ message: ${JSON.stringify(`must be ${label}`)}, path: ${rootPath} })`);
       checks.push(`  }`);
     }
     checks.push(...generateConstraintChecks("", "input", rootPath, schema, suffix, ctx));
@@ -1290,7 +1348,7 @@ const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
         `}`
       ].join("\n");
     }
-    const body = checks.join("\n").replaceAll("errors.push(", "(errors ??= []).push(");
+    const body = checks.join("\n");
     return withHoisted(ctx.hoisted, [
       `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
       `  let errors: ValidationError[] | undefined`,
@@ -1327,9 +1385,9 @@ const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
       `  if (${wrongType}) {`,
       `    return { valid: false, errors: [{ message: 'must be ${typLabel}', path: _path }] }`,
       `  }`,
-      `  const _root: unknown = input`,
+      ...readsBinding("_root", constraintLines.join("\n")) ? [`  const _root: unknown = input`] : [],
       `  let errors: ValidationError[] | undefined`,
-      constraintLines.join("\n").replaceAll("errors.push(", "(errors ??= []).push("),
+      constraintLines.join("\n"),
       `  return errors !== undefined ? { valid: false, errors } : true`,
       `}`
     ].join("\n"));
@@ -1342,7 +1400,7 @@ const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
   return withHoisted(typelessCtx.hoisted, [
     `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
     `  let errors: ValidationError[] | undefined`,
-    typelessChecks.join("\n").replaceAll("errors.push(", "(errors ??= []).push("),
+    typelessChecks.join("\n"),
     `  return errors !== undefined ? { valid: false, errors } : true`,
     `}`
   ].join("\n"));
@@ -1350,7 +1408,7 @@ const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
 const generateGeneralRootValidator = (schema, typeName, suffix, rootSchema) => {
   const ctx = createRootContext(rootSchema);
   const checks = generateValueChecks("", "input", "`${_path}`", schema, suffix, ctx, true);
-  const body = checks.join("\n").replaceAll("errors.push(", "(errors ??= []).push(");
+  const body = checks.join("\n");
   return withHoisted(ctx.hoisted, [
     `export const ${validatorName(typeName)} = (input: unknown, _path = ''): ValidationResult => {`,
     `  let errors: ValidationError[] | undefined`,
@@ -1410,7 +1468,7 @@ const rewriteNullable = (node) => {
       defineEntry(out, key, value);
     }
   }
-  if (src["nullable"] === true)
+  if (readKey(src, "nullable") === true)
     return { anyOf: [{ type: "null" }, out] };
   return out;
 };