@amritk/generate-parsers 0.18.0 → 0.19.0

package/dist/generators/generate-strict-assertion.js

@@ -1,14 +1,116 @@
-import { escapeRegexPattern } from "@amritk/helpers/escape-regex-pattern";
+import { regexLiteral } from "@amritk/helpers/escape-regex-pattern";
 import { getMjstInstanceOf, getMjstPrimitive } from "@amritk/helpers/mjst-extension";
 import { multipleOfFailExpr } from "@amritk/helpers/multiple-of-check";
 import { quoteJsString } from "@amritk/helpers/quote-js-string";
 import { resolveRef } from "@amritk/helpers/resolve-ref";
-import { safeAccessor } from "@amritk/helpers/safe-accessor";
-import { hasConst, hasDependentRequired, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMinItems, hasMinimum, hasMinLength, hasMultipleOf, hasPattern, hasProperties, hasPropertyNames, hasRef, hasRequired, hasType, hasUniqueItems, isSchemaObject } from "@amritk/helpers/schema-guards";
+import { hasOwnCheck, missingCheck, safeAccessor } from "@amritk/helpers/safe-accessor";
+import { hasConst, hasDependentRequired, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMaxProperties, hasMinItems, hasMinimum, hasMinLength, hasMinProperties, hasMultipleOf, hasPattern, hasProperties, hasPropertyNames, hasRef, hasRequired, hasType, hasUniqueItems, isSchemaObject } from "@amritk/helpers/schema-guards";
+import { maxLengthFailExpr, minLengthFailExpr } from "@amritk/helpers/string-length-check";
+import { generateDeepEqualCheck } from "./generate-deep-equal-check.js";
 import { generateEnumCheck } from "./generate-enum-check.js";
-import { canEnforceUnion, generateUnionCheck, getUnionBranches, isInlineObjectProperty, multiTypeCheck } from "./generate-type-checks.js";
-import { getPrefixItems, prefixItemsCapsLength, scalarItemTypeCheck } from "./generate-validation-expression.js";
-import { subschemaMatchExpr } from "./subschema-match.js";
+import { canEnforceUnion, generateUnionCheck, getUnionBranches, isExclusiveUnion, isInlineObjectProperty, multiTypeCheck } from "./generate-type-checks.js";
+import { generateUniqueItemsCheck } from "./generate-unique-items-check.js";
+import { everyTailItem, getPrefixItems, prefixItemsCapsLength, scalarItemTypeCheck } from "./generate-validation-expression.js";
+import { hasConstrainingRefSibling, subschemaMatchExpr } from "./subschema-match.js";
+const matchContext = (context) => context.rootSchema ? { rootSchema: context.rootSchema } : {};
+const TYPELESS_CONSTRAINT_KEYWORDS = [
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "multipleOf",
+  "minLength",
+  "maxLength",
+  "pattern",
+  "minItems",
+  "maxItems",
+  "uniqueItems",
+  "items",
+  "prefixItems",
+  "contains"
+];
+const TYPELESS_OBJECT_KEYWORDS = [
+  "required",
+  "minProperties",
+  "maxProperties",
+  "propertyNames",
+  "patternProperties",
+  "additionalProperties",
+  "dependentRequired",
+  "dependentSchemas"
+];
+const backstopReason = (schema, context) => {
+  if (!isSchemaObject(schema))
+    return null;
+  const record = schema;
+  if ("unevaluatedProperties" in record && record["unevaluatedProperties"] !== true)
+    return "unevaluatedProperties";
+  if ("unevaluatedItems" in record && record["unevaluatedItems"] !== true)
+    return "unevaluatedItems";
+  if (hasRef(schema) && (!context.useRefImports || hasConstrainingRefSibling(schema)))
+    return "$ref";
+  if (record["items"] === false && !Array.isArray(record["prefixItems"]))
+    return "items";
+  if (!("type" in record)) {
+    if (TYPELESS_CONSTRAINT_KEYWORDS.some((keyword) => keyword in record))
+      return "constraints";
+    if (!("properties" in record) && TYPELESS_OBJECT_KEYWORDS.some((keyword) => keyword in record))
+      return "constraints";
+    return null;
+  }
+  if (Array.isArray(record["type"])) {
+    const nonNull = record["type"].filter((type) => type !== "null");
+    const constrains = TYPELESS_CONSTRAINT_KEYWORDS.some((keyword) => keyword in record) || TYPELESS_OBJECT_KEYWORDS.some((keyword) => keyword in record);
+    if (nonNull.length > 1 && constrains)
+      return "constraints";
+  }
+  return null;
+};
+const backstopSchema = (schema, reason) => {
+  if (reason !== "constraints" && reason !== "items")
+    return schema;
+  const record = schema;
+  const residual = {};
+  for (const keyword of [
+    "type",
+    ...TYPELESS_CONSTRAINT_KEYWORDS,
+    ...TYPELESS_OBJECT_KEYWORDS,
+    "minContains",
+    "maxContains"
+  ]) {
+    if (keyword in record)
+      residual[keyword] = record[keyword];
+  }
+  if ("additionalProperties" in residual && "properties" in record) {
+    const properties = record["properties"];
+    if (typeof properties === "object" && properties !== null && !Array.isArray(properties)) {
+      residual["properties"] = Object.fromEntries(Object.keys(properties).map((k) => [k, true]));
+    }
+  }
+  return residual;
+};
+const backstopMessage = (reason, label) => {
+  switch (reason) {
+    case "unevaluatedProperties":
+      return `${label} must NOT have unevaluated properties`;
+    case "unevaluatedItems":
+      return `${label} must NOT have unevaluated items`;
+    case "$ref":
+      return `${label} does not satisfy the referenced schema`;
+    default:
+      return `${label} does not satisfy the schema`;
+  }
+};
+const generateBackstopAssertion = (acc, schema, label, context, optional = false) => {
+  const reason = backstopReason(schema, context);
+  if (reason === null)
+    return [];
+  const match = subschemaMatchExpr(acc, backstopSchema(schema, reason), matchContext(context));
+  if (match === null || match === "true")
+    return [];
+  const failure = throwError(backstopMessage(reason, label));
+  return [optional ? `  if (${acc} !== undefined && !(${match})) ${failure};` : `  if (!(${match})) ${failure};`];
+};
 const wrongTypeCondition = (accessor, type) => {
   switch (type) {
     case "string":
@@ -41,28 +143,28 @@ const generateConstraintChecks = (acc, propSchema, field, context = {}) => {
   const lines = [];
   if (t === "string") {
     if (hasPattern(propSchema)) {
-      const pattern = escapeRegexPattern(propSchema.pattern);
-      lines.push(`  if (typeof ${acc} === "string" && !/${pattern}/.test(${acc})) ${throwError(`${field} must match pattern ${propSchema.pattern}`)};`);
+      const patternLiteral = regexLiteral(propSchema.pattern);
+      lines.push(`  if (typeof ${acc} === "string" && !${patternLiteral}.test(${acc})) ${throwError(`${field} must match pattern ${propSchema.pattern}`)};`);
     }
     if (hasMinLength(propSchema)) {
-      lines.push(`  if (typeof ${acc} === "string" && ${acc}.length < ${propSchema.minLength}) ${throwError(`${field} must have at least ${propSchema.minLength} characters`)};`);
+      lines.push(`  if (typeof ${acc} === "string" && ${minLengthFailExpr(acc, propSchema.minLength)}) ${throwError(`${field} must have at least ${propSchema.minLength} characters`)};`);
     }
     if (hasMaxLength(propSchema)) {
-      lines.push(`  if (typeof ${acc} === "string" && ${acc}.length > ${propSchema.maxLength}) ${throwError(`${field} must have at most ${propSchema.maxLength} characters`)};`);
+      lines.push(`  if (typeof ${acc} === "string" && ${maxLengthFailExpr(acc, propSchema.maxLength)}) ${throwError(`${field} must have at most ${propSchema.maxLength} characters`)};`);
     }
   }
   if (t === "number" || t === "integer") {
     if (hasMinimum(propSchema)) {
-      lines.push(`  if (typeof ${acc} === "number" && ${acc} < ${propSchema.minimum}) ${throwError(`${field} must be >= ${propSchema.minimum}`)};`);
+      lines.push(`  if (typeof ${acc} === "number" && !(${acc} >= ${propSchema.minimum})) ${throwError(`${field} must be >= ${propSchema.minimum}`)};`);
     }
     if (hasMaximum(propSchema)) {
-      lines.push(`  if (typeof ${acc} === "number" && ${acc} > ${propSchema.maximum}) ${throwError(`${field} must be <= ${propSchema.maximum}`)};`);
+      lines.push(`  if (typeof ${acc} === "number" && !(${acc} <= ${propSchema.maximum})) ${throwError(`${field} must be <= ${propSchema.maximum}`)};`);
     }
     if (hasExclusiveMinimum(propSchema)) {
-      lines.push(`  if (typeof ${acc} === "number" && ${acc} <= ${propSchema.exclusiveMinimum}) ${throwError(`${field} must be > ${propSchema.exclusiveMinimum}`)};`);
+      lines.push(`  if (typeof ${acc} === "number" && !(${acc} > ${propSchema.exclusiveMinimum})) ${throwError(`${field} must be > ${propSchema.exclusiveMinimum}`)};`);
     }
     if (hasExclusiveMaximum(propSchema)) {
-      lines.push(`  if (typeof ${acc} === "number" && ${acc} >= ${propSchema.exclusiveMaximum}) ${throwError(`${field} must be < ${propSchema.exclusiveMaximum}`)};`);
+      lines.push(`  if (typeof ${acc} === "number" && !(${acc} < ${propSchema.exclusiveMaximum})) ${throwError(`${field} must be < ${propSchema.exclusiveMaximum}`)};`);
     }
     if (hasMultipleOf(propSchema)) {
       lines.push(`  if (typeof ${acc} === "number" && ${multipleOfFailExpr(acc, propSchema.multipleOf)}) ${throwError(`${field} must be a multiple of ${propSchema.multipleOf}`)};`);
@@ -76,17 +178,33 @@ const generateConstraintChecks = (acc, propSchema, field, context = {}) => {
       lines.push(`  if (Array.isArray(${acc}) && ${acc}.length > ${propSchema.maxItems}) ${throwError(`${field} must have at most ${propSchema.maxItems} items`)};`);
     }
     if (hasUniqueItems(propSchema) && propSchema.uniqueItems === true) {
-      lines.push(`  if (Array.isArray(${acc}) && new Set(${acc}.map((_u) => JSON.stringify(_u))).size !== ${acc}.length) ${throwError(`${field} must NOT have duplicate items`)};`);
+      lines.push(`  if (Array.isArray(${acc}) && !(${generateUniqueItemsCheck(acc, propSchema)})) ${throwError(`${field} must NOT have duplicate items`)};`);
     }
-    const itemCheck = generateItemCheck(propSchema);
+    const itemCheck = generateItemCheck(propSchema, context);
     if (itemCheck) {
-      lines.push(`  if (Array.isArray(${acc}) && !${acc}.every((_it) => ${itemCheck.check})) ${throwError(`${field} ${itemCheck.message}`)};`);
+      lines.push(`  if (Array.isArray(${acc}) && !${everyTailItem(acc, itemCheck.check, propSchema)}) ${throwError(`${field} ${itemCheck.message}`)};`);
     }
-    lines.push(...generatePrefixItemsAssertion(acc, field, propSchema, context.rootSchema));
+    lines.push(...generatePrefixItemsAssertion(acc, field, propSchema, context));
+  }
+  if (t === "object") {
+    lines.push(...generateObjectSizeChecks(acc, propSchema, field, true));
+  }
+  return lines;
+};
+const generateObjectSizeChecks = (acc, schema, label, guard) => {
+  if (!isSchemaObject(schema))
+    return [];
+  const lines = [];
+  const prefix = guard ? `isObject(${acc}) && ` : "";
+  if (hasMinProperties(schema)) {
+    lines.push(`  if (${prefix}Object.keys(${acc}).length < ${schema.minProperties}) ${throwError(`${label} must have at least ${schema.minProperties} properties`)};`);
+  }
+  if (hasMaxProperties(schema)) {
+    lines.push(`  if (${prefix}Object.keys(${acc}).length > ${schema.maxProperties}) ${throwError(`${label} must have at most ${schema.maxProperties} properties`)};`);
   }
   return lines;
 };
-const generateItemCheck = (schema) => {
+const generateItemCheck = (schema, context) => {
   if (!isSchemaObject(schema) || !hasItems(schema) || Array.isArray(schema.items))
     return null;
   const items = schema.items;
@@ -95,17 +213,175 @@ const generateItemCheck = (schema) => {
     return { check: generateEnumCheck("_it", items.enum), message: `items must be one of: ${label}` };
   }
   const scalarCheck = scalarItemTypeCheck(items, "_it");
-  if (scalarCheck === null || !isSchemaObject(items) || !hasType(items))
+  if (scalarCheck !== null && isSchemaObject(items) && hasType(items)) {
+    return { check: scalarCheck, message: `items expected ${typeLabel(items.type)}` };
+  }
+  if (hasRef(items) && context.useRefImports === true || isInlineObjectProperty(items))
+    return null;
+  const match = subschemaMatchExpr("_it", items, matchContext(context));
+  if (match === null || match === "true")
+    return null;
+  return { check: match, message: "items do not match the item schema" };
+};
+const nullableObjectShapeChecks = (acc, schema, type, label, optional, context) => {
+  if (type !== "object")
+    return [];
+  const match = subschemaMatchExpr(acc, { ...schema, type: "object" }, matchContext(context));
+  if (match === null || match === "true")
+    return [];
+  const presence = optional ? `${acc} !== undefined && ${acc} !== null` : `${acc} !== null`;
+  return [`  if (${presence} && !(${match})) ${throwError(`${label} does not match the declared object shape`)};`];
+};
+const generateNotCheck = (acc, schema, label, optional, context) => {
+  if (!isSchemaObject(schema) || !("not" in schema))
+    return [];
+  const match = subschemaMatchExpr(acc, schema["not"], matchContext(context));
+  if (match === null || match === "false")
+    return [];
+  const failure = throwError(`${label} must NOT match the excluded schema`);
+  return [optional ? `  if (${acc} !== undefined && (${match})) ${failure};` : `  if (${match}) ${failure};`];
+};
+const generateAllOfChecks = (acc, schema, label, optional, context, skipInlineMembers = false) => {
+  if (!isSchemaObject(schema) || !Array.isArray(schema.allOf))
+    return [];
+  const handledInline = new Set(skipInlineMembers ? inlineAllOfMembers(schema) : []);
+  const lines = [];
+  for (const member of schema.allOf) {
+    if (handledInline.has(member))
+      continue;
+    const delegated = context.useRefImports === true && hasProperties(schema) && !hasConstrainingRefSibling(member);
+    if (isSchemaObject(member) && hasRef(member) && delegated)
+      continue;
+    const match = subschemaMatchExpr(acc, member, matchContext(context));
+    if (match === null || match === "true")
+      continue;
+    const failure = throwError(`${label} does not satisfy all of the declared schemas`);
+    lines.push(optional ? `  if (${acc} !== undefined && !(${match})) ${failure};` : `  if (!(${match})) ${failure};`);
+  }
+  return lines;
+};
+const flatUnionCheck = (acc, schema, context) => {
+  const branches = getUnionBranches(schema);
+  if (branches === null || context.stripUnknown === true)
+    return null;
+  if (!canEnforceUnion(branches, context.rootSchema))
     return null;
-  return { check: scalarCheck, message: `items expected ${typeLabel(items.type)}` };
+  return generateUnionCheck(acc, branches, context.useRefImports ?? false, context.suffix ?? "", isExclusiveUnion(schema));
+};
+const generateUnionMatchChecks = (acc, schema, label, optional, context) => {
+  if (!isSchemaObject(schema))
+    return [];
+  const record = schema;
+  const covered = flatUnionCheck(acc, schema, context) === null ? void 0 : isExclusiveUnion(schema) ? "oneOf" : "anyOf";
+  const lines = [];
+  for (const keyword of ["anyOf", "oneOf"]) {
+    if (keyword === covered)
+      continue;
+    const members = record[keyword];
+    if (!Array.isArray(members) || members.length === 0)
+      continue;
+    const matches = [];
+    for (const member of members) {
+      const match = subschemaMatchExpr(acc, member, matchContext(context));
+      if (match === null)
+        break;
+      matches.push(match);
+    }
+    if (matches.length !== members.length)
+      continue;
+    const check = unionMatchExpr(keyword, matches);
+    if (check === null || check === "true")
+      continue;
+    const failure = throwError(`${label} does not match ${keyword === "anyOf" ? "any of" : "exactly one of"} the declared schemas`);
+    lines.push(optional ? `  if (${acc} !== undefined && !(${check})) ${failure};` : `  if (!(${check})) ${failure};`);
+  }
+  return lines;
+};
+const unionMatchExpr = (keyword, matches) => {
+  if (keyword === "anyOf") {
+    if (matches.includes("true"))
+      return null;
+    return matches.length === 1 ? matches[0] : `(${matches.join(" || ")})`;
+  }
+  if (matches.length === 1)
+    return matches[0];
+  return `((${matches.map((match) => `(${match} ? 1 : 0)`).join(" + ")}) === 1)`;
+};
+const generateConditionalChecks = (acc, schema, label, context) => {
+  if (!isSchemaObject(schema))
+    return [];
+  const record = schema;
+  if (!("if" in record) || !("then" in record) && !("else" in record))
+    return [];
+  const ifMatch = subschemaMatchExpr(acc, record["if"], matchContext(context));
+  if (ifMatch === null)
+    return [];
+  const lines = [];
+  if ("then" in record) {
+    const thenMatch = subschemaMatchExpr(acc, record["then"], matchContext(context));
+    if (thenMatch === null)
+      return [];
+    if (thenMatch !== "true") {
+      lines.push(`  if ((${ifMatch}) && !(${thenMatch})) ${throwError(`${label} does not satisfy the 'then' schema`)};`);
+    }
+  }
+  if ("else" in record) {
+    const elseMatch = subschemaMatchExpr(acc, record["else"], matchContext(context));
+    if (elseMatch === null)
+      return [];
+    if (elseMatch !== "true") {
+      lines.push(`  if (!(${ifMatch}) && !(${elseMatch})) ${throwError(`${label} does not satisfy the 'else' schema`)};`);
+    }
+  }
+  return lines;
 };
-const generateContainsCheck = (acc, schema, label) => {
+const generateKeyedValueChecks = (obj, schema, label, context = {}) => {
+  if (!isSchemaObject(schema))
+    return [];
+  const record = schema;
+  const patternEntries = [];
+  const patternSource = record["patternProperties"];
+  if (typeof patternSource === "object" && patternSource !== null && !Array.isArray(patternSource)) {
+    for (const [pattern, sub] of Object.entries(patternSource)) {
+      const match = subschemaMatchExpr("_v", sub, matchContext(context));
+      if (match === null || match === "true")
+        continue;
+      patternEntries.push([pattern, match]);
+    }
+  }
+  const allPatterns = typeof patternSource === "object" && patternSource !== null && !Array.isArray(patternSource) ? Object.keys(patternSource) : [];
+  const additional = record["additionalProperties"];
+  const additionalMatch = additional !== void 0 && typeof additional !== "boolean" ? subschemaMatchExpr("_v", additional, matchContext(context)) : null;
+  const lines = [];
+  for (const [pattern, match] of patternEntries) {
+    lines.push(`    if (${regexLiteral(pattern)}.test(_k) && !(${match})) ${throwError(`${label} invalid value for property `, "_k")};`);
+  }
+  if (additionalMatch !== null && additionalMatch !== "true") {
+    const declared = hasProperties(schema) ? Object.keys(schema.properties) : [];
+    const guards = [];
+    if (declared.length > 0)
+      guards.push(`!${JSON.stringify(declared)}.includes(_k)`);
+    for (const pattern of allPatterns)
+      guards.push(`!${regexLiteral(pattern)}.test(_k)`);
+    const prefix = guards.length > 0 ? `${guards.join(" && ")} && ` : "";
+    lines.push(`    if (${prefix}!(${additionalMatch})) ${throwError(`${label} invalid value for property `, "_k")};`);
+  }
+  if (lines.length === 0)
+    return [];
+  return [
+    `  for (const _k of Object.keys(${obj})) {`,
+    `    const _v = (${obj} as Record<string, unknown>)[_k];`,
+    ...lines,
+    `  }`
+  ];
+};
+const generateContainsCheck = (acc, schema, label, context = {}) => {
   if (!isSchemaObject(schema))
     return [];
   const sp = schema;
   if (!("contains" in sp))
     return [];
-  const match = subschemaMatchExpr("_c", sp["contains"]);
+  const match = subschemaMatchExpr("_c", sp["contains"], matchContext(context));
   if (match === null)
     return [];
   const min = typeof sp["minContains"] === "number" ? sp["minContains"] : 1;
@@ -126,12 +402,12 @@ const generateDependentRequiredChecks = (obj, schema, label) => {
     if (!Array.isArray(deps))
       continue;
     for (const dep of deps) {
-      lines.push(`  if (${JSON.stringify(trigger)} in ${obj} && !(${JSON.stringify(dep)} in ${obj})) ${throwError(`${label} must have property '${dep}' when '${trigger}' is present`)};`);
+      lines.push(`  if (${hasOwnCheck(obj, trigger)} && ${missingCheck(obj, dep)}) ${throwError(`${label} must have property '${dep}' when '${trigger}' is present`)};`);
     }
   }
   return lines;
 };
-const generateDependentSchemasChecks = (obj, schema, label) => {
+const generateDependentSchemasChecks = (obj, schema, label, context) => {
   const dep = schema["dependentSchemas"];
   if (typeof dep !== "object" || dep === null || Array.isArray(dep))
     return [];
@@ -140,13 +416,13 @@ const generateDependentSchemasChecks = (obj, schema, label) => {
     if (sub === true)
       continue;
     if (sub === false) {
-      lines.push(`  if (${JSON.stringify(trigger)} in ${obj}) ${throwError(`${label} must NOT have property '${trigger}'`)};`);
+      lines.push(`  if (${hasOwnCheck(obj, trigger)}) ${throwError(`${label} must NOT have property '${trigger}'`)};`);
       continue;
     }
-    const match = subschemaMatchExpr(obj, sub);
+    const match = subschemaMatchExpr(obj, sub, matchContext(context));
     if (match === null || match === "true")
       continue;
-    lines.push(`  if (${JSON.stringify(trigger)} in ${obj} && !(${match})) ${throwError(`${label} does not satisfy the schema required when '${trigger}' is present`)};`);
+    lines.push(`  if (${hasOwnCheck(obj, trigger)} && !(${match})) ${throwError(`${label} does not satisfy the schema required when '${trigger}' is present`)};`);
   }
   return lines;
 };
@@ -158,7 +434,8 @@ const resolvePositionSchema = (pos, rootSchema) => {
   }
   return pos;
 };
-const generatePrefixItemsAssertion = (acc, field, schema, rootSchema) => {
+const generatePrefixItemsAssertion = (acc, field, schema, context) => {
+  const rootSchema = context.rootSchema;
   const prefix = getPrefixItems(schema);
   if (!prefix)
     return [];
@@ -168,9 +445,8 @@ const generatePrefixItemsAssertion = (acc, field, schema, rootSchema) => {
     const el = `${acc}[${i}]`;
     const present = `Array.isArray(${acc}) && ${acc}.length > ${i}`;
     if (isSchemaObject(pos) && hasEnum(pos) && pos.enum.length > 0) {
-      const allowed = JSON.stringify(pos.enum);
       const label = pos.enum.map((v) => JSON.stringify(v)).join(", ");
-      lines.push(`  if (${present} && !(${allowed} as readonly unknown[]).includes(${el})) ${throwError(`${field}[${i}] must be one of: ${label}`)};`);
+      lines.push(`  if (${present} && !${generateEnumCheck(el, pos.enum)}) ${throwError(`${field}[${i}] must be one of: ${label}`)};`);
       continue;
     }
     if (isSchemaObject(pos) && hasType(pos)) {
@@ -180,16 +456,20 @@ const generatePrefixItemsAssertion = (acc, field, schema, rootSchema) => {
         lines.push(`  if (${present} && (${wrong})) ${throwError(`${field}[${i}] expected ${typeLabel(pt)}, got `, `typeof ${el}`)};`);
       }
     }
+    const match = subschemaMatchExpr(el, prefix[i], matchContext(context));
+    if (match !== null && match !== "true") {
+      lines.push(`  if (${present} && !(${match})) ${throwError(`${field}[${i}] does not match the tuple schema`)};`);
+    }
   }
   if (prefixItemsCapsLength(schema)) {
     lines.push(`  if (Array.isArray(${acc}) && ${acc}.length > ${prefix.length}) ${throwError(`${field} must NOT have more than ${prefix.length} items`)};`);
   }
   return lines;
 };
-const generatePropertyNameChecks = (obj, schema, label) => {
+const generatePropertyNameChecks = (obj, schema, label, context) => {
   if (!hasPropertyNames(schema) || !isSchemaObject(schema.propertyNames))
     return [];
-  const match = subschemaMatchExpr("_name", schema.propertyNames);
+  const match = subschemaMatchExpr("_name", schema.propertyNames, matchContext(context));
   if (match === null || match === "true")
     return [];
   return [
@@ -198,13 +478,19 @@ const generatePropertyNameChecks = (obj, schema, label) => {
     `  }`
   ];
 };
-const generateObjectKeywordChecks = (obj, schema, label, guard) => {
+const generateCompositionChecks = (acc, schema, label, context = {}) => [
+  ...generateNotCheck(acc, schema, label, false, context),
+  ...generateAllOfChecks(acc, schema, label, false, context),
+  ...generateUnionMatchChecks(acc, schema, label, false, context),
+  ...generateConditionalChecks(acc, schema, label, context)
+];
+const generateObjectKeywordChecks = (obj, schema, label, guard, context = {}) => {
   if (!isSchemaObject(schema))
     return [];
   const inner = [
     ...generateDependentRequiredChecks(obj, schema, label),
-    ...generateDependentSchemasChecks(obj, schema, label),
-    ...generatePropertyNameChecks(obj, schema, label)
+    ...generateDependentSchemasChecks(obj, schema, label, context),
+    ...generatePropertyNameChecks(obj, schema, label, context)
   ];
   if (inner.length === 0)
     return [];
@@ -217,16 +503,25 @@ const generatePropertyAssertion = (key, propSchema, isRequired, typeName, contex
   const field = `[${typeName}] field '${key}'`;
   const lines = [];
   if (isRequired) {
-    lines.push(`  if (!(${JSON.stringify(key)} in input)) ${throwError(`[${typeName}] missing required property '${key}'`)};`);
+    lines.push(`  if (${missingCheck("input", key)}) ${throwError(`[${typeName}] missing required property '${key}'`)};`);
+  }
+  if (propSchema === false) {
+    lines.push(`  if (${hasOwnCheck("input", key)}) ${throwError(`[${typeName}] must NOT have property '${key}'`)};`);
+    return lines;
   }
   if (!isSchemaObject(propSchema))
     return lines;
+  lines.push(...generateBackstopAssertion(acc, propSchema, field, context, !isRequired));
   if (hasRef(propSchema))
     return lines;
+  lines.push(...generateNotCheck(acc, propSchema, field, !isRequired, context));
+  lines.push(...generateAllOfChecks(acc, propSchema, field, !isRequired, context));
+  lines.push(...generateUnionMatchChecks(acc, propSchema, field, !isRequired, context));
+  lines.push(...generateConditionalChecks(acc, propSchema, field, context));
   const unionBranches = getUnionBranches(propSchema);
   if (unionBranches) {
     if (!context.stripUnknown && canEnforceUnion(unionBranches, context.rootSchema)) {
-      const check = generateUnionCheck(acc, unionBranches, context.useRefImports ?? false, context.suffix ?? "");
+      const check = generateUnionCheck(acc, unionBranches, context.useRefImports ?? false, context.suffix ?? "", isExclusiveUnion(propSchema));
       if (check !== null) {
         const failure = throwError(`${field} does not match any allowed variant`);
         lines.push(isRequired ? `  if (!(${check})) ${failure};` : `  if (${acc} !== undefined && !(${check})) ${failure};`);
@@ -252,13 +547,19 @@ const generatePropertyAssertion = (key, propSchema, isRequired, typeName, contex
     }
     return lines;
   }
+  if (hasConst(propSchema)) {
+    const equal = generateDeepEqualCheck(acc, propSchema.const);
+    const failure = throwError(`${field} must be ${JSON.stringify(propSchema.const)}`);
+    lines.push(isRequired ? `  if (!(${equal})) ${failure};` : `  if (${acc} !== undefined && !(${equal})) ${failure};`);
+    return lines;
+  }
   if (hasEnum(propSchema)) {
-    const allowed = JSON.stringify(propSchema.enum);
+    const member = generateEnumCheck(acc, propSchema.enum);
     const label = propSchema.enum.map((v) => JSON.stringify(v)).join(", ");
     if (isRequired) {
-      lines.push(`  if (!(${allowed} as readonly unknown[]).includes(${acc})) ${throwError(`${field} must be one of: ${label}`)};`);
+      lines.push(`  if (!${member}) ${throwError(`${field} must be one of: ${label}`)};`);
     } else {
-      lines.push(`  if (${acc} !== undefined && !(${allowed} as readonly unknown[]).includes(${acc})) ${throwError(`${field} must be one of: ${label}`)};`);
+      lines.push(`  if (${acc} !== undefined && !${member}) ${throwError(`${field} must be one of: ${label}`)};`);
     }
     return lines;
   }
@@ -272,6 +573,7 @@ const generatePropertyAssertion = (key, propSchema, isRequired, typeName, contex
     const nonNull = types.filter((type) => type !== "null");
     if (nonNull.length === 1) {
       lines.push(...generateConstraintChecks(acc, { ...propSchema, type: nonNull[0] }, field, context));
+      lines.push(...nullableObjectShapeChecks(acc, propSchema, nonNull[0], field, !isRequired, context));
     }
     return lines;
   }
@@ -291,9 +593,15 @@ const generatePropertyAssertion = (key, propSchema, isRequired, typeName, contex
   if (isSchemaObject(propSchema)) {
     const r = propSchema;
     if ("contains" in r)
-      lines.push(...generateContainsCheck(acc, propSchema, field));
+      lines.push(...generateContainsCheck(acc, propSchema, field, context));
     if (("dependentRequired" in r || "dependentSchemas" in r || "propertyNames" in r) && !isInlineObjectProperty(propSchema)) {
-      lines.push(...generateObjectKeywordChecks(acc, propSchema, field, true));
+      lines.push(...generateObjectKeywordChecks(acc, propSchema, field, true, context));
+    }
+    if ("patternProperties" in r || isSchemaObject(propSchema) && typeof r["additionalProperties"] === "object") {
+      const keyed = generateKeyedValueChecks(acc, propSchema, field, context);
+      if (keyed.length > 0) {
+        lines.push(`  if (isObject(${acc})) {`, ...keyed.map((line) => `  ${line}`), `  }`);
+      }
     }
   }
   return lines;
@@ -327,18 +635,27 @@ const generateObjectStrictAssertion = (schema, typeName, context = {}) => {
       required.delete(key);
   }
   for (const key of required) {
-    lines.push(`  if (!(${JSON.stringify(key)} in input)) ${throwError(`[${typeName}] missing required property '${key}'`)};`);
+    lines.push(`  if (${missingCheck("input", key)}) ${throwError(`[${typeName}] missing required property '${key}'`)};`);
   }
   for (const member of inlineAllOfMembers(schema)) {
     lines.push(...generateObjectStrictAssertion(member, typeName, context).slice(1));
   }
   const sr = schema;
   if ("dependentRequired" in sr || "dependentSchemas" in sr || "propertyNames" in sr) {
-    lines.push(...generateObjectKeywordChecks("input", schema, `[${typeName}]`, false));
+    lines.push(...generateObjectKeywordChecks("input", schema, `[${typeName}]`, false, context));
   }
+  lines.push(...generateObjectSizeChecks("input", schema, `[${typeName}]`, false));
+  lines.push(...generateNotCheck("input", schema, `[${typeName}]`, false, context));
+  lines.push(...generateAllOfChecks("input", schema, `[${typeName}]`, false, context, true));
+  lines.push(...generateUnionMatchChecks("input", schema, `[${typeName}]`, false, context));
+  lines.push(...generateConditionalChecks("input", schema, `[${typeName}]`, context));
+  lines.push(...generateKeyedValueChecks("input", schema, `[${typeName}]`, context));
+  lines.push(...generateBackstopAssertion("input", schema, `[${typeName}]`, context));
   return lines;
 };
-const generateScalarStrictAssertion = (schema, typeName, rootSchema) => {
+const generateScalarStrictAssertion = (schema, typeName, context = {}) => {
+  if (schema === false)
+    return `  ${throwError(`[${typeName}] schema is false: no value is valid`)};`;
   const got = 'input === null ? "null" : typeof input';
   const instanceOf = getMjstInstanceOf(schema);
   if (instanceOf) {
@@ -353,13 +670,15 @@ const generateScalarStrictAssertion = (schema, typeName, rootSchema) => {
   const label = `[${typeName}]`;
   const lines = [];
   if (hasConst(schema)) {
-    const wanted = JSON.stringify(JSON.stringify(schema.const));
-    lines.push(`  if (JSON.stringify(input) !== ${wanted}) ${throwError(`${label} must be ${JSON.stringify(schema.const)}`)};`);
+    lines.push(`  if (!(${generateDeepEqualCheck("input", schema.const)})) ${throwError(`${label} must be ${JSON.stringify(schema.const)}`)};`);
   } else if (hasEnum(schema)) {
-    const allowed = JSON.stringify(schema.enum);
     const enumLabel = schema.enum.map((v) => JSON.stringify(v)).join(", ");
-    lines.push(`  if (!(${allowed} as readonly unknown[]).includes(input)) ${throwError(`${label} must be one of: ${enumLabel}`)};`);
+    lines.push(`  if (!${generateEnumCheck("input", schema.enum)}) ${throwError(`${label} must be one of: ${enumLabel}`)};`);
   }
+  lines.push(...generateNotCheck("input", schema, label, false, context));
+  lines.push(...generateAllOfChecks("input", schema, label, false, context));
+  lines.push(...generateUnionMatchChecks("input", schema, label, false, context));
+  lines.push(...generateConditionalChecks("input", schema, label, context));
   const rootMultiType = multiTypeCheck("input", schema, { ignoreConstraints: true });
   if (rootMultiType !== void 0) {
     const types = schema.type;
@@ -368,8 +687,10 @@ const generateScalarStrictAssertion = (schema, typeName, rootSchema) => {
     }
     const nonNull = types.filter((type) => type !== "null");
     if (nonNull.length === 1) {
-      lines.push(...generateConstraintChecks("input", { ...schema, type: nonNull[0] }, label, rootSchema ? { rootSchema } : {}));
+      lines.push(...generateConstraintChecks("input", { ...schema, type: nonNull[0] }, label, context));
+      lines.push(...nullableObjectShapeChecks("input", schema, nonNull[0], label, false, context));
     }
+    lines.push(...generateBackstopAssertion("input", schema, label, context));
     return lines.length > 0 ? lines.join("\n") : null;
   }
   if (hasType(schema)) {
@@ -379,15 +700,22 @@ const generateScalarStrictAssertion = (schema, typeName, rootSchema) => {
       lines.push(`  if (${wrongType}) ${throwError(`${label} expected ${typeLabel(t)}, got `, got)};`);
     }
     if (t === "array") {
-      lines.push(...generateContainsCheck("input", schema, label));
+      lines.push(...generateContainsCheck("input", schema, label, context));
     }
-    lines.push(...generateConstraintChecks("input", schema, label, rootSchema ? { rootSchema } : {}));
+    lines.push(...generateConstraintChecks("input", schema, label, context));
   }
+  lines.push(...generateBackstopAssertion("input", schema, label, context));
   return lines.length > 0 ? lines.join("\n") : null;
 };
 export {
+  backstopReason,
+  backstopSchema,
+  generateBackstopAssertion,
+  generateCompositionChecks,
   generateContainsCheck,
+  generateKeyedValueChecks,
   generateObjectKeywordChecks,
+  generateObjectSizeChecks,
   generateObjectStrictAssertion,
   generateScalarStrictAssertion,
   inlineAllOfMembers