@amritk/validation 0.2.0

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

@@ -0,0 +1,1691 @@
+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 { boundFailExpr, boundOperator, boundPassExpr } from "@amritk/helpers/numeric-bound-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";
+import { maxLengthFailExpr, maxLengthPassExpr, minLengthFailExpr, minLengthPassExpr } from "@amritk/helpers/string-length-check";
+import { unknownKeyCheck } from "@amritk/helpers/unknown-key-check";
+import { DEFAULT_UNKNOWN_KEYS } from "@amritk/helpers/unknown-keys-strategy";
+import { assertGeneratableRefs } from "./assert-generatable-refs.js";
+import { assertUnevaluatedGeneratable, UNPROVABLE_COVERAGE_MESSAGE } from "./assert-unevaluated-generatable.js";
+import { formatCheckName, formatFamily } from "./emit-format-checks.js";
+import { declaresKeywordOutside, enforcesFormat, NO_FORMATS } from "./enforced-keywords.js";
+import { tupleShapeOf } from "./tuple-shape.js";
+import { unevaluatedItemsExpr, unevaluatedPropertiesExpr } from "./unevaluated-match.js";
+const validatorName = (typeName) => `validate${typeName}`;
+const checkerName = (typeName) => `check${typeName}`;
+const propertyRead = (objVar, key) => safeAccessor(objVar, key);
+const PROTOTYPE_MEMBERS = new Set(Object.getOwnPropertyNames(Object.prototype));
+const protoLocalName = (key, depth) => `_own${depth}_${key}`;
+const hasOwnCheck = (objVar, key) => {
+  if (PROTOTYPE_MEMBERS.has(key))
+    return `Object.hasOwn(${objVar}, ${JSON.stringify(key)})`;
+  return `${JSON.stringify(key)} in ${objVar}`;
+};
+const missingCheck = (objVar, key) => `!(${hasOwnCheck(objVar, key)})`;
+const typeofString = (type) => {
+  if (type === "integer")
+    return "number";
+  return type;
+};
+const constMismatchCondition = (accessor, value) => {
+  if (value === null || typeof value !== "object") {
+    return `${accessor} !== ${JSON.stringify(value)}`;
+  }
+  return `!valuesEqual(${accessor}, ${JSON.stringify(value)})`;
+};
+const enumMembershipExpr = (values, acc) => {
+  if (values.length === 0)
+    return "false";
+  const parts = values.map((value) => {
+    if (typeof value === "number" && Number.isNaN(value))
+      return `Number.isNaN(${acc})`;
+    if (value !== null && typeof value === "object")
+      return `valuesEqual(${acc}, ${JSON.stringify(value)})`;
+    return `${acc} === ${JSON.stringify(value)}`;
+  });
+  return `(${parts.join(" || ")})`;
+};
+const FALSE_SCHEMA_MESSAGE = "boolean schema is false";
+const SCALAR_ITEM_TYPES = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean", "null"]);
+const schemaIsScalarOnly = (schema) => {
+  if (!isSchemaObject(schema))
+    return false;
+  const t = readKey(schema, "type");
+  if (t === void 0)
+    return false;
+  const types = Array.isArray(t) ? t : [t];
+  return types.length > 0 && types.every((x) => typeof x === "string" && SCALAR_ITEM_TYPES.has(x));
+};
+const arrayItemsAreScalarOnly = (schema) => {
+  const { tuple, tail, tailIsClosed } = tupleShapeOf(schema);
+  if (tuple !== void 0) {
+    if (!tuple.every((p) => schemaIsScalarOnly(p)))
+      return false;
+    if (tailIsClosed)
+      return true;
+    return schemaIsScalarOnly(tail);
+  }
+  return schemaIsScalarOnly(tail);
+};
+const wrongTypeCondition = (accessor, type) => {
+  switch (type) {
+    case "string":
+      return `typeof ${accessor} !== 'string'`;
+    case "number":
+      return `typeof ${accessor} !== 'number'`;
+    case "integer":
+      return `typeof ${accessor} !== 'number' || !Number.isInteger(${accessor})`;
+    case "boolean":
+      return `typeof ${accessor} !== 'boolean'`;
+    case "array":
+      return `!Array.isArray(${accessor})`;
+    case "null":
+      return `${accessor} !== null`;
+    case "object":
+      return `typeof ${accessor} !== 'object' || ${accessor} === null || Array.isArray(${accessor})`;
+    default:
+      return "";
+  }
+};
+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) || !declaresKey(schema, "type") || !Array.isArray(schema.type))
+    return null;
+  return schema.type;
+};
+const ROOT_ERROR_SINK = "(errors ??= [])";
+const ACCUMULATING = { on: false, blocked: false };
+const FAIL_FAST_SINK = "\0fail-fast";
+const LITERAL_CONDITION = /^[\s()!&|]*(?:(?:true|false)[\s()!&|]*)+$/;
+const blockFailFast = (ctx) => {
+  if (ctx.sink === FAIL_FAST_SINK)
+    ctx.failFast.blocked = true;
+};
+const hoistPrefix = (ctx) => ctx.failFast.on ? "_check" : "";
+const typeTestAccessor = (raw, ctx) => ctx.sink === FAIL_FAST_SINK ? `(${raw} as unknown)` : raw;
+const emittedName = (typeName, failFast) => failFast.on ? checkerName(typeName) : validatorName(typeName);
+const errorsBinding = (failFast) => failFast.on ? [] : ["  let errors: ValidationError[] | undefined"];
+const errorsVerdict = (failFast) => failFast.on ? "  return true" : "  return errors !== undefined ? { valid: false, errors } : true";
+const returnError = (message, path, keyword, params = "{}") => `return { valid: false, errors: [{ message: ${message}, path: ${path}, keyword: ${JSON.stringify(keyword)}, params: ${params} }] }`;
+const pushError = (sink, message, path, keyword, params = "{}") => sink === FAIL_FAST_SINK ? returnError(message, path, keyword, params) : `${sink}.push({ message: ${message}, path: ${path}, keyword: ${JSON.stringify(keyword)}, params: ${params} })`;
+const MATCH_ERROR_SINK = "_m";
+const createRootContext = (rootSchema, formats = NO_FORMATS, branchErrors = false, failFast = ACCUMULATING) => ({
+  objVar: "obj",
+  pathPrefix: "${_path}",
+  depth: 0,
+  hoisted: [],
+  rootSchema,
+  sink: failFast.on ? FAIL_FAST_SINK : ROOT_ERROR_SINK,
+  formats,
+  // A fail-fast body reports one error and stops, so there is no second error for
+  // a branch explanation to sit beside. Leaving the option on would emit the
+  // `selectBranchErrors` sweep *after* the `return` that ends the function, which
+  // is unreachable code the consumer's build rejects.
+  branchErrors: branchErrors && !failFast.on,
+  failFast
+});
+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) || !declaresKey(schema, "patternProperties"))
+    return [];
+  const patterns = schema.patternProperties;
+  if (typeof patterns !== "object" || patterns === null)
+    return [];
+  return Object.keys(patterns);
+};
+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 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;
+};
+const generateStrictKeyChecks = (schema, ctx) => {
+  if (!isSchemaObject(schema))
+    return [];
+  if (!hasAdditionalProperties(schema) || schema.additionalProperties !== false)
+    return [];
+  const known = Object.keys(hasProperties(schema) ? schema.properties : {});
+  const d = ctx.depth;
+  const knownKeysName = `${hoistPrefix(ctx)}_knownKeys${ctx.hoisted.length}`;
+  const check = unknownKeyCheck(known, knownKeysName);
+  const unknownTest = check.isUnknown(`_key${d}`);
+  for (const declaration of check.declarations) {
+    ctx.hoisted.push({ declaration, reference: unknownTest });
+  }
+  const patterns = patternPropertySources(schema);
+  let patternGuard = "";
+  if (patterns.length > 0) {
+    const patternsName = `${hoistPrefix(ctx)}_patterns${ctx.hoisted.length}`;
+    const compiled = patterns.map((p) => `new RegExp(${JSON.stringify(p)}, ${JSON.stringify(regexFlagsFor(p))})`);
+    patternGuard = ` && !${patternsName}.some((re) => re.test(_key${d}))`;
+    ctx.hoisted.push({
+      declaration: `const ${patternsName} = [${compiled.join(", ")}]`,
+      reference: patternGuard
+    });
+  }
+  return [
+    `  for (const _key${d} in ${ctx.objVar}) {`,
+    `    if (${unknownTest}${patternGuard}) {`,
+    `      ${pushError(ctx.sink, "'must NOT have additional properties'", `\`${ctx.pathPrefix}/\${escapePointer(_key${d})}\``, "additionalProperties", `{ additionalProperty: _key${d} }`)}`,
+    `    }`,
+    `  }`
+  ];
+};
+const generateMissingRequiredChecks = (schema, ctx) => {
+  if (!isSchemaObject(schema) || !hasRequired(schema))
+    return [];
+  const props = hasProperties(schema) ? schema.properties : {};
+  const parentPath = ctx.depth === 0 ? "_path" : `\`${ctx.pathPrefix}\``;
+  const lines = [];
+  for (const key of schema.required) {
+    if (Object.hasOwn(props, key))
+      continue;
+    lines.push(`  if (${missingCheck(ctx.objVar, key)}) {`);
+    lines.push(`    ${pushError(ctx.sink, JSON.stringify(`must have required property '${key}'`), parentPath, "required", JSON.stringify({ missingProperty: key }))}`);
+    lines.push(`  }`);
+  }
+  return lines;
+};
+const generatePropertyChecks = (key, propSchema, isRequired, suffix, ctx) => {
+  if (propSchema === false) {
+    const path = `\`${ctx.pathPrefix}/${pointerSegment(key)}\``;
+    const parentPath = ctx.depth === 0 ? "_path" : `\`${ctx.pathPrefix}\``;
+    if (isRequired) {
+      blockFailFast(ctx);
+      return [
+        `  if (${missingCheck(ctx.objVar, key)}) {`,
+        `    ${pushError(ctx.sink, JSON.stringify(`must have required property '${key}'`), parentPath, "required", JSON.stringify({ missingProperty: key }))}`,
+        `  } else {`,
+        `    ${pushError(ctx.sink, JSON.stringify(FALSE_SCHEMA_MESSAGE), path, "false schema")}`,
+        `  }`
+      ];
+    }
+    return [
+      `  if (${hasOwnCheck(ctx.objVar, key)}) {`,
+      `    ${pushError(ctx.sink, JSON.stringify(FALSE_SCHEMA_MESSAGE), path, "false schema")}`,
+      `  }`
+    ];
+  }
+  const raw = PROTOTYPE_MEMBERS.has(key) ? protoLocalName(key, ctx.depth) : propertyRead(ctx.objVar, key);
+  const lines = [
+    ...generatePropertyCheckLines(key, propSchema, isRequired, suffix, ctx),
+    // `unevaluated*` is a sibling of everything else the property declares, and
+    // several of the branches above return early, so it is appended here rather
+    // than emitted inside them. The checks carry their own runtime type guard, so
+    // an absent optional property is inert and needs no presence gate.
+    ...generateUnevaluatedChecks(raw, `\`${ctx.pathPrefix}/${pointerSegment(key)}\``, propSchema, suffix, ctx)
+  ];
+  if (lines.length === 0 || !PROTOTYPE_MEMBERS.has(key))
+    return lines;
+  return [`  const ${protoLocalName(key, ctx.depth)} = ${propertyRead(ctx.objVar, key)}`, ...lines];
+};
+const singleIfBlock = (lines) => {
+  if (lines.length < 3)
+    return null;
+  const opener = /^ {2}if \((.*)\) \{$/.exec(lines[0]);
+  if (opener === null || lines[lines.length - 1] !== "  }")
+    return null;
+  for (let i = 1; i < lines.length - 1; i++) {
+    if (!lines[i].startsWith("    "))
+      return null;
+  }
+  return { condition: opener[1], body: lines.slice(1, -1) };
+};
+const generateKeywordChecks = (key, raw, path, schema, suffix, ctx, presence) => {
+  if (!isSchemaObject(schema))
+    return [];
+  const lines = [];
+  if (hasRef(schema)) {
+    const target = refToName(schema.$ref, suffix);
+    const delegate = ctx.sink === FAIL_FAST_SINK ? [`  const _r = ${checkerName(target)}(${raw}, ${path})`, `  if (_r !== true) return _r`] : [
+      `  const _r = ${validatorName(target)}(${raw}, ${path})`,
+      `  if (_r !== true) ${ctx.sink}.push(..._r.errors)`
+    ];
+    if (presence === "")
+      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(`    ${pushError(ctx.sink, `'must be ${instanceOf}'`, path, "type", JSON.stringify({ type: instanceOf }))}`);
+    lines.push(`  }`);
+  }
+  const primitive = getMjstPrimitive(schema);
+  if (primitive) {
+    lines.push(`  if (${presence}typeof ${raw} !== "${primitive}") {`);
+    lines.push(`    ${pushError(ctx.sink, `'must be ${primitive}'`, path, "type", JSON.stringify({ type: primitive }))}`);
+    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(`    ${pushError(ctx.sink, msg, path, "const", JSON.stringify({ allowedValue: schema.const }))}`);
+    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(`    ${pushError(ctx.sink, JSON.stringify(`must be one of: ${label}`), path, "enum", JSON.stringify({ allowedValues: schema.enum }))}`);
+    lines.push(`  }`);
+  }
+  if (instanceOf === void 0 && primitive === void 0) {
+    if (hasType(schema)) {
+      const t = schema.type;
+      const wrongType = wrongTypeCondition(typeTestAccessor(raw, ctx), t);
+      if (wrongType) {
+        lines.push(`  if (${presence === "" ? wrongType : `${presence}(${wrongType})`}) {`);
+        lines.push(`    ${pushError(ctx.sink, `'must be ${typeofString(t)}'`, path, "type", JSON.stringify({ type: t }))}`);
+        lines.push(`  }`);
+      }
+    }
+    const typeArray = getTypeArray(schema);
+    if (typeArray) {
+      const allWrong = typeArray.map((t) => wrongTypeCondition(typeTestAccessor(raw, ctx), t)).filter((c) => c !== "").map((c) => `(${c})`).join(" && ");
+      if (allWrong) {
+        const label = typeArray.map((t) => typeofString(t)).join(" or ");
+        lines.push(`  if (${presence === "" ? allWrong : `${presence}(${allWrong})`}) {`);
+        lines.push(`    ${pushError(ctx.sink, JSON.stringify(`must be ${label}`), path, "type", JSON.stringify({ type: schema.type }))}`);
+        lines.push(`  }`);
+      }
+    }
+  }
+  lines.push(...generateConstraintChecks(key, raw, path, schema, suffix, ctx));
+  const combinators = generateCombinatorChecks(key, raw, path, schema, suffix, ctx);
+  if (combinators.length > 0) {
+    if (presence === "")
+      lines.push(...combinators);
+    else
+      lines.push(`  if (${raw} !== undefined) {`, ...combinators.map((line) => `  ${line}`), `  }`);
+  }
+  return lines;
+};
+const generatePropertyCheckLines = (key, propSchema, isRequired, suffix, ctx) => {
+  const parentPath = ctx.depth === 0 ? "_path" : `\`${ctx.pathPrefix}\``;
+  const missing = [
+    `  if (${missingCheck(ctx.objVar, key)}) {`,
+    `    ${pushError(ctx.sink, JSON.stringify(`must have required property '${key}'`), parentPath, "required", JSON.stringify({ missingProperty: key }))}`
+  ];
+  if (!isSchemaObject(propSchema)) {
+    if (isRequired && propSchema === true)
+      return [...missing, `  }`];
+    return [];
+  }
+  const raw = PROTOTYPE_MEMBERS.has(key) ? protoLocalName(key, ctx.depth) : propertyRead(ctx.objVar, key);
+  const path = `\`${ctx.pathPrefix}/${pointerSegment(key)}\``;
+  if (isRequired) {
+    const valueLines = generateKeywordChecks(key, raw, path, propSchema, suffix, ctx, "");
+    if (valueLines.length === 0)
+      return [...missing, `  }`];
+    const single = singleIfBlock(valueLines);
+    if (single !== null)
+      return [...missing, `  } else if (${single.condition}) {`, ...single.body, `  }`];
+    return [...missing, `  } else {`, ...valueLines.map((line) => `  ${line}`), `  }`];
+  }
+  return generateKeywordChecks(key, raw, path, propSchema, suffix, ctx, `${raw} !== undefined && `);
+};
+const generateConstraintChecks = (key, raw, path, propSchema, suffix, ctx) => {
+  if (!isSchemaObject(propSchema))
+    return [];
+  const sp = propSchema;
+  const lines = [];
+  if (isSchemaObject(propSchema) && enforcesFormat(propSchema, ctx.formats)) {
+    const format = propSchema.format;
+    const family = formatFamily(format);
+    if (family !== void 0) {
+      lines.push(`  if (typeof ${raw} === '${family}' && !${formatCheckName(format)}(${raw})) {`);
+      lines.push(`    ${pushError(ctx.sink, JSON.stringify(`must match format "${format}"`), path, "format", JSON.stringify({ format }))}`);
+      lines.push(`  }`);
+    }
+  }
+  if (hasPattern(propSchema) || hasMinLength(propSchema) || hasMaxLength(propSchema)) {
+    if (hasPattern(propSchema)) {
+      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(`    ${pushError(ctx.sink, msg, path, "pattern", JSON.stringify({ pattern: propSchema.pattern }))}`);
+      lines.push(`  }`);
+    }
+    if (hasMinLength(propSchema) && propSchema.minLength > 0) {
+      lines.push(`  if (typeof ${raw} === 'string' && ${minLengthFailExpr(raw, propSchema.minLength)}) {`);
+      lines.push(`    ${pushError(ctx.sink, `'must have at least ${propSchema.minLength} characters'`, path, "minLength", JSON.stringify({ limit: propSchema.minLength }))}`);
+      lines.push(`  }`);
+    }
+    if (hasMaxLength(propSchema)) {
+      lines.push(`  if (typeof ${raw} === 'string' && ${maxLengthFailExpr(raw, propSchema.maxLength)}) {`);
+      lines.push(`    ${pushError(ctx.sink, `'must have at most ${propSchema.maxLength} characters'`, path, "maxLength", JSON.stringify({ limit: propSchema.maxLength }))}`);
+      lines.push(`  }`);
+    }
+  }
+  if (hasMinimum(propSchema) || hasMaximum(propSchema) || hasExclusiveMinimum(propSchema) || hasExclusiveMaximum(propSchema) || hasMultipleOf(propSchema)) {
+    if (hasMinimum(propSchema)) {
+      const strict = hasStrictExclusiveMinimum(propSchema);
+      lines.push(`  if (typeof ${raw} === 'number' && ${boundFailExpr(raw, "minimum", propSchema.minimum, strict)}) {`);
+      lines.push(`    ${pushError(ctx.sink, `'must be ${boundOperator("minimum", strict)} ${propSchema.minimum}'`, path, strict ? "exclusiveMinimum" : "minimum", JSON.stringify({ comparison: boundOperator("minimum", strict), limit: propSchema.minimum }))}`);
+      lines.push(`  }`);
+    }
+    if (hasMaximum(propSchema)) {
+      const strict = hasStrictExclusiveMaximum(propSchema);
+      lines.push(`  if (typeof ${raw} === 'number' && ${boundFailExpr(raw, "maximum", propSchema.maximum, strict)}) {`);
+      lines.push(`    ${pushError(ctx.sink, `'must be ${boundOperator("maximum", strict)} ${propSchema.maximum}'`, path, strict ? "exclusiveMaximum" : "maximum", JSON.stringify({ comparison: boundOperator("maximum", strict), limit: propSchema.maximum }))}`);
+      lines.push(`  }`);
+    }
+    if (hasExclusiveMinimum(propSchema)) {
+      lines.push(`  if (typeof ${raw} === 'number' && ${boundFailExpr(raw, "minimum", propSchema.exclusiveMinimum, true)}) {`);
+      lines.push(`    ${pushError(ctx.sink, `'must be > ${propSchema.exclusiveMinimum}'`, path, "exclusiveMinimum", JSON.stringify({ comparison: ">", limit: propSchema.exclusiveMinimum }))}`);
+      lines.push(`  }`);
+    }
+    if (hasExclusiveMaximum(propSchema)) {
+      lines.push(`  if (typeof ${raw} === 'number' && ${boundFailExpr(raw, "maximum", propSchema.exclusiveMaximum, true)}) {`);
+      lines.push(`    ${pushError(ctx.sink, `'must be < ${propSchema.exclusiveMaximum}'`, path, "exclusiveMaximum", JSON.stringify({ comparison: "<", limit: propSchema.exclusiveMaximum }))}`);
+      lines.push(`  }`);
+    }
+    if (hasMultipleOf(propSchema)) {
+      lines.push(`  if (typeof ${raw} === 'number' && ${multipleOfFailExpr(raw, propSchema.multipleOf)}) {`);
+      lines.push(`    ${pushError(ctx.sink, `'must be a multiple of ${propSchema.multipleOf}'`, path, "multipleOf", JSON.stringify({ multipleOf: propSchema.multipleOf }))}`);
+      lines.push(`  }`);
+    }
+  }
+  const { tuple, tail, tailIsClosed } = tupleShapeOf(sp);
+  if (tail !== void 0) {
+    const itemSchema = tail;
+    const firstTailIndex = tuple !== void 0 ? tuple.length : 0;
+    const iv = `_i${ctx.depth}`;
+    const itemPath = `\`${path.slice(1, -1)}/\${${iv}}\``;
+    if (hasRef(itemSchema) && !declaresKeywordOutside(itemSchema, ["$ref"])) {
+      const failFast = ctx.sink === FAIL_FAST_SINK;
+      const target = refToName(itemSchema.$ref, suffix);
+      lines.push(`  if (Array.isArray(${raw})) {`);
+      lines.push(`    for (let ${iv} = ${firstTailIndex}; ${iv} < ${raw}.length; ${iv}++) {`);
+      lines.push(`      const _ir = ${failFast ? checkerName(target) : validatorName(target)}(${raw}[${iv}], ${itemPath})`);
+      lines.push(`      if (_ir !== true) ${failFast ? "return _ir" : `${ctx.sink}.push(..._ir.errors)`}`);
+      lines.push(`    }`);
+      lines.push(`  }`);
+    } else if (isSchemaObject(itemSchema)) {
+      const itemVar = `_item${ctx.depth}`;
+      const detail = generateValueChecks("", itemVar, itemPath, itemSchema, suffix, ctx, true);
+      if (detail.length > 0) {
+        lines.push(`  if (Array.isArray(${raw})) {`);
+        lines.push(`    for (let ${iv} = ${firstTailIndex}; ${iv} < ${raw}.length; ${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 || 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(`    ${pushError(ctx.sink, `'must NOT have more than 0 items'`, path, "items", "{ limit: 0 }")}`);
+      lines.push(`  }`);
+    }
+    if (hasMinItems(propSchema)) {
+      lines.push(`  if (Array.isArray(${raw}) && ${raw}.length < ${propSchema.minItems}) {`);
+      lines.push(`    ${pushError(ctx.sink, `'must have at least ${propSchema.minItems} items'`, path, "minItems", JSON.stringify({ limit: propSchema.minItems }))}`);
+      lines.push(`  }`);
+    }
+    if (hasMaxItems(propSchema)) {
+      lines.push(`  if (Array.isArray(${raw}) && ${raw}.length > ${propSchema.maxItems}) {`);
+      lines.push(`    ${pushError(ctx.sink, `'must have at most ${propSchema.maxItems} items'`, path, "maxItems", JSON.stringify({ limit: propSchema.maxItems }))}`);
+      lines.push(`  }`);
+    }
+    if (hasUniqueItems(propSchema) && propSchema.uniqueItems === true) {
+      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(`    ${pushError(ctx.sink, `'must NOT have duplicate items'`, path, "uniqueItems")}`);
+      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 = pushError(ctx.sink, `'array does not contain the required matching items'`, path, "contains");
+        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})) {`);
+      for (let i = 0; i < tuple.length; i++) {
+        const itemChecks = generateValueChecks("", `${raw}[${i}]`, `\`${path.slice(1, -1)}/${i}\``, tuple[i], suffix, ctx, true);
+        if (itemChecks.length > 0) {
+          lines.push(`    if (${raw}.length > ${i}) {`);
+          lines.push(...itemChecks.map((l) => `    ${l}`));
+          lines.push(`    }`);
+        }
+      }
+      if (tailIsClosed) {
+        lines.push(`    if (${raw}.length > ${tuple.length}) {`);
+        lines.push(`      ${pushError(ctx.sink, `'must NOT have more than ${tuple.length} items'`, path, "items", JSON.stringify({ limit: tuple.length }))}`);
+        lines.push(`    }`);
+      }
+      lines.push(`  }`);
+    }
+  }
+  lines.push(...generateInlineObjectChecks(key, propSchema, raw, suffix, ctx));
+  return lines;
+};
+const generateValueChecks = (key, raw, path, propSchema, suffix, ctx, required = false) => [
+  ...generateValueCheckLines(key, raw, path, propSchema, suffix, ctx, required),
+  // Appended rather than folded into the checks above because several of those
+  // branches (`$ref`, `const`, `enum`, x-mjst) return early: `unevaluated*` is a
+  // sibling of whatever else the node declares, and dropping it would leave the
+  // validator accepting documents the interpreter rejects.
+  ...generateUnevaluatedChecks(raw, path, propSchema, suffix, ctx)
+];
+const generateValueCheckLines = (_key, raw, path, propSchema, suffix, ctx, required = false) => {
+  const lines = [];
+  if (propSchema === false) {
+    const report = pushError(ctx.sink, JSON.stringify(FALSE_SCHEMA_MESSAGE), path, "false schema");
+    if (required)
+      blockFailFast(ctx);
+    if (required)
+      return [`  {`, `    ${report}`, `  }`];
+    return [`  if (${raw} !== undefined) {`, `    ${report}`, `  }`];
+  }
+  if (!isSchemaObject(propSchema))
+    return [];
+  const presence = required ? "" : `${raw} !== undefined && `;
+  const valueCtx = {
+    branchErrors: ctx.branchErrors,
+    failFast: ctx.failFast,
+    objVar: ctx.objVar,
+    pathPrefix: path.slice(1, -1),
+    depth: ctx.depth + 1,
+    hoisted: ctx.hoisted,
+    rootSchema: ctx.rootSchema,
+    sink: ctx.sink,
+    formats: ctx.formats
+  };
+  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, required = false, branch) => {
+  if (sub === true)
+    return "true";
+  if (sub === false)
+    return "false";
+  if (!isSchemaObject(sub))
+    return "true";
+  const value = NARROWABLE_REFERENCE.test(raw) ? raw : `_mv${ctx.depth}`;
+  const valuePath = branch === void 0 ? "`${_path}`" : branch.path;
+  const checks = generateValueChecks("", value, valuePath, sub, suffix, { ...ctx, sink: MATCH_ERROR_SINK }, required);
+  if (checks.length === 0)
+    return "true";
+  const body = checks.join("\n");
+  const binding = value === raw ? "" : `const ${value}: unknown = ${raw}
+`;
+  const collect = branch === void 0 ? "" : `
+    if (_m.length !== 0) (${branch.buffer} ??= []).push(_m)`;
+  return `((): boolean => { const _m: ValidationError[] = []
+${binding}${body}${collect}
+    return _m.length === 0 })()`;
+};
+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 (!declaresKey(s, "unevaluatedProperties") && !declaresKey(s, "unevaluatedItems"))
+    return [];
+  const match = unevaluatedMatcher(suffix, ctx);
+  const lines = [];
+  const properties = unevaluatedPropertiesExpr(raw, schema, ctx.rootSchema, ctx.depth, match);
+  if (properties === null)
+    throw new Error(UNPROVABLE_COVERAGE_MESSAGE("unevaluatedProperties"));
+  if (properties !== void 0) {
+    if (LITERAL_CONDITION.test(`!(${properties.expr})`))
+      blockFailFast(ctx);
+    lines.push(`  if (typeof ${raw} === 'object' && ${raw} !== null && !Array.isArray(${raw})) {`);
+    for (const statement of properties.setup)
+      lines.push(`    ${statement}`);
+    lines.push(`    if (!(${properties.expr})) {`);
+    lines.push(`      ${pushError(ctx.sink, `'must NOT have unevaluated properties'`, path, "unevaluatedProperties")}`);
+    lines.push(`    }`);
+    lines.push(`  }`);
+  }
+  const items = unevaluatedItemsExpr(raw, schema, ctx.rootSchema, ctx.depth, match);
+  if (items === null)
+    throw new Error(UNPROVABLE_COVERAGE_MESSAGE("unevaluatedItems"));
+  if (items !== void 0) {
+    if (LITERAL_CONDITION.test(`!(${items.expr})`))
+      blockFailFast(ctx);
+    lines.push(`  if (Array.isArray(${raw})) {`);
+    for (const statement of items.setup)
+      lines.push(`    ${statement}`);
+    lines.push(`    if (!(${items.expr})) {`);
+    lines.push(`      ${pushError(ctx.sink, `'must NOT have unevaluated items'`, path, "unevaluatedItems")}`);
+    lines.push(`    }`);
+    lines.push(`  }`);
+  }
+  return lines;
+};
+const BRANCH_BUFFER = "_br";
+const selectBranchErrorsLine = (path, ctx) => `for (const _e of selectBranchErrors(${BRANCH_BUFFER} ?? [], ${path})) ${ctx.sink}.push(_e)`;
+const branchBufferBlock = (guard, message, keyword, path, ctx) => [
+  `  {`,
+  `    let ${BRANCH_BUFFER}: ValidationError[][] | null = null`,
+  `    if (${guard}) {`,
+  `      ${pushError(ctx.sink, message, path, keyword)}`,
+  `      ${selectBranchErrorsLine(path, ctx)}`,
+  `    }`,
+  `  }`
+];
+const generateCombinatorChecks = (key, raw, path, schema, suffix, ctx) => {
+  if (!isSchemaObject(schema))
+    return [];
+  const lines = [];
+  if (hasAllOf(schema)) {
+    for (const branch of schema.allOf)
+      lines.push(...generateValueChecks(key, raw, path, branch, suffix, ctx, true));
+  }
+  if (hasAnyOf(schema) && schema.anyOf.length > 0) {
+    const collector = ctx.branchErrors ? { buffer: BRANCH_BUFFER, path } : void 0;
+    const conds = schema.anyOf.map((b) => generateMatchesExpr(raw, b, suffix, ctx, true, collector));
+    if (!conds.includes("true")) {
+      if (ctx.branchErrors) {
+        lines.push(...branchBufferBlock(`!(${conds.join(" || ")})`, `'must match a schema in anyOf'`, "anyOf", path, ctx));
+      } else {
+        const condition = `!(${conds.join(" || ")})`;
+        if (LITERAL_CONDITION.test(condition))
+          blockFailFast(ctx);
+        lines.push(`  if (${condition}) {`);
+        lines.push(`    ${pushError(ctx.sink, `'must match a schema in anyOf'`, path, "anyOf")}`);
+        lines.push(`  }`);
+      }
+    }
+  }
+  if (hasOneOf(schema) && schema.oneOf.length > 0) {
+    const collector = ctx.branchErrors ? { buffer: BRANCH_BUFFER, path } : void 0;
+    const conds = schema.oneOf.map((b) => `(${generateMatchesExpr(raw, b, suffix, ctx, true, collector)} ? 1 : 0)`);
+    const message = `'must match exactly one schema in oneOf'`;
+    if (!ctx.branchErrors) {
+      lines.push(`  if ((${conds.join(" + ")}) !== 1) {`);
+      lines.push(`    ${pushError(ctx.sink, message, path, "oneOf")}`);
+      lines.push(`  }`);
+    } else {
+      lines.push(`  {`);
+      lines.push(`    let ${BRANCH_BUFFER}: ValidationError[][] | null = null`);
+      lines.push(`    const _n = ${conds.join(" + ")}`);
+      lines.push(`    if (_n === 0) {`);
+      lines.push(`      ${pushError(ctx.sink, message, path, "oneOf")}`);
+      lines.push(`      ${selectBranchErrorsLine(path, ctx)}`);
+      lines.push(`    } else if (_n !== 1) {`);
+      lines.push(`      ${pushError(ctx.sink, message, path, "oneOf")}`);
+      lines.push(`    }`);
+      lines.push(`  }`);
+    }
+  }
+  const not = readKey(schema, "not");
+  if (not !== void 0 && (isSchemaObject(not) || typeof not === "boolean")) {
+    const cond = generateMatchesExpr(raw, not, suffix, ctx, true);
+    if (cond !== "false") {
+      if (LITERAL_CONDITION.test(cond))
+        blockFailFast(ctx);
+      lines.push(`  if (${cond}) {`);
+      lines.push(`    ${pushError(ctx.sink, `'must NOT match the schema in not'`, path, "not")}`);
+      lines.push(`  }`);
+    }
+  }
+  const ifSchema = readKey(schema, "if");
+  if (ifSchema !== void 0 && (isSchemaObject(ifSchema) || typeof ifSchema === "boolean")) {
+    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, true);
+      if (cond === "true") {
+        lines.push(...thenLines);
+      } else if (cond === "false") {
+        lines.push(...elseLines);
+      } else {
+        lines.push(`  if (${cond}) {`);
+        lines.push(...thenLines);
+        lines.push(`  } else {`);
+        lines.push(...elseLines);
+        lines.push(`  }`);
+      }
+    }
+  }
+  return lines;
+};
+const generatePatternAndAdditionalChecks = (schema, suffix, ctx) => {
+  if (!isSchemaObject(schema))
+    return [];
+  const obj = ctx.objVar;
+  const d = ctx.depth;
+  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;
+    body.push(`    if (${regexLiteral(pattern)}.test(${kv})) {`);
+    body.push(...valueChecks.map((line) => `    ${line}`));
+    body.push(`    }`);
+  }
+  if (hasAdditionalProperties(schema) && isSchemaObject(schema.additionalProperties)) {
+    const valueChecks = valueChecksFor(schema.additionalProperties);
+    if (valueChecks.length > 0) {
+      const known = Object.keys(hasProperties(schema) ? schema.properties : {});
+      if (known.length > 0) {
+        const check = unknownKeyCheck(known, `${hoistPrefix(ctx)}_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`);
+      }
+      for (const pattern of patterns) {
+        body.push(`    if (${regexLiteral(pattern)}.test(${kv})) continue`);
+      }
+      body.push(...valueChecks.map((line) => `  ${line}`));
+    }
+  }
+  if (body.length === 0)
+    return [];
+  return [`  for (const ${kv} in ${obj}) {`, ...body, `  }`];
+};
+const generateInlineObjectChecks = (key, propSchema, raw, suffix, ctx) => {
+  if (!isSchemaObject(propSchema))
+    return [];
+  const child = {
+    branchErrors: ctx.branchErrors,
+    failFast: ctx.failFast,
+    objVar: `_obj${ctx.depth + 1}`,
+    // When `key` is empty the value is located AT `ctx.pathPrefix` already (e.g. an
+    // inline object reached through a combinator branch or a dynamic-key value), so
+    // appending `/${key}` would emit a spurious `//` or trailing `/` in error paths.
+    pathPrefix: key === "" ? ctx.pathPrefix : `${ctx.pathPrefix}/${pointerSegment(key)}`,
+    depth: ctx.depth + 1,
+    hoisted: ctx.hoisted,
+    rootSchema: ctx.rootSchema,
+    sink: ctx.sink,
+    formats: ctx.formats
+  };
+  const required = new Set(hasRequired(propSchema) ? propSchema.required : []);
+  const properties = hasProperties(propSchema) ? propSchema.properties : {};
+  const innerLines = [];
+  for (const [childKey, childSchema] of Object.entries(properties)) {
+    innerLines.push(...generatePropertyChecks(childKey, childSchema, required.has(childKey), suffix, child));
+  }
+  innerLines.push(...generateMissingRequiredChecks(propSchema, child));
+  innerLines.push(...generatePatternAndAdditionalChecks(propSchema, suffix, child));
+  innerLines.push(...generateStrictKeyChecks(propSchema, child));
+  innerLines.push(...generateDependentRequiredChecks(propSchema, child));
+  innerLines.push(...generateDependentSchemasChecks(propSchema, suffix, child));
+  innerLines.push(...generateDependenciesChecks(propSchema, suffix, child));
+  innerLines.push(...generateMinMaxPropertiesChecks(propSchema, child));
+  if (hasPropertyNames(propSchema)) {
+    innerLines.push(...generatePropertyNameChecks(propSchema.propertyNames, suffix, child));
+  }
+  if (innerLines.length === 0)
+    return [];
+  return [
+    `  if (typeof ${raw} === 'object' && ${raw} !== null && !Array.isArray(${raw})) {`,
+    `    const ${child.objVar} = ${raw} as Record<string, unknown>`,
+    ...innerLines.map((line) => `  ${line}`),
+    `  }`
+  ];
+};
+const generatePropertyNameChecks = (nameSchema, suffix, ctx) => {
+  const at = `\`${ctx.pathPrefix}/\${escapePointer(_name)}\``;
+  const nameCtx = {
+    branchErrors: ctx.branchErrors,
+    failFast: ctx.failFast,
+    objVar: ctx.objVar,
+    pathPrefix: `${ctx.pathPrefix}/\${escapePointer(_name)}`,
+    depth: ctx.depth + 1,
+    hoisted: ctx.hoisted,
+    rootSchema: ctx.rootSchema,
+    sink: ctx.sink,
+    formats: ctx.formats
+  };
+  const checks = generateValueChecks("", "_name", at, nameSchema, suffix, nameCtx, true);
+  if (checks.length === 0)
+    return [];
+  return [`  for (const _name of Object.keys(${ctx.objVar})) {`, ...checks.map((line) => `  ${line}`), `  }`];
+};
+const generateDependentRequiredChecks = (schema, ctx) => {
+  if (!isSchemaObject(schema) || !hasDependentRequired(schema))
+    return [];
+  const obj = ctx.objVar;
+  const at = ctx.depth === 0 ? "_path" : `\`${ctx.pathPrefix}\``;
+  const lines = [];
+  for (const [trigger, deps] of Object.entries(schema.dependentRequired)) {
+    if (!Array.isArray(deps))
+      continue;
+    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(`    ${pushError(ctx.sink, msg, at, "dependentRequired", JSON.stringify({ missingProperty: dep, property: trigger, depsCount: 1 }))}`);
+      lines.push(`  }`);
+    }
+  }
+  return lines;
+};
+const dependentSelfBinding = (objVar, depth) => {
+  const name = `_dep${depth}`;
+  return { name, declaration: `  const ${name}: unknown = ${objVar}` };
+};
+const generateDependentSchemasChecks = (schema, suffix, ctx) => {
+  if (!isSchemaObject(schema))
+    return [];
+  const dep = readKey(schema, "dependentSchemas");
+  if (typeof dep !== "object" || dep === null || Array.isArray(dep))
+    return [];
+  const obj = ctx.objVar;
+  const at = ctx.depth === 0 ? "_path" : `\`${ctx.pathPrefix}\``;
+  const objPath = `\`${ctx.pathPrefix}\``;
+  const lines = [];
+  for (const [trigger, sub] of Object.entries(dep)) {
+    if (sub === true)
+      continue;
+    if (sub === false) {
+      const msg = JSON.stringify(`must NOT have property '${trigger}'`);
+      lines.push(`  if (${hasOwnCheck(obj, trigger)}) {`);
+      lines.push(`    ${pushError(ctx.sink, msg, at, "dependentSchemas", JSON.stringify({ property: trigger }))}`);
+      lines.push(`  }`);
+      continue;
+    }
+    if (!isSchemaObject(sub))
+      continue;
+    const self = dependentSelfBinding(obj, ctx.depth);
+    const checks = generateValueChecks("", self.name, objPath, sub, suffix, ctx);
+    if (checks.length === 0)
+      continue;
+    lines.push(`  if (${hasOwnCheck(obj, trigger)}) {`);
+    lines.push(`  ${self.declaration}`);
+    lines.push(...checks.map((line) => `  ${line}`));
+    lines.push(`  }`);
+  }
+  return lines;
+};
+const generateDependenciesChecks = (schema, suffix, ctx) => {
+  if (!isSchemaObject(schema))
+    return [];
+  const dep = readKey(schema, "dependencies");
+  if (typeof dep !== "object" || dep === null || Array.isArray(dep))
+    return [];
+  const obj = ctx.objVar;
+  const at = ctx.depth === 0 ? "_path" : `\`${ctx.pathPrefix}\``;
+  const objPath = `\`${ctx.pathPrefix}\``;
+  const lines = [];
+  for (const [trigger, value] of Object.entries(dep)) {
+    if (Array.isArray(value)) {
+      for (const key of value) {
+        if (typeof key !== "string")
+          continue;
+        const msg = JSON.stringify(`must have property '${key}' when '${trigger}' is present`);
+        lines.push(`  if (${hasOwnCheck(obj, trigger)} && ${missingCheck(obj, key)}) {`);
+        lines.push(`    ${pushError(ctx.sink, msg, at, "dependencies", JSON.stringify({ missingProperty: key, property: trigger, depsCount: 1 }))}`);
+        lines.push(`  }`);
+      }
+      continue;
+    }
+    if (value === true)
+      continue;
+    if (value === false) {
+      const msg = JSON.stringify(`must NOT have property '${trigger}'`);
+      lines.push(`  if (${hasOwnCheck(obj, trigger)}) {`);
+      lines.push(`    ${pushError(ctx.sink, msg, at, "dependencies", JSON.stringify({ property: trigger }))}`);
+      lines.push(`  }`);
+      continue;
+    }
+    if (!isSchemaObject(value))
+      continue;
+    const self = dependentSelfBinding(obj, ctx.depth);
+    const checks = generateValueChecks("", self.name, objPath, value, suffix, ctx);
+    if (checks.length === 0)
+      continue;
+    lines.push(`  if (${hasOwnCheck(obj, trigger)}) {`);
+    lines.push(`  ${self.declaration}`);
+    lines.push(...checks.map((line) => `  ${line}`));
+    lines.push(`  }`);
+  }
+  return lines;
+};
+const generateMinMaxPropertiesChecks = (schema, ctx) => {
+  if (!isSchemaObject(schema))
+    return [];
+  const hasMin = hasMinProperties(schema);
+  const hasMax = hasMaxProperties(schema);
+  if (!hasMin && !hasMax)
+    return [];
+  const obj = ctx.objVar;
+  const at = ctx.depth === 0 ? "_path" : `\`${ctx.pathPrefix}\``;
+  const count = `_pc${ctx.depth}`;
+  const lines = [`  const ${count} = Object.keys(${obj}).length`];
+  if (hasMin) {
+    const msg = JSON.stringify(`must have at least ${schema.minProperties} properties`);
+    lines.push(`  if (${count} < ${schema.minProperties}) {`);
+    lines.push(`    ${pushError(ctx.sink, msg, at, "minProperties", JSON.stringify({ limit: schema.minProperties }))}`);
+    lines.push(`  }`);
+  }
+  if (hasMax) {
+    const msg = JSON.stringify(`must have at most ${schema.maxProperties} properties`);
+    lines.push(`  if (${count} > ${schema.maxProperties}) {`);
+    lines.push(`    ${pushError(ctx.sink, msg, at, "maxProperties", JSON.stringify({ limit: schema.maxProperties }))}`);
+    lines.push(`  }`);
+  }
+  return lines;
+};
+const hasObjectLevelCombinator = (schema) => {
+  if (!isSchemaObject(schema))
+    return false;
+  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 declaresKey(s, "unevaluatedProperties") && s["unevaluatedProperties"] !== true || declaresKey(s, "unevaluatedItems") && s["unevaluatedItems"] !== true;
+};
+const createGuardContext = (unknownKeys, formats = NO_FORMATS) => ({ unknownKeys, formats, locals: 0, loops: 0 });
+const guardFormatPass = (schema, acc, ctx) => {
+  if (!enforcesFormat(schema, ctx.formats))
+    return null;
+  const format = schema.format;
+  return formatFamily(format) === void 0 ? null : `${formatCheckName(format)}(${acc})`;
+};
+const emptyGuardBlock = () => ({ conditions: [], nested: [], keyChecks: [] });
+const isFlatGuardBlock = (block) => block.nested.length === 0 && block.keyChecks.length === 0;
+const keySetCheckLines = (check, bail, indent, unknownKeys) => {
+  const key = `_k${check.index}`;
+  if (check.count === null) {
+    const unknown = unknownKeyCheck(check.known, "", Number.POSITIVE_INFINITY).isUnknown(key);
+    return [`${indent}for (const ${key} in ${check.obj}) if (${unknown}) ${bail}`];
+  }
+  if (unknownKeys === "count-keys") {
+    return [`${indent}if (Object.keys(${check.obj}).length !== ${check.count}) ${bail}`];
+  }
+  const count = `_c${check.index}`;
+  return [
+    `${indent}let ${count} = 0`,
+    `${indent}for (const ${key} in ${check.obj}) ${count}++`,
+    `${indent}if (${count} !== ${check.count}) ${bail}`
+  ];
+};
+const renderChainBail = (conditions, bail, indent, layout) => layout === "inline" ? [`if (!(${conditions.join(" && ")})) ${bail}`] : [`${indent}if (!(`, conditions.map((condition) => `${indent}  ${condition}`).join(" &&\n"), `${indent})) ${bail}`];
+const renderGuardBlock = (block, bail, indent, layout, unknownKeys) => {
+  const lines = [];
+  if (block.conditions.length > 0)
+    lines.push(...renderChainBail(block.conditions, bail, indent, layout));
+  for (const nested of block.nested) {
+    lines.push(`${indent}const ${nested.local} = ${nested.read} as Record<string, unknown>`);
+    if (nested.optional) {
+      lines.push(`${indent}if (${nested.local} !== undefined) {`);
+      lines.push(...renderGuardBlock(nested.block, bail, `${indent}  `, layout, unknownKeys));
+      lines.push(`${indent}}`);
+    } else {
+      lines.push(...renderGuardBlock(nested.block, bail, indent, layout, unknownKeys));
+    }
+  }
+  for (const check of block.keyChecks)
+    lines.push(...keySetCheckLines(check, bail, indent, unknownKeys));
+  return lines;
+};
+const joinInline = (lines) => {
+  const trimmed = lines.map((line) => line.trim());
+  return trimmed.reduce((text, line, i) => {
+    if (i === 0)
+      return line;
+    const previous = trimmed[i - 1];
+    return `${text}${previous.endsWith("{") || line === "}" ? " " : "; "}${line}`;
+  }, "");
+};
+const guardPropConditions = (key, propSchema, objAcc, block, ctx) => {
+  if (!isSchemaObject(propSchema))
+    return null;
+  const raw = safeAccessor(objAcc, key);
+  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))
+    return null;
+  switch (propSchema.type) {
+    case "string":
+      return [`typeof ${raw} === 'string'`];
+    case "number":
+      return [`typeof ${raw} === 'number'`];
+    case "integer":
+      return [`typeof ${raw} === 'number'`, `Number.isInteger(${raw})`];
+    case "boolean":
+      return [`typeof ${raw} === 'boolean'`];
+    case "null":
+      return [`${raw} === null`];
+    case "object": {
+      const local = `_n${ctx.locals++}`;
+      const nested = guardObjectConditions(propSchema, local, local, ctx);
+      if (nested === null)
+        return null;
+      block.nested.push({ local, read: raw, optional: false, block: nested });
+      return [];
+    }
+    // Arrays need a per-item loop the guard can't express, and any other type
+    // (null, multi-type, untyped) is left to the slow path.
+    default:
+      return null;
+  }
+};
+const ARRAY_INDEX_KEY = /^(0|[1-9]\d*)$/;
+const TYPEOF_CHECKABLE_TYPES = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean", "object"]);
+const arrayRejectedByRequiredProp = (keys, required, properties) => {
+  for (const key of keys) {
+    if (!required.has(key) || key === "length" || ARRAY_INDEX_KEY.test(key))
+      continue;
+    const propSchema = properties[key];
+    if (propSchema !== void 0 && isSchemaObject(propSchema) && hasType(propSchema) && TYPEOF_CHECKABLE_TYPES.has(propSchema.type)) {
+      return true;
+    }
+  }
+  return false;
+};
+const guardObjectConditions = (schema, raw, objAcc, ctx) => {
+  if (!isObjectSchema(schema))
+    return null;
+  if (hasDependentRequired(schema) || hasPropertyNames(schema) || declaresKey(schema, "dependentSchemas"))
+    return null;
+  if (hasMinProperties(schema) || hasMaxProperties(schema) || declaresKey(schema, "dependencies"))
+    return null;
+  if (isSchemaObject(schema) && declaresKey(schema, "patternProperties"))
+    return null;
+  if (hasObjectLevelCombinator(schema))
+    return null;
+  if (carriesUnevaluated(schema))
+    return null;
+  let strict = false;
+  if (hasAdditionalProperties(schema)) {
+    if (schema.additionalProperties === false)
+      strict = true;
+    else
+      return null;
+  }
+  const required = new Set(hasRequired(schema) ? schema.required : []);
+  const properties = hasProperties(schema) ? schema.properties : {};
+  const keys = Object.keys(properties);
+  for (const key of required) {
+    if (!Object.hasOwn(properties, key))
+      return null;
+  }
+  const arrayCheck = arrayRejectedByRequiredProp(keys, required, properties) ? "" : ` && !Array.isArray(${raw})`;
+  const block = emptyGuardBlock();
+  block.conditions.push(`typeof ${raw} === 'object' && ${raw} !== null${arrayCheck}`);
+  for (const key of keys) {
+    if (!required.has(key))
+      return null;
+    const propConditions = guardPropConditions(key, properties[key], objAcc, block, ctx);
+    if (propConditions === null)
+      return null;
+    block.conditions.push(...propConditions);
+  }
+  if (strict) {
+    if (!keys.every((key) => required.has(key)))
+      return null;
+    block.keyChecks.push({ obj: objAcc, count: keys.length, known: keys, index: ctx.loops++ });
+  }
+  return block;
+};
+const generateObjectValidator = (schema, typeName, suffix, rootSchema, unknownKeys, formats, branchErrors, failFast) => {
+  const vName = emittedName(typeName, failFast);
+  const required = new Set(hasRequired(schema) ? schema.required : []);
+  const properties = hasProperties(schema) ? schema.properties : {};
+  const ctx = createRootContext(rootSchema, formats, branchErrors, failFast);
+  const propertyLines = [];
+  for (const [key, propSchema] of Object.entries(properties)) {
+    const checks = generatePropertyChecks(key, propSchema, required.has(key), suffix, ctx);
+    if (checks.length > 0) {
+      propertyLines.push(...checks);
+    }
+  }
+  propertyLines.push(...generateMissingRequiredChecks(schema, ctx));
+  propertyLines.push(...generatePatternAndAdditionalChecks(schema, suffix, ctx));
+  propertyLines.push(...generateStrictKeyChecks(schema, ctx));
+  propertyLines.push(...generateDependentRequiredChecks(schema, ctx));
+  propertyLines.push(...generateDependentSchemasChecks(schema, suffix, ctx));
+  propertyLines.push(...generateDependenciesChecks(schema, suffix, ctx));
+  propertyLines.push(...generateMinMaxPropertiesChecks(schema, ctx));
+  if (hasPropertyNames(schema)) {
+    propertyLines.push(...generatePropertyNameChecks(schema.propertyNames, suffix, ctx));
+  }
+  const objectCombinators = generateCombinatorChecks("", "_root", "`${_path}`", schema, suffix, ctx);
+  if (objectCombinators.length > 0) {
+    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" : "";
+  const guard = guardObjectConditions(schema, "input", "obj", createGuardContext(unknownKeys, formats));
+  const objBinding = readsObjBinding(body) ? [`  const obj = input as Record<string, unknown>`] : [];
+  const collectBody = (name, exported) => [
+    `${exported ? "export " : ""}const ${name} = (input: unknown, _path = ''): ValidationResult => {`,
+    ...objBinding,
+    `  if (typeof input !== 'object' || input === null || Array.isArray(input)) {`,
+    `    ${returnError(`'must be object'`, "_path", "type", JSON.stringify({ type: "object" }))}`,
+    `  }`,
+    // The blank line separates the shape check from the `errors` declaration
+    // under it; a fail-fast body declares nothing there, and two blank lines in
+    // a row is just untidy output.
+    ...failFast.on ? [] : [""],
+    ...errorsBinding(failFast),
+    body,
+    errorsVerdict(failFast),
+    `}`
+  ].join("\n");
+  if (!guard) {
+    return withHoisted(ctx.hoisted, collectBody(vName, true));
+  }
+  const collectName = `${vName}Errors`;
+  const bail = `return ${collectName}(input, _path)`;
+  const guardLines = isFlatGuardBlock(guard) ? [
+    `  if (`,
+    guard.conditions.map((condition) => `    ${condition}`).join(" &&\n"),
+    `  ) {`,
+    `    return true`,
+    `  }`,
+    `  ${bail}`
+  ] : [...renderGuardBlock(guard, bail, "  ", "lines", unknownKeys), `  return true`];
+  return withHoisted(ctx.hoisted, [
+    collectBody(collectName, false),
+    ``,
+    `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+    ...readsObjBinding(guardLines.join("\n")) ? [`  const obj = input as Record<string, unknown>`] : [],
+    ...guardLines,
+    `}`
+  ].join("\n"));
+};
+const guardName = (typeName) => `is${typeName}`;
+const valueCanHaveType = (value, type) => {
+  switch (type) {
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number";
+    case "integer":
+      return typeof value === "number" && Number.isInteger(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "null":
+      return value === null;
+    case "array":
+      return Array.isArray(value);
+    case "object":
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    default:
+      return true;
+  }
+};
+const flatLeafBails = (schema) => 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(readKey(schema, "items")) || declaresKey(schema, "additionalItems") || carriesUnevaluated(schema) || getMjstInstanceOf(schema) !== void 0 || getMjstPrimitive(schema) !== void 0;
+const isNestedObjectLeaf = (schema) => isSchemaObject(schema) && !flatLeafBails(schema) && hasType(schema) && schema.type === "object";
+const booleanLeafExpr = (schema, acc, ctx) => {
+  if (!isSchemaObject(schema))
+    return null;
+  if (flatLeafBails(schema))
+    return null;
+  if (!hasType(schema)) {
+    if (!hasEnum(schema))
+      return null;
+    if (declaresKeywordOutside(schema, ["enum"], ctx.formats))
+      return null;
+    return enumMembershipExpr(schema.enum, acc);
+  }
+  const t = schema.type;
+  const membership = hasEnum(schema) ? enumMembershipExpr(schema.enum.filter((member) => valueCanHaveType(member, t)), acc) : null;
+  const withMembership = (expr) => expr === null || membership === null ? expr : `${expr} && ${membership}`;
+  switch (t) {
+    // Each constraint is the exact negation of the validator's error condition,
+    // so edge values — `NaN` above all, which compares `false` against every
+    // operator — get the identical verdict on both paths. The numeric bounds are
+    // written as the pass condition (`x >= min`) because the validator's error
+    // condition is its negation; the length checks come from the same
+    // `string-length-check` emitter the validator uses, for the same reason.
+    // A constrained check reads `acc` again after the `typeof`, and TypeScript
+    // narrows it there because every `acc` is a *reference* — `obj.a`, `_n0.b`,
+    // `_it` — never a cast expression: nested members read through a hoisted
+    // local (see {@link NestedGuard}), and a narrowing does not survive two
+    // spellings of `(obj.a as Record<string, unknown>).b`.
+    case "string": {
+      const parts = [`typeof ${acc} === 'string'`];
+      const formatPass = guardFormatPass(schema, acc, ctx);
+      if (formatPass !== null)
+        parts.push(formatPass);
+      if (hasPattern(schema))
+        parts.push(`${regexLiteral(schema.pattern)}.test(${acc})`);
+      if (hasMinLength(schema))
+        parts.push(minLengthPassExpr(acc, schema.minLength));
+      if (hasMaxLength(schema))
+        parts.push(maxLengthPassExpr(acc, schema.maxLength));
+      return withMembership(parts.join(" && "));
+    }
+    case "number":
+    case "integer": {
+      const parts = [`typeof ${acc} === 'number'`];
+      if (t === "integer")
+        parts.push(`Number.isInteger(${acc})`);
+      const formatPass = guardFormatPass(schema, acc, ctx);
+      if (formatPass !== null)
+        parts.push(formatPass);
+      if (hasMinimum(schema))
+        parts.push(boundPassExpr(acc, "minimum", schema.minimum, hasStrictExclusiveMinimum(schema)));
+      if (hasMaximum(schema))
+        parts.push(boundPassExpr(acc, "maximum", schema.maximum, hasStrictExclusiveMaximum(schema)));
+      if (hasExclusiveMinimum(schema))
+        parts.push(boundPassExpr(acc, "minimum", schema.exclusiveMinimum, true));
+      if (hasExclusiveMaximum(schema))
+        parts.push(boundPassExpr(acc, "maximum", schema.exclusiveMaximum, true));
+      if (hasMultipleOf(schema))
+        parts.push(multipleOfPassExpr(acc, schema.multipleOf));
+      return withMembership(parts.join(" && "));
+    }
+    case "boolean":
+      return withMembership(`typeof ${acc} === 'boolean'`);
+    case "null":
+      return withMembership(`${acc} === null`);
+    case "object":
+      return null;
+    case "array":
+      return withMembership(booleanArrayExpr(schema, acc, ctx));
+    default:
+      return null;
+  }
+};
+const booleanArrayExpr = (schema, acc, ctx) => {
+  const parts = [`Array.isArray(${acc})`];
+  if (hasMinItems(schema))
+    parts.push(`${acc}.length >= ${schema.minItems}`);
+  if (hasMaxItems(schema))
+    parts.push(`${acc}.length <= ${schema.maxItems}`);
+  if (hasUniqueItems(schema) && schema.uniqueItems === true) {
+    parts.push(arrayItemsAreScalarOnly(schema) ? `new Set(${acc} as unknown[]).size === ${acc}.length` : `allUnique(${acc} as unknown[])`);
+  }
+  const base = parts.join(" && ");
+  if (readKey(schema, "items") === false)
+    return `${base} && ${acc}.length === 0`;
+  if (!hasItems(schema))
+    return base;
+  const items = schema.items;
+  if (!isSchemaObject(items))
+    return base;
+  if (hasRef(items))
+    return null;
+  if (isNestedObjectLeaf(items)) {
+    const local = `_n${ctx.locals++}`;
+    const block = booleanObjectParts(items, local, local, ctx);
+    if (block === null)
+      return null;
+    const body = joinInline([
+      `const ${local} = _it as Record<string, unknown>`,
+      ...renderGuardBlock(block, "return false", "", "inline", ctx.unknownKeys),
+      `return true`
+    ]);
+    return `${base} && everyItem(${acc} as unknown[], (_it) => { ${body} })`;
+  }
+  const itemExpr = booleanLeafExpr(items, "_it", ctx);
+  if (itemExpr === null)
+    return null;
+  return `${base} && everyItem(${acc} as unknown[], (_it) => (${itemExpr}))`;
+};
+const booleanObjectParts = (schema, raw, objAcc, ctx) => {
+  if (!isObjectSchema(schema))
+    return null;
+  if (hasRef(schema) || hasConst(schema) || hasEnum(schema))
+    return null;
+  if (getMjstInstanceOf(schema) !== void 0 || getMjstPrimitive(schema) !== void 0)
+    return null;
+  if (hasDependentRequired(schema) || hasPropertyNames(schema) || declaresKey(schema, "dependentSchemas"))
+    return null;
+  if (hasMinProperties(schema) || hasMaxProperties(schema) || declaresKey(schema, "dependencies"))
+    return null;
+  if (isSchemaObject(schema) && declaresKey(schema, "patternProperties"))
+    return null;
+  if (hasObjectLevelCombinator(schema))
+    return null;
+  if (carriesUnevaluated(schema))
+    return null;
+  let strict = false;
+  if (hasAdditionalProperties(schema)) {
+    if (schema.additionalProperties === false)
+      strict = true;
+    else
+      return null;
+  }
+  const required = new Set(hasRequired(schema) ? schema.required : []);
+  const properties = hasProperties(schema) ? schema.properties : {};
+  const keys = Object.keys(properties);
+  const arrayCheck = arrayRejectedByRequiredProp(keys, required, properties) ? "" : ` && !Array.isArray(${raw})`;
+  const block = emptyGuardBlock();
+  block.conditions.push(`typeof ${raw} === 'object' && ${raw} !== null${arrayCheck}`);
+  for (const key of keys) {
+    const propSchema = properties[key];
+    if (propSchema === void 0 || !isSchemaObject(propSchema))
+      return null;
+    if (PROTOTYPE_MEMBERS.has(key))
+      return null;
+    const member = safeAccessor(objAcc, key);
+    if (isNestedObjectLeaf(propSchema)) {
+      const local = `_n${ctx.locals++}`;
+      const nested = booleanObjectParts(propSchema, local, local, ctx);
+      if (nested === null)
+        return null;
+      block.nested.push({ local, read: member, optional: !required.has(key), block: nested });
+      continue;
+    }
+    const expr = booleanLeafExpr(propSchema, member, ctx);
+    if (expr === null)
+      return null;
+    block.conditions.push(required.has(key) ? expr : `(${member} === undefined || (${expr}))`);
+  }
+  for (const key of required) {
+    if (Object.hasOwn(properties, key))
+      continue;
+    block.conditions.push(hasOwnCheck(objAcc, key));
+  }
+  if (strict) {
+    const allRequired = keys.every((key) => required.has(key));
+    block.keyChecks.push({ obj: objAcc, count: allRequired ? keys.length : null, known: keys, index: ctx.loops++ });
+  }
+  return block;
+};
+const IMPLICIT_OBJECT_KEYWORDS = ["properties", "patternProperties", "additionalProperties"];
+const typeDescribesEveryAcceptedValue = (schema) => {
+  if (!isSchemaObject(schema))
+    return true;
+  const s = schema;
+  if (declaresKey(s, "type") || declaresKey(s, "enum") || declaresKey(s, "const") || declaresKey(s, "$ref"))
+    return true;
+  for (const keyword of ["allOf", "anyOf", "oneOf"]) {
+    const branches = readKey(s, keyword);
+    if (!Array.isArray(branches))
+      continue;
+    if (!branches.every((branch) => typeDescribesEveryAcceptedValue(branch)))
+      return false;
+  }
+  return !IMPLICIT_OBJECT_KEYWORDS.some((keyword) => declaresKey(s, keyword));
+};
+const generateBooleanGuard = (schema, typeName, _suffix = "", unknownKeys = DEFAULT_UNKNOWN_KEYS, formats = NO_FORMATS) => {
+  const name = guardName(typeName);
+  const returns = typeDescribesEveryAcceptedValue(rewriteNullable(schema)) ? `input is ${typeName}` : "boolean";
+  const fallback = `export const ${name} = (input: unknown): ${returns} => ${validatorName(typeName)}(input) === true`;
+  const rewritten = rewriteNullable(schema);
+  const ctx = createGuardContext(unknownKeys, formats);
+  if (declaresObjectType(rewritten)) {
+    if (!objectRootIsSelfContained(rewritten))
+      return fallback;
+    const block = booleanObjectParts(rewritten, "input", "obj", ctx);
+    if (block === null)
+      return fallback;
+    const body = isFlatGuardBlock(block) ? [`  return (`, block.conditions.map((part) => `    ${part}`).join(" &&\n"), `  )`] : [...renderGuardBlock(block, "return false", "  ", "lines", unknownKeys), `  return true`];
+    return [
+      `export const ${name} = (input: unknown): ${returns} => {`,
+      // Same unused-local as the validator's hot guard: a node with no property
+      // to read guards on the shape alone and never touches the narrowing.
+      ...readsObjBinding(body.join("\n")) ? [`  const obj = input as Record<string, unknown>`] : [],
+      ...body,
+      `}`
+    ].join("\n");
+  }
+  const expr = booleanLeafExpr(rewritten, "input", ctx);
+  if (expr === null)
+    return fallback;
+  return `export const ${name} = (input: unknown): ${returns} => ${expr}`;
+};
+const generateScalarValidator = (schema, typeName, suffix, rootSchema, formats, branchErrors, failFast) => {
+  const vName = emittedName(typeName, failFast);
+  if (!isSchemaObject(schema)) {
+    if (schema === false) {
+      return [
+        `export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`,
+        `  ${returnError(JSON.stringify(FALSE_SCHEMA_MESSAGE), "_path", "false schema")}`,
+        `}`
+      ].join("\n");
+    }
+    return [`export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`, `  return true`, `}`].join("\n");
+  }
+  const generalRoot = () => generateGeneralRootValidator(schema, typeName, suffix, rootSchema, formats, branchErrors, failFast);
+  if (hasRef(schema)) {
+    if (declaresKeywordOutside(schema, ["$ref"]))
+      return generalRoot();
+    const delegateName = emittedName(refToName(schema.$ref, suffix), failFast);
+    return [
+      `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+      `  return ${delegateName}(input, _path)`,
+      `}`
+    ].join("\n");
+  }
+  const instanceOf = getMjstInstanceOf(schema);
+  if (instanceOf) {
+    if (declaresKeywordOutside(schema, [MJST_EXTENSION_KEY, "type"]))
+      return generalRoot();
+    return [
+      `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+      `  if (!(input instanceof ${instanceOf})) {`,
+      `    ${returnError(`'must be ${instanceOf}'`, "_path", "type", JSON.stringify({ type: instanceOf }))}`,
+      `  }`,
+      `  return true`,
+      `}`
+    ].join("\n");
+  }
+  const primitive = getMjstPrimitive(schema);
+  if (primitive) {
+    if (declaresKeywordOutside(schema, [MJST_EXTENSION_KEY, "type"]))
+      return generalRoot();
+    return [
+      `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+      `  if (typeof input !== "${primitive}") {`,
+      `    ${returnError(`'must be ${primitive}'`, "_path", "type", JSON.stringify({ type: primitive }))}`,
+      `  }`,
+      `  return true`,
+      `}`
+    ].join("\n");
+  }
+  if (hasConst(schema)) {
+    if (declaresKeywordOutside(schema, ["const"]))
+      return generalRoot();
+    const mismatch = constMismatchCondition("input", schema.const);
+    const msg = JSON.stringify(`must be ${JSON.stringify(schema.const)}`);
+    return [
+      `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+      `  if (${mismatch}) {`,
+      `    ${returnError(msg, "_path", "const", JSON.stringify({ allowedValue: schema.const }))}`,
+      `  }`,
+      `  return true`,
+      `}`
+    ].join("\n");
+  }
+  if (hasEnum(schema)) {
+    if (declaresKeywordOutside(schema, ["enum"]))
+      return generalRoot();
+    const label = schema.enum.map((v) => JSON.stringify(v)).join(", ");
+    return [
+      `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+      `  if (!${enumMembershipExpr(schema.enum, "input")}) {`,
+      `    ${returnError(JSON.stringify(`must be one of: ${label}`), "_path", "enum", JSON.stringify({ allowedValues: schema.enum }))}`,
+      `  }`,
+      `  return true`,
+      `}`
+    ].join("\n");
+  }
+  if (hasAllOf(schema) || hasAnyOf(schema) || hasOneOf(schema) || declaresKey(schema, "not") || declaresKey(schema, "if")) {
+    const ctx = createRootContext(rootSchema, formats, branchErrors, failFast);
+    const checks = [];
+    const rootPath = "`${_path}`";
+    const rootTypeArray2 = getTypeArray(schema);
+    if (rootTypeArray2) {
+      const allWrong = rootTypeArray2.map((t) => wrongTypeCondition(typeTestAccessor("input", ctx), t)).filter((c) => c !== "").map((c) => `(${c})`).join(" && ");
+      if (allWrong) {
+        const label = rootTypeArray2.map((t) => typeofString(t)).join(" or ");
+        checks.push(`  if (${allWrong}) {`);
+        checks.push(`    ${pushError(ctx.sink, JSON.stringify(`must be ${label}`), rootPath, "type", JSON.stringify({ type: schema.type }))}`);
+        checks.push(`  }`);
+      }
+    } else if (hasType(schema)) {
+      const t = schema.type;
+      const wrongType = wrongTypeCondition(typeTestAccessor("input", ctx), t);
+      if (wrongType) {
+        checks.push(`  if (${wrongType}) {`);
+        checks.push(`    ${pushError(ctx.sink, `'must be ${typeofString(t)}'`, rootPath, "type", JSON.stringify({ type: t }))}`);
+        checks.push(`  }`);
+      }
+    }
+    checks.push(...generateConstraintChecks("", "input", rootPath, schema, suffix, ctx));
+    checks.push(...generateCombinatorChecks("", "input", rootPath, schema, suffix, ctx));
+    const body = checks.join("\n");
+    return withHoisted(ctx.hoisted, [
+      `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+      ...errorsBinding(failFast),
+      body,
+      errorsVerdict(failFast),
+      `}`
+    ].join("\n"));
+  }
+  const rootTypeArray = getTypeArray(schema);
+  if (rootTypeArray) {
+    const ctx = createRootContext(rootSchema, formats, branchErrors, failFast);
+    const rootPath = "`${_path}`";
+    const checks = [];
+    const allWrong = rootTypeArray.map((t) => wrongTypeCondition(typeTestAccessor("input", ctx), t)).filter((c) => c !== "").map((c) => `(${c})`).join(" && ");
+    if (allWrong) {
+      const label = rootTypeArray.map((t) => typeofString(t)).join(" or ");
+      checks.push(`  if (${allWrong}) {`);
+      checks.push(`    ${pushError(ctx.sink, JSON.stringify(`must be ${label}`), rootPath, "type", JSON.stringify({ type: schema.type }))}`);
+      checks.push(`  }`);
+    }
+    checks.push(...generateConstraintChecks("", "input", rootPath, schema, suffix, ctx));
+    if (checks.length === 0) {
+      return [
+        `export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`,
+        `  return true`,
+        `}`
+      ].join("\n");
+    }
+    const body = checks.join("\n");
+    return withHoisted(ctx.hoisted, [
+      `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+      ...errorsBinding(failFast),
+      body,
+      errorsVerdict(failFast),
+      `}`
+    ].join("\n"));
+  }
+  if (hasType(schema)) {
+    const t = schema.type;
+    const wrongType = wrongTypeCondition("input", t);
+    const typLabel = typeofString(t);
+    const rootCtx = createRootContext(rootSchema, formats, branchErrors, failFast);
+    const constraintLines = generateConstraintChecks("", "_root", "`${_path}`", schema, suffix, rootCtx);
+    if (!wrongType) {
+      return [
+        `export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`,
+        `  return true`,
+        `}`
+      ].join("\n");
+    }
+    if (constraintLines.length === 0) {
+      return [
+        `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+        `  if (${wrongType}) {`,
+        `    ${returnError(`'must be ${typLabel}'`, "_path", "type", JSON.stringify({ type: schema.type }))}`,
+        `  }`,
+        `  return true`,
+        `}`
+      ].join("\n");
+    }
+    return withHoisted(rootCtx.hoisted, [
+      `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+      `  if (${wrongType}) {`,
+      `    ${returnError(`'must be ${typLabel}'`, "_path", "type", JSON.stringify({ type: schema.type }))}`,
+      `  }`,
+      ...readsBinding("_root", constraintLines.join("\n")) ? [`  const _root: unknown = input`] : [],
+      ...errorsBinding(failFast),
+      constraintLines.join("\n"),
+      errorsVerdict(failFast),
+      `}`
+    ].join("\n"));
+  }
+  const typelessCtx = createRootContext(rootSchema, formats, branchErrors, failFast);
+  const typelessChecks = generateConstraintChecks("", "input", "`${_path}`", schema, suffix, typelessCtx);
+  if (typelessChecks.length === 0) {
+    return [`export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`, `  return true`, `}`].join("\n");
+  }
+  return withHoisted(typelessCtx.hoisted, [
+    `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+    ...errorsBinding(failFast),
+    typelessChecks.join("\n"),
+    errorsVerdict(failFast),
+    `}`
+  ].join("\n"));
+};
+const generateGeneralRootValidator = (schema, typeName, suffix, rootSchema, formats, branchErrors, failFast) => {
+  const ctx = createRootContext(rootSchema, formats, branchErrors, failFast);
+  const checks = generateValueChecks("", "input", "`${_path}`", schema, suffix, ctx, true);
+  const body = checks.join("\n");
+  return withHoisted(ctx.hoisted, [
+    `export const ${emittedName(typeName, failFast)} = (input: unknown, _path = ''): ValidationResult => {`,
+    ...errorsBinding(failFast),
+    body,
+    errorsVerdict(failFast),
+    `}`
+  ].join("\n"));
+};
+const SINGLE_SUBSCHEMA_KEYS = /* @__PURE__ */ new Set([
+  "additionalProperties",
+  "additionalItems",
+  "contains",
+  "propertyNames",
+  "not",
+  "if",
+  "then",
+  "else",
+  "unevaluatedProperties",
+  "unevaluatedItems"
+]);
+const SUBSCHEMA_LIST_KEYS = /* @__PURE__ */ new Set(["allOf", "anyOf", "oneOf", "prefixItems"]);
+const SUBSCHEMA_MAP_KEYS = /* @__PURE__ */ new Set(["properties", "patternProperties", "dependentSchemas", "$defs", "definitions"]);
+const defineEntry = (target, key, value) => {
+  if (key === "__proto__") {
+    Object.defineProperty(target, key, { value, writable: true, enumerable: true, configurable: true });
+    return;
+  }
+  target[key] = value;
+};
+const rewriteNullable = (node) => {
+  if (typeof node !== "object" || node === null || Array.isArray(node))
+    return node;
+  const src = node;
+  const out = {};
+  for (const [key, value] of Object.entries(src)) {
+    if (key === "nullable")
+      continue;
+    if (SINGLE_SUBSCHEMA_KEYS.has(key)) {
+      defineEntry(out, key, rewriteNullable(value));
+    } else if (key === "items") {
+      defineEntry(out, key, Array.isArray(value) ? value.map(rewriteNullable) : rewriteNullable(value));
+    } else if (SUBSCHEMA_LIST_KEYS.has(key) && Array.isArray(value)) {
+      defineEntry(out, key, value.map(rewriteNullable));
+    } else if (SUBSCHEMA_MAP_KEYS.has(key) && typeof value === "object" && value !== null) {
+      const mapped = {};
+      for (const [name, sub] of Object.entries(value)) {
+        defineEntry(mapped, name, rewriteNullable(sub));
+      }
+      defineEntry(out, key, mapped);
+    } else if (key === "dependencies" && typeof value === "object" && value !== null) {
+      const mapped = {};
+      for (const [name, sub] of Object.entries(value)) {
+        defineEntry(mapped, name, Array.isArray(sub) ? sub : rewriteNullable(sub));
+      }
+      defineEntry(out, key, mapped);
+    } else {
+      defineEntry(out, key, value);
+    }
+  }
+  if (readKey(src, "nullable") === true)
+    return { anyOf: [{ type: "null" }, out] };
+  return out;
+};
+const generateValidatorFunction = (schema, typeName, suffix = "", rootSchema, unknownKeys = DEFAULT_UNKNOWN_KEYS, formats = NO_FORMATS, branchErrors = false) => generateValidatorSource(schema, typeName, suffix, rootSchema, unknownKeys, formats, branchErrors, {
+  on: false,
+  blocked: false
+});
+const generateCheckFunction = (schema, typeName, suffix = "", rootSchema, unknownKeys = DEFAULT_UNKNOWN_KEYS, formats = NO_FORMATS) => {
+  const failFast = { on: true, blocked: false };
+  const source = generateValidatorSource(schema, typeName, suffix, rootSchema, unknownKeys, formats, false, failFast);
+  if (source.includes(FAIL_FAST_SINK)) {
+    throw new Error(`the fail-fast validator for "${typeName}" emitted the error sink verbatim, which means some emitter reported through \`ctx.sink\` without going through \`pushError\`. That report has to take the fail-fast form (a \`return\`) or stay on the accumulating path.`);
+  }
+  if (!failFast.blocked)
+    return source;
+  return [
+    `export const ${checkerName(typeName)} = (input: unknown, _path = ''): ValidationResult => {`,
+    `  const _r = ${validatorName(typeName)}(input, _path)`,
+    `  return _r === true ? true : { valid: false, errors: _r.errors.slice(0, 1) }`,
+    `}`
+  ].join("\n");
+};
+const generateValidatorSource = (schema, typeName, suffix, rootSchema, unknownKeys, formats, branchErrors, failFast) => {
+  assertGeneratableRefs(schema, typeName);
+  const rewritten = rewriteNullable(schema);
+  const document = rootSchema ?? schema;
+  assertUnevaluatedGeneratable(rewritten, typeName, document, unevaluatedMatcher(suffix, createRootContext(document, formats, branchErrors, failFast)));
+  if (carriesUnevaluated(rewritten)) {
+    return generateGeneralRootValidator(rewritten, typeName, suffix, document, formats, branchErrors, failFast);
+  }
+  if (declaresObjectType(rewritten) && objectRootIsSelfContained(rewritten)) {
+    return generateObjectValidator(rewritten, typeName, suffix, document, unknownKeys, formats, branchErrors, failFast);
+  }
+  return generateScalarValidator(rewritten, typeName, suffix, document, formats, branchErrors, failFast);
+};
+export {
+  generateBooleanGuard,
+  generateCheckFunction,
+  generateValidatorFunction
+};