@amritk/generate-validators 0.11.12 → 0.12.1

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

@@ -1,11 +1,24 @@
-import { escapeRegexPattern } from "@amritk/helpers/escape-regex-pattern";
+import { regexFlagsFor, regexLiteral } from "@amritk/helpers/escape-regex-pattern";
 import { getMjstInstanceOf, getMjstPrimitive } from "@amritk/helpers/mjst-extension";
 import { multipleOfFailExpr, multipleOfPassExpr } from "@amritk/helpers/multiple-of-check";
 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 { assertGeneratableRefs } from "./assert-generatable-refs.js";
+import { assertUnevaluatedGeneratable, UNPROVABLE_COVERAGE_MESSAGE } from "./assert-unevaluated-generatable.js";
+import { unevaluatedItemsExpr, unevaluatedPropertiesExpr } from "./unevaluated-match.js";
 const validatorName = (typeName) => `validate${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";
@@ -17,6 +30,19 @@ const constMismatchCondition = (accessor, 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))
@@ -59,12 +85,19 @@ const wrongTypeCondition = (accessor, type) => {
       return "";
   }
 };
+const declaresObjectType = (schema) => hasType(schema) && schema.type === "object";
 const getTypeArray = (schema) => {
   if (!isSchemaObject(schema) || !("type" in schema) || !Array.isArray(schema.type))
     return null;
   return schema.type;
 };
-const createRootContext = () => ({ objVar: "obj", pathPrefix: "${_path}", depth: 0, hoisted: [] });
+const createRootContext = (rootSchema) => ({
+  objVar: "obj",
+  pathPrefix: "${_path}",
+  depth: 0,
+  hoisted: [],
+  rootSchema
+});
 const pointerSegment = (key) => key.replace(/~/g, "~0").replace(/\//g, "~1").replace(/[\\`$]/g, "\\$&");
 const patternPropertySources = (schema) => {
   if (!isSchemaObject(schema) || !("patternProperties" in schema))
@@ -87,7 +120,8 @@ const generateStrictKeyChecks = (schema, ctx) => {
   let patternGuard = "";
   if (patterns.length > 0) {
     const patternsName = `_patterns${ctx.hoisted.length}`;
-    ctx.hoisted.push(`const ${patternsName} = [${patterns.map((p) => `new RegExp(${JSON.stringify(p)})`).join(", ")}]`);
+    const compiled = patterns.map((p) => `new RegExp(${JSON.stringify(p)}, ${JSON.stringify(regexFlagsFor(p))})`);
+    ctx.hoisted.push(`const ${patternsName} = [${compiled.join(", ")}]`);
     patternGuard = ` && !${patternsName}.some((re) => re.test(_key${d}))`;
   }
   return [
@@ -107,25 +141,57 @@ const generateMissingRequiredChecks = (schema, ctx) => {
   for (const key of schema.required) {
     if (Object.hasOwn(props, key))
       continue;
-    lines.push(`  if (!(${JSON.stringify(key)} in ${ctx.objVar})) {`);
+    lines.push(`  if (${missingCheck(ctx.objVar, key)}) {`);
     lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
     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) {
+      return [
+        `  if (${missingCheck(ctx.objVar, key)}) {`,
+        `    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`,
+        `  } else {`,
+        `    errors.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} })`,
+      `  }`
+    ];
+  }
+  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 generatePropertyCheckLines = (key, propSchema, isRequired, suffix, ctx) => {
   if (!isSchemaObject(propSchema)) {
     if (isRequired && propSchema === true) {
       const parentPath2 = ctx.depth === 0 ? "_path" : `\`${ctx.pathPrefix}\``;
       return [
-        `  if (!(${JSON.stringify(key)} in ${ctx.objVar})) {`,
+        `  if (${missingCheck(ctx.objVar, key)}) {`,
         `    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath2} })`,
         `  }`
       ];
     }
     return [];
   }
-  const raw = `${ctx.objVar}[${JSON.stringify(key)}]`;
+  const raw = PROTOTYPE_MEMBERS.has(key) ? protoLocalName(key, ctx.depth) : propertyRead(ctx.objVar, key);
   const path = `\`${ctx.pathPrefix}/${pointerSegment(key)}\``;
   const parentPath = ctx.depth === 0 ? "_path" : `\`${ctx.pathPrefix}\``;
   const lines = [];
@@ -142,7 +208,7 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix, ctx) => {
       ...siblings
     ];
     if (isRequired) {
-      lines.push(`  if (!(${JSON.stringify(key)} in ${ctx.objVar})) {`);
+      lines.push(`  if (${missingCheck(ctx.objVar, key)}) {`);
       lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
       lines.push(`  } else {`);
       lines.push(...delegate);
@@ -157,7 +223,7 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix, ctx) => {
   const instanceOf = getMjstInstanceOf(propSchema);
   if (instanceOf) {
     if (isRequired) {
-      lines.push(`  if (!(${JSON.stringify(key)} in ${ctx.objVar})) {`);
+      lines.push(`  if (${missingCheck(ctx.objVar, key)}) {`);
       lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
       lines.push(`  } else if (!(${raw} instanceof ${instanceOf})) {`);
       lines.push(`    errors.push({ message: 'must be ${instanceOf}', path: ${path} })`);
@@ -172,7 +238,7 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix, ctx) => {
   const primitive = getMjstPrimitive(propSchema);
   if (primitive) {
     if (isRequired) {
-      lines.push(`  if (!(${JSON.stringify(key)} in ${ctx.objVar})) {`);
+      lines.push(`  if (${missingCheck(ctx.objVar, key)}) {`);
       lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
       lines.push(`  } else if (typeof ${raw} !== "${primitive}") {`);
       lines.push(`    errors.push({ message: 'must be ${primitive}', path: ${path} })`);
@@ -188,7 +254,7 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix, ctx) => {
     const mismatch = constMismatchCondition(raw, propSchema.const);
     const msg = JSON.stringify(`must be ${JSON.stringify(propSchema.const)}`);
     if (isRequired) {
-      lines.push(`  if (!(${JSON.stringify(key)} in ${ctx.objVar})) {`);
+      lines.push(`  if (${missingCheck(ctx.objVar, key)}) {`);
       lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
       lines.push(`  } else if (${mismatch}) {`);
       lines.push(`    errors.push({ message: ${msg}, path: ${path} })`);
@@ -201,16 +267,16 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix, ctx) => {
     return lines;
   }
   if (hasEnum(propSchema)) {
-    const allowed = JSON.stringify(propSchema.enum);
+    const member = enumMembershipExpr(propSchema.enum, raw);
     const label = propSchema.enum.map((v) => JSON.stringify(v)).join(", ");
     if (isRequired) {
-      lines.push(`  if (!(${JSON.stringify(key)} in ${ctx.objVar})) {`);
+      lines.push(`  if (${missingCheck(ctx.objVar, key)}) {`);
       lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
-      lines.push(`  } else if (!(${allowed} as unknown[]).includes(${raw})) {`);
+      lines.push(`  } else if (!${member}) {`);
       lines.push(`    errors.push({ message: ${JSON.stringify(`must be one of: ${label}`)}, path: ${path} })`);
       lines.push(`  }`);
     } else {
-      lines.push(`  if (${raw} !== undefined && !(${allowed} as unknown[]).includes(${raw})) {`);
+      lines.push(`  if (${raw} !== undefined && !${member}) {`);
       lines.push(`    errors.push({ message: ${JSON.stringify(`must be one of: ${label}`)}, path: ${path} })`);
       lines.push(`  }`);
     }
@@ -221,7 +287,7 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix, ctx) => {
     const allWrong = typeArray.map((t) => wrongTypeCondition(raw, t)).filter((c) => c !== "").map((c) => `(${c})`).join(" && ");
     const label = typeArray.map((t) => typeofString(t)).join(" or ");
     if (isRequired) {
-      lines.push(`  if (!(${JSON.stringify(key)} in ${ctx.objVar})) {`);
+      lines.push(`  if (${missingCheck(ctx.objVar, key)}) {`);
       lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
       if (allWrong) {
         lines.push(`  } else if (${allWrong}) {`);
@@ -241,7 +307,7 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix, ctx) => {
     const wrongType = wrongTypeCondition(raw, t);
     const typLabel = typeofString(t);
     if (isRequired) {
-      lines.push(`  if (!(${JSON.stringify(key)} in ${ctx.objVar})) {`);
+      lines.push(`  if (${missingCheck(ctx.objVar, key)}) {`);
       lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
       if (wrongType) {
         lines.push(`  } else if (${wrongType}) {`);
@@ -266,7 +332,7 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix, ctx) => {
       lines.push(`  }`);
     }
   } else if (isRequired) {
-    lines.push(`  if (!(${JSON.stringify(key)} in ${ctx.objVar})) {`);
+    lines.push(`  if (${missingCheck(ctx.objVar, key)}) {`);
     lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
     if (extraLines.length > 0) {
       lines.push(`  } else {`);
@@ -287,19 +353,19 @@ const generateConstraintChecks = (key, raw, path, propSchema, suffix, ctx) => {
   const lines = [];
   if (hasPattern(propSchema) || hasMinLength(propSchema) || hasMaxLength(propSchema)) {
     if (hasPattern(propSchema)) {
-      const re = escapeRegexPattern(propSchema.pattern);
+      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(`  if (typeof ${raw} === 'string' && !${re}.test(${raw})) {`);
       lines.push(`    errors.push({ message: ${msg}, path: ${path} })`);
       lines.push(`  }`);
     }
     if (hasMinLength(propSchema)) {
-      lines.push(`  if (typeof ${raw} === 'string' && ${raw}.length < ${propSchema.minLength}) {`);
+      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(`  }`);
     }
     if (hasMaxLength(propSchema)) {
-      lines.push(`  if (typeof ${raw} === 'string' && ${raw}.length > ${propSchema.maxLength}) {`);
+      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(`  }`);
     }
@@ -307,27 +373,25 @@ const generateConstraintChecks = (key, raw, path, propSchema, suffix, ctx) => {
   if (hasMinimum(propSchema) || hasMaximum(propSchema) || hasExclusiveMinimum(propSchema) || hasExclusiveMaximum(propSchema) || hasMultipleOf(propSchema)) {
     if (hasMinimum(propSchema)) {
       const strict = hasStrictExclusiveMinimum(propSchema);
-      const op = strict ? "<=" : "<";
       const rel = strict ? ">" : ">=";
-      lines.push(`  if (typeof ${raw} === 'number' && ${raw} ${op} ${propSchema.minimum}) {`);
+      lines.push(`  if (typeof ${raw} === 'number' && !(${raw} ${rel} ${propSchema.minimum})) {`);
       lines.push(`    errors.push({ message: 'must be ${rel} ${propSchema.minimum}', path: ${path} })`);
       lines.push(`  }`);
     }
     if (hasMaximum(propSchema)) {
       const strict = hasStrictExclusiveMaximum(propSchema);
-      const op = strict ? ">=" : ">";
       const rel = strict ? "<" : "<=";
-      lines.push(`  if (typeof ${raw} === 'number' && ${raw} ${op} ${propSchema.maximum}) {`);
+      lines.push(`  if (typeof ${raw} === 'number' && !(${raw} ${rel} ${propSchema.maximum})) {`);
       lines.push(`    errors.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(`  if (typeof ${raw} === 'number' && !(${raw} > ${propSchema.exclusiveMinimum})) {`);
       lines.push(`    errors.push({ message: 'must be > ${propSchema.exclusiveMinimum}', path: ${path} })`);
       lines.push(`  }`);
     }
     if (hasExclusiveMaximum(propSchema)) {
-      lines.push(`  if (typeof ${raw} === 'number' && ${raw} >= ${propSchema.exclusiveMaximum}) {`);
+      lines.push(`  if (typeof ${raw} === 'number' && !(${raw} < ${propSchema.exclusiveMaximum})) {`);
       lines.push(`    errors.push({ message: 'must be < ${propSchema.exclusiveMaximum}', path: ${path} })`);
       lines.push(`  }`);
     }
@@ -339,12 +403,14 @@ const generateConstraintChecks = (key, raw, path, propSchema, suffix, ctx) => {
   }
   if (hasItems(propSchema)) {
     const itemSchema = propSchema.items;
+    const prefix = sp["prefixItems"];
+    const firstTailIndex = Array.isArray(prefix) ? prefix.length : 0;
     const iv = `_i${ctx.depth}`;
     const itemPath = `\`${path.slice(1, -1)}/\${${iv}}\``;
     if (hasRef(itemSchema)) {
       const vName = validatorName(refToName(itemSchema.$ref, suffix));
       lines.push(`  if (Array.isArray(${raw})) {`);
-      lines.push(`    for (let ${iv} = 0; ${iv} < ${raw}.length; ${iv}++) {`);
+      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(`    }`);
@@ -354,7 +420,7 @@ const generateConstraintChecks = (key, raw, path, propSchema, suffix, ctx) => {
       const detail = generateValueChecks("", itemVar, itemPath, itemSchema, suffix, ctx, true);
       if (detail.length > 0) {
         lines.push(`  if (Array.isArray(${raw})) {`);
-        lines.push(`    for (let ${iv} = 0; ${iv} < ${raw}.length; ${iv}++) {`);
+        lines.push(`    for (let ${iv} = ${firstTailIndex}; ${iv} < ${raw}.length; ${iv}++) {`);
         lines.push(`      const ${itemVar} = ${raw}[${iv}]`);
         lines.push(...detail.map((l) => `    ${l}`));
         lines.push(`    }`);
@@ -362,7 +428,7 @@ const generateConstraintChecks = (key, raw, path, propSchema, suffix, ctx) => {
       }
     }
   }
-  if (hasMinItems(propSchema) || hasMaxItems(propSchema) || hasUniqueItems(propSchema) && propSchema.uniqueItems === true || isSchemaObject(sp["contains"]) || Array.isArray(sp["prefixItems"]) || sp["items"] === false && !Array.isArray(sp["prefixItems"])) {
+  if (hasMinItems(propSchema) || hasMaxItems(propSchema) || hasUniqueItems(propSchema) && propSchema.uniqueItems === true || "contains" in sp || Array.isArray(sp["prefixItems"]) || sp["items"] === false && !Array.isArray(sp["prefixItems"])) {
     if (sp["items"] === false && !Array.isArray(sp["prefixItems"])) {
       lines.push(`  if (Array.isArray(${raw}) && ${raw}.length > 0) {`);
       lines.push(`    errors.push({ message: 'must NOT have more than 0 items', path: ${path} })`);
@@ -384,7 +450,7 @@ const generateConstraintChecks = (key, raw, path, propSchema, suffix, ctx) => {
       lines.push(`    errors.push({ message: 'must NOT have duplicate items', path: ${path} })`);
       lines.push(`  }`);
     }
-    if (isSchemaObject(sp["contains"])) {
+    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);
@@ -418,10 +484,24 @@ const generateConstraintChecks = (key, raw, path, propSchema, suffix, ctx) => {
   lines.push(...generateInlineObjectChecks(key, propSchema, raw, suffix, ctx));
   return lines;
 };
-const generateValueChecks = (_key, raw, path, propSchema, suffix, ctx, required = false) => {
+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 = `errors.push({ message: ${JSON.stringify(FALSE_SCHEMA_MESSAGE)}, path: ${path} })`;
+    if (required)
+      return [`  ${report}`];
+    return [`  if (${raw} !== undefined) {`, `    ${report}`, `  }`];
+  }
   if (!isSchemaObject(propSchema))
     return [];
-  const lines = [];
   const presence = required ? "" : `${raw} !== undefined && `;
   if (hasRef(propSchema)) {
     const vName = validatorName(refToName(propSchema.$ref, suffix));
@@ -459,9 +539,8 @@ const generateValueChecks = (_key, raw, path, propSchema, suffix, ctx, required
     return lines;
   }
   if (hasEnum(propSchema)) {
-    const allowed = JSON.stringify(propSchema.enum);
     const label = propSchema.enum.map((v) => JSON.stringify(v)).join(", ");
-    lines.push(`  if (${presence}!(${allowed} as unknown[]).includes(${raw})) {`);
+    lines.push(`  if (${presence}!${enumMembershipExpr(propSchema.enum, raw)}) {`);
     lines.push(`    errors.push({ message: ${JSON.stringify(`must be one of: ${label}`)}, path: ${path} })`);
     lines.push(`  }`);
     return lines;
@@ -476,11 +555,22 @@ const generateValueChecks = (_key, raw, path, propSchema, suffix, ctx, required
       lines.push(`  }`);
     }
   }
+  const typeArray = getTypeArray(propSchema);
+  if (typeArray) {
+    const allWrong = typeArray.map((t) => wrongTypeCondition(raw, t)).filter((c) => c !== "").map((c) => `(${c})`).join(" && ");
+    if (allWrong) {
+      const label = typeArray.map((t) => typeofString(t)).join(" or ");
+      lines.push(`  if (${presence}(${allWrong})) {`);
+      lines.push(`    errors.push({ message: ${JSON.stringify(`must be ${label}`)}, path: ${path} })`);
+      lines.push(`  }`);
+    }
+  }
   const valueCtx = {
     objVar: ctx.objVar,
     pathPrefix: path.slice(1, -1),
     depth: ctx.depth + 1,
-    hoisted: ctx.hoisted
+    hoisted: ctx.hoisted,
+    rootSchema: ctx.rootSchema
   };
   lines.push(...generateConstraintChecks("", raw, path, propSchema, suffix, valueCtx));
   lines.push(...generateCombinatorChecks("", raw, path, propSchema, suffix, valueCtx));
@@ -501,6 +591,41 @@ const generateMatchesExpr = (raw, sub, suffix, ctx) => {
 ${body}
     return _m.length === 0 })()`;
 };
+const unevaluatedMatcher = (suffix, ctx) => (accessor, schema, depth) => generateMatchesExpr(accessor, schema, suffix, { ...ctx, depth: ctx.depth + depth + 1 });
+const generateUnevaluatedChecks = (raw, path, schema, suffix, ctx) => {
+  if (!isSchemaObject(schema))
+    return [];
+  const s = schema;
+  if (!("unevaluatedProperties" in s) && !("unevaluatedItems" in s))
+    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) {
+    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(`      errors.push({ message: 'must NOT have unevaluated properties', path: ${path} })`);
+    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) {
+    lines.push(`  if (Array.isArray(${raw})) {`);
+    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(`    }`);
+    lines.push(`  }`);
+  }
+  return lines;
+};
 const generateCombinatorChecks = (key, raw, path, schema, suffix, ctx) => {
   if (!isSchemaObject(schema))
     return [];
@@ -553,13 +678,13 @@ const generatePatternAndAdditionalChecks = (schema, suffix, ctx) => {
   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 = escapeRegexPattern(pattern);
+    const re = regexLiteral(pattern);
     const kv = `_pk${d}`;
     const valueChecks = generateValueChecks(`\${${kv}}`, `${obj}[${kv}]`, `\`${ctx.pathPrefix}/\${${kv}}\``, sub, suffix, ctx);
     if (valueChecks.length === 0)
       continue;
     lines.push(`  for (const ${kv} in ${obj}) {`);
-    lines.push(`    if (/${re}/.test(${kv})) {`);
+    lines.push(`    if (${re}.test(${kv})) {`);
     lines.push(...valueChecks.map((line) => `    ${line}`));
     lines.push(`    }`);
     lines.push(`  }`);
@@ -574,7 +699,7 @@ const generatePatternAndAdditionalChecks = (schema, suffix, ctx) => {
       if (known.length > 0)
         lines.push(`    if (${JSON.stringify(known)}.includes(${kv})) continue`);
       for (const pattern of Object.keys(patternsRecord)) {
-        lines.push(`    if (/${escapeRegexPattern(pattern)}/.test(${kv})) continue`);
+        lines.push(`    if (${regexLiteral(pattern)}.test(${kv})) continue`);
       }
       lines.push(...valueChecks.map((line) => `    ${line}`));
       lines.push(`  }`);
@@ -592,7 +717,8 @@ const generateInlineObjectChecks = (key, propSchema, raw, suffix, ctx) => {
     // 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
+    hoisted: ctx.hoisted,
+    rootSchema: ctx.rootSchema
   };
   const required = new Set(hasRequired(propSchema) ? propSchema.required : []);
   const properties = hasProperties(propSchema) ? propSchema.properties : {};
@@ -607,7 +733,7 @@ const generateInlineObjectChecks = (key, propSchema, raw, suffix, ctx) => {
   innerLines.push(...generateDependentSchemasChecks(propSchema, suffix, child));
   innerLines.push(...generateDependenciesChecks(propSchema, suffix, child));
   innerLines.push(...generateMinMaxPropertiesChecks(propSchema, child));
-  if (hasPropertyNames(propSchema) && isSchemaObject(propSchema.propertyNames)) {
+  if (hasPropertyNames(propSchema)) {
     innerLines.push(...generatePropertyNameChecks(propSchema.propertyNames, suffix, child));
   }
   if (innerLines.length === 0)
@@ -620,14 +746,13 @@ const generateInlineObjectChecks = (key, propSchema, raw, suffix, ctx) => {
   ];
 };
 const generatePropertyNameChecks = (nameSchema, suffix, ctx) => {
-  if (!isSchemaObject(nameSchema))
-    return [];
   const at = `\`${ctx.pathPrefix}/\${_name}\``;
   const nameCtx = {
     objVar: ctx.objVar,
     pathPrefix: `${ctx.pathPrefix}/\${_name}`,
     depth: ctx.depth + 1,
-    hoisted: ctx.hoisted
+    hoisted: ctx.hoisted,
+    rootSchema: ctx.rootSchema
   };
   const checks = generateValueChecks("", "_name", at, nameSchema, suffix, nameCtx, true);
   if (checks.length === 0)
@@ -645,7 +770,7 @@ const generateDependentRequiredChecks = (schema, ctx) => {
       continue;
     for (const dep of deps) {
       const msg = JSON.stringify(`must have property '${dep}' when '${trigger}' is present`);
-      lines.push(`  if (${JSON.stringify(trigger)} in ${obj} && !(${JSON.stringify(dep)} in ${obj})) {`);
+      lines.push(`  if (${hasOwnCheck(obj, trigger)} && ${missingCheck(obj, dep)}) {`);
       lines.push(`    errors.push({ message: ${msg}, path: ${at} })`);
       lines.push(`  }`);
     }
@@ -667,7 +792,7 @@ const generateDependentSchemasChecks = (schema, suffix, ctx) => {
       continue;
     if (sub === false) {
       const msg = JSON.stringify(`must NOT have property '${trigger}'`);
-      lines.push(`  if (${JSON.stringify(trigger)} in ${obj}) {`);
+      lines.push(`  if (${hasOwnCheck(obj, trigger)}) {`);
       lines.push(`    errors.push({ message: ${msg}, path: ${at} })`);
       lines.push(`  }`);
       continue;
@@ -677,7 +802,7 @@ const generateDependentSchemasChecks = (schema, suffix, ctx) => {
     const checks = generateValueChecks("", obj, objPath, sub, suffix, ctx);
     if (checks.length === 0)
       continue;
-    lines.push(`  if (${JSON.stringify(trigger)} in ${obj}) {`);
+    lines.push(`  if (${hasOwnCheck(obj, trigger)}) {`);
     lines.push(...checks.map((line) => `  ${line}`));
     lines.push(`  }`);
   }
@@ -699,7 +824,7 @@ const generateDependenciesChecks = (schema, suffix, ctx) => {
         if (typeof key !== "string")
           continue;
         const msg = JSON.stringify(`must have property '${key}' when '${trigger}' is present`);
-        lines.push(`  if (${JSON.stringify(trigger)} in ${obj} && !(${JSON.stringify(key)} in ${obj})) {`);
+        lines.push(`  if (${hasOwnCheck(obj, trigger)} && ${missingCheck(obj, key)}) {`);
         lines.push(`    errors.push({ message: ${msg}, path: ${at} })`);
         lines.push(`  }`);
       }
@@ -709,7 +834,7 @@ const generateDependenciesChecks = (schema, suffix, ctx) => {
       continue;
     if (value === false) {
       const msg = JSON.stringify(`must NOT have property '${trigger}'`);
-      lines.push(`  if (${JSON.stringify(trigger)} in ${obj}) {`);
+      lines.push(`  if (${hasOwnCheck(obj, trigger)}) {`);
       lines.push(`    errors.push({ message: ${msg}, path: ${at} })`);
       lines.push(`  }`);
       continue;
@@ -719,7 +844,7 @@ const generateDependenciesChecks = (schema, suffix, ctx) => {
     const checks = generateValueChecks("", obj, objPath, value, suffix, ctx);
     if (checks.length === 0)
       continue;
-    lines.push(`  if (${JSON.stringify(trigger)} in ${obj}) {`);
+    lines.push(`  if (${hasOwnCheck(obj, trigger)}) {`);
     lines.push(...checks.map((line) => `  ${line}`));
     lines.push(`  }`);
   }
@@ -755,11 +880,17 @@ const hasObjectLevelCombinator = (schema) => {
     return false;
   return hasAllOf(schema) || hasAnyOf(schema) || hasOneOf(schema) || "not" in schema || "if" in schema;
 };
+const carriesUnevaluated = (schema) => {
+  if (!isSchemaObject(schema))
+    return false;
+  const s = schema;
+  return "unevaluatedProperties" in s && s["unevaluatedProperties"] !== true || "unevaluatedItems" in s && 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)) {
+  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)) {
     return null;
   }
   if (!hasType(propSchema))
@@ -807,6 +938,8 @@ const guardObjectConditions = (schema, raw, objAcc) => {
     return null;
   if (hasObjectLevelCombinator(schema))
     return null;
+  if (carriesUnevaluated(schema))
+    return null;
   let strict = false;
   if (hasAdditionalProperties(schema)) {
     if (schema.additionalProperties === false)
@@ -838,11 +971,11 @@ const guardObjectConditions = (schema, raw, objAcc) => {
   }
   return conditions;
 };
-const generateObjectValidator = (schema, typeName, suffix) => {
+const generateObjectValidator = (schema, typeName, suffix, rootSchema) => {
   const vName = validatorName(typeName);
   const required = new Set(hasRequired(schema) ? schema.required : []);
   const properties = hasProperties(schema) ? schema.properties : {};
-  const ctx = createRootContext();
+  const ctx = createRootContext(rootSchema);
   const propertyLines = [];
   for (const [key, propSchema] of Object.entries(properties)) {
     const checks = generatePropertyChecks(key, propSchema, required.has(key), suffix, ctx);
@@ -857,7 +990,7 @@ const generateObjectValidator = (schema, typeName, suffix) => {
   propertyLines.push(...generateDependentSchemasChecks(schema, suffix, ctx));
   propertyLines.push(...generateDependenciesChecks(schema, suffix, ctx));
   propertyLines.push(...generateMinMaxPropertiesChecks(schema, ctx));
-  if (hasPropertyNames(schema) && isSchemaObject(schema.propertyNames)) {
+  if (hasPropertyNames(schema)) {
     propertyLines.push(...generatePropertyNameChecks(schema.propertyNames, suffix, ctx));
   }
   propertyLines.push(...generateCombinatorChecks("", "obj", "`${_path}`", schema, suffix, ctx));
@@ -897,17 +1030,10 @@ const generateObjectValidator = (schema, typeName, suffix) => {
   ].join("\n");
 };
 const guardName = (typeName) => `is${typeName}`;
-const enumMembershipExpr = (values, acc) => {
-  const allPrimitive = values.length > 0 && values.every((v) => (v === null || typeof v !== "object") && typeof v !== "function") && !values.some((v) => typeof v === "number" && Number.isNaN(v));
-  if (allPrimitive) {
-    return `(${values.map((v) => `${acc} === ${JSON.stringify(v)}`).join(" || ")})`;
-  }
-  return `(${JSON.stringify(values)} as unknown[]).includes(${acc})`;
-};
 const booleanLeafExpr = (schema, acc) => {
   if (!isSchemaObject(schema))
     return null;
-  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 || getMjstInstanceOf(schema) !== void 0 || getMjstPrimitive(schema) !== void 0) {
+  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 || carriesUnevaluated(schema) || getMjstInstanceOf(schema) !== void 0 || getMjstPrimitive(schema) !== void 0) {
     return null;
   }
   if (hasEnum(schema)) {
@@ -917,18 +1043,20 @@ const booleanLeafExpr = (schema, acc) => {
     return null;
   const t = schema.type;
   switch (t) {
-    // Each constraint is the exact negation of the validator's error condition
-    // (`!(len < min)`, not `len >= min`) so edge values — most importantly `NaN`,
-    // which the validator accepts for a constrained number since `NaN < min` is
-    // false — get the identical verdict.
+    // 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.
     case "string": {
       const parts = [`typeof ${acc} === 'string'`];
       if (hasPattern(schema))
-        parts.push(`/${escapeRegexPattern(schema.pattern)}/.test(${acc})`);
+        parts.push(`${regexLiteral(schema.pattern)}.test(${acc})`);
       if (hasMinLength(schema))
-        parts.push(`!(${acc}.length < ${schema.minLength})`);
+        parts.push(minLengthPassExpr(acc, schema.minLength));
       if (hasMaxLength(schema))
-        parts.push(`!(${acc}.length > ${schema.maxLength})`);
+        parts.push(maxLengthPassExpr(acc, schema.maxLength));
       return parts.join(" && ");
     }
     case "number":
@@ -937,13 +1065,13 @@ const booleanLeafExpr = (schema, acc) => {
       if (t === "integer")
         parts.push(`Number.isInteger(${acc})`);
       if (hasMinimum(schema))
-        parts.push(`!(${acc} ${hasStrictExclusiveMinimum(schema) ? "<=" : "<"} ${schema.minimum})`);
+        parts.push(`${acc} ${hasStrictExclusiveMinimum(schema) ? ">" : ">="} ${schema.minimum}`);
       if (hasMaximum(schema))
-        parts.push(`!(${acc} ${hasStrictExclusiveMaximum(schema) ? ">=" : ">"} ${schema.maximum})`);
+        parts.push(`${acc} ${hasStrictExclusiveMaximum(schema) ? "<" : "<="} ${schema.maximum}`);
       if (hasExclusiveMinimum(schema))
-        parts.push(`!(${acc} <= ${schema.exclusiveMinimum})`);
+        parts.push(`${acc} > ${schema.exclusiveMinimum}`);
       if (hasExclusiveMaximum(schema))
-        parts.push(`!(${acc} >= ${schema.exclusiveMaximum})`);
+        parts.push(`${acc} < ${schema.exclusiveMaximum}`);
       if (hasMultipleOf(schema))
         parts.push(multipleOfPassExpr(acc, schema.multipleOf));
       return parts.join(" && ");
@@ -995,6 +1123,8 @@ const booleanObjectParts = (schema, raw, objAcc) => {
     return null;
   if (hasObjectLevelCombinator(schema))
     return null;
+  if (carriesUnevaluated(schema))
+    return null;
   let strict = false;
   if (hasAdditionalProperties(schema)) {
     if (schema.additionalProperties === false)
@@ -1011,6 +1141,8 @@ const booleanObjectParts = (schema, raw, objAcc) => {
     const propSchema = properties[key];
     if (propSchema === void 0 || !isSchemaObject(propSchema))
       return null;
+    if (PROTOTYPE_MEMBERS.has(key))
+      return null;
     const member = safeAccessor(objAcc, key);
     const expr = booleanLeafExpr(propSchema, member);
     if (expr === null)
@@ -1029,16 +1161,33 @@ const booleanObjectParts = (schema, raw, objAcc) => {
   }
   return parts;
 };
+const IMPLICIT_OBJECT_KEYWORDS = ["properties", "patternProperties", "additionalProperties"];
+const typeDescribesEveryAcceptedValue = (schema) => {
+  if (!isSchemaObject(schema))
+    return true;
+  const s = schema;
+  if ("type" in s || "enum" in s || "const" in s || "$ref" in s)
+    return true;
+  for (const keyword of ["allOf", "anyOf", "oneOf"]) {
+    const branches = s[keyword];
+    if (!Array.isArray(branches))
+      continue;
+    if (!branches.every((branch) => typeDescribesEveryAcceptedValue(branch)))
+      return false;
+  }
+  return !IMPLICIT_OBJECT_KEYWORDS.some((keyword) => keyword in s);
+};
 const generateBooleanGuard = (schema, typeName, _suffix = "") => {
   const name = guardName(typeName);
-  const fallback = `export const ${name} = (input: unknown): input is ${typeName} => ${validatorName(typeName)}(input) === true`;
+  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);
-  if (isObjectSchema(rewritten)) {
+  if (declaresObjectType(rewritten)) {
     const parts = booleanObjectParts(rewritten, "input", "obj");
     if (parts === null)
       return fallback;
     return [
-      `export const ${name} = (input: unknown): input is ${typeName} => {`,
+      `export const ${name} = (input: unknown): ${returns} => {`,
       `  const obj = input as Record<string, unknown>`,
       `  return (`,
       parts.map((part) => `    ${part}`).join(" &&\n"),
@@ -1049,11 +1198,18 @@ const generateBooleanGuard = (schema, typeName, _suffix = "") => {
   const expr = booleanLeafExpr(rewritten, "input");
   if (expr === null)
     return fallback;
-  return `export const ${name} = (input: unknown): input is ${typeName} => ${expr}`;
+  return `export const ${name} = (input: unknown): ${returns} => ${expr}`;
 };
-const generateScalarValidator = (schema, typeName, suffix) => {
+const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
   const vName = validatorName(typeName);
   if (!isSchemaObject(schema)) {
+    if (schema === false) {
+      return [
+        `export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`,
+        `  return { valid: false, errors: [{ message: ${JSON.stringify(FALSE_SCHEMA_MESSAGE)}, path: _path }] }`,
+        `}`
+      ].join("\n");
+    }
     return [`export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`, `  return true`, `}`].join("\n");
   }
   if (hasRef(schema)) {
@@ -1099,11 +1255,10 @@ const generateScalarValidator = (schema, typeName, suffix) => {
     ].join("\n");
   }
   if (hasEnum(schema)) {
-    const allowed = JSON.stringify(schema.enum);
     const label = schema.enum.map((v) => JSON.stringify(v)).join(", ");
     return [
       `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
-      `  if (!(${allowed} as unknown[]).includes(input)) {`,
+      `  if (!${enumMembershipExpr(schema.enum, "input")}) {`,
       `    return { valid: false, errors: [{ message: ${JSON.stringify(`must be one of: ${label}`)}, path: _path }] }`,
       `  }`,
       `  return true`,
@@ -1111,7 +1266,7 @@ const generateScalarValidator = (schema, typeName, suffix) => {
     ].join("\n");
   }
   if (hasAllOf(schema) || hasAnyOf(schema) || hasOneOf(schema) || "not" in schema || "if" in schema) {
-    const ctx = createRootContext();
+    const ctx = createRootContext(rootSchema);
     const checks = [];
     const rootPath = "`${_path}`";
     const rootTypeArray2 = getTypeArray(schema);
@@ -1123,7 +1278,6 @@ const generateScalarValidator = (schema, typeName, suffix) => {
         checks.push(`    errors.push({ message: ${JSON.stringify(`must be ${label}`)}, path: ${rootPath} })`);
         checks.push(`  }`);
       }
-      checks.push(...generateConstraintChecks("", "input", rootPath, schema, suffix, ctx));
     } else if (hasType(schema)) {
       const t = schema.type;
       const wrongType = wrongTypeCondition("input", t);
@@ -1132,8 +1286,8 @@ const generateScalarValidator = (schema, typeName, suffix) => {
         checks.push(`    errors.push({ message: 'must be ${typeofString(t)}', path: ${rootPath} })`);
         checks.push(`  }`);
       }
-      checks.push(...generateConstraintChecks("", "input", rootPath, schema, suffix, ctx));
     }
+    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 hoistedBlock = ctx.hoisted.length > 0 ? `${ctx.hoisted.join("\n")}
@@ -1149,21 +1303,33 @@ const generateScalarValidator = (schema, typeName, suffix) => {
   }
   const rootTypeArray = getTypeArray(schema);
   if (rootTypeArray) {
+    const ctx = createRootContext(rootSchema);
+    const rootPath = "`${_path}`";
+    const checks = [];
     const allWrong = rootTypeArray.map((t) => wrongTypeCondition("input", t)).filter((c) => c !== "").map((c) => `(${c})`).join(" && ");
-    const label = rootTypeArray.map((t) => typeofString(t)).join(" or ");
-    if (!allWrong) {
+    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(`  }`);
+    }
+    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").replaceAll("errors.push(", "(errors ??= []).push(");
+    const hoistedBlock = ctx.hoisted.length > 0 ? `${ctx.hoisted.join("\n")}
+
+` : "";
     return [
-      `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
-      `  if (${allWrong}) {`,
-      `    return { valid: false, errors: [{ message: ${JSON.stringify(`must be ${label}`)}, path: _path }] }`,
-      `  }`,
-      `  return true`,
+      `${hoistedBlock}export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+      `  let errors: ValidationError[] | undefined`,
+      body,
+      `  return errors !== undefined ? { valid: false, errors } : true`,
       `}`
     ].join("\n");
   }
@@ -1171,7 +1337,7 @@ const generateScalarValidator = (schema, typeName, suffix) => {
     const t = schema.type;
     const wrongType = wrongTypeCondition("input", t);
     const typLabel = typeofString(t);
-    const rootCtx = createRootContext();
+    const rootCtx = createRootContext(rootSchema);
     const constraintLines = generateConstraintChecks("", "input", "`${_path}`", schema, suffix, rootCtx);
     if (!wrongType) {
       return [
@@ -1204,27 +1370,36 @@ const generateScalarValidator = (schema, typeName, suffix) => {
       `}`
     ].join("\n");
   }
-  return [`export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`, `  return true`, `}`].join("\n");
+  const typelessCtx = createRootContext(rootSchema);
+  const typelessChecks = generateConstraintChecks("", "input", "`${_path}`", schema, suffix, typelessCtx);
+  if (typelessChecks.length === 0) {
+    return [`export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`, `  return true`, `}`].join("\n");
+  }
+  const typelessHoisted = typelessCtx.hoisted.length > 0 ? `${typelessCtx.hoisted.join("\n")}
+
+` : "";
+  return [
+    `${typelessHoisted}export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+    `  let errors: ValidationError[] | undefined`,
+    typelessChecks.join("\n").replaceAll("errors.push(", "(errors ??= []).push("),
+    `  return errors !== undefined ? { valid: false, errors } : true`,
+    `}`
+  ].join("\n");
 };
-const assertNoUnsupportedKeywords = (schema, typeName) => {
-  const visit = (node) => {
-    if (typeof node !== "object" || node === null)
-      return;
-    if (Array.isArray(node)) {
-      for (const item of node)
-        visit(item);
-      return;
-    }
-    const record = node;
-    for (const keyword of ["unevaluatedProperties", "unevaluatedItems"]) {
-      if (keyword in record && record[keyword] !== true) {
-        throw new Error(`[${typeName}] unsupported keyword "${keyword}": the validator generator does not implement it and would silently accept documents the interpreter rejects. Validate this schema with the runtime interpreter, or remove the keyword.`);
-      }
-    }
-    for (const value of Object.values(record))
-      visit(value);
-  };
-  visit(schema);
+const generateUnevaluatedRootValidator = (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 hoistedBlock = ctx.hoisted.length > 0 ? `${ctx.hoisted.join("\n")}
+
+` : "";
+  return [
+    `${hoistedBlock}export const ${validatorName(typeName)} = (input: unknown, _path = ''): ValidationResult => {`,
+    `  let errors: ValidationError[] | undefined`,
+    body,
+    `  return errors !== undefined ? { valid: false, errors } : true`,
+    `}`
+  ].join("\n");
 };
 const SINGLE_SUBSCHEMA_KEYS = /* @__PURE__ */ new Set([
   "additionalProperties",
@@ -1240,6 +1415,13 @@ const SINGLE_SUBSCHEMA_KEYS = /* @__PURE__ */ new Set([
 ]);
 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;
@@ -1249,37 +1431,43 @@ const rewriteNullable = (node) => {
     if (key === "nullable")
       continue;
     if (SINGLE_SUBSCHEMA_KEYS.has(key)) {
-      out[key] = rewriteNullable(value);
+      defineEntry(out, key, rewriteNullable(value));
     } else if (key === "items") {
-      out[key] = Array.isArray(value) ? value.map(rewriteNullable) : rewriteNullable(value);
+      defineEntry(out, key, Array.isArray(value) ? value.map(rewriteNullable) : rewriteNullable(value));
     } else if (SUBSCHEMA_LIST_KEYS.has(key) && Array.isArray(value)) {
-      out[key] = value.map(rewriteNullable);
+      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))
-        mapped[name] = rewriteNullable(sub);
-      out[key] = 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)) {
-        mapped[name] = Array.isArray(sub) ? sub : rewriteNullable(sub);
+        defineEntry(mapped, name, Array.isArray(sub) ? sub : rewriteNullable(sub));
       }
-      out[key] = mapped;
+      defineEntry(out, key, mapped);
     } else {
-      out[key] = value;
+      defineEntry(out, key, value);
     }
   }
   if (src["nullable"] === true)
     return { anyOf: [{ type: "null" }, out] };
   return out;
 };
-const generateValidatorFunction = (schema, typeName, suffix = "") => {
-  assertNoUnsupportedKeywords(schema, typeName);
+const generateValidatorFunction = (schema, typeName, suffix = "", rootSchema) => {
+  assertGeneratableRefs(schema, typeName);
   const rewritten = rewriteNullable(schema);
-  if (isObjectSchema(rewritten)) {
-    return generateObjectValidator(rewritten, typeName, suffix);
+  const document = rootSchema ?? schema;
+  assertUnevaluatedGeneratable(rewritten, typeName, document, unevaluatedMatcher(suffix, createRootContext(document)));
+  if (carriesUnevaluated(rewritten)) {
+    return generateUnevaluatedRootValidator(rewritten, typeName, suffix, document);
+  }
+  if (declaresObjectType(rewritten)) {
+    return generateObjectValidator(rewritten, typeName, suffix, document);
   }
-  return generateScalarValidator(rewritten, typeName, suffix);
+  return generateScalarValidator(rewritten, typeName, suffix, document);
 };
 export {
   generateBooleanGuard,