@amritk/generate-parsers 0.16.2 → 0.17.0

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

@@ -1,487 +1,351 @@
-import { escapeRegexPattern } 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 { generateEnumCheck } from './generate-enum-check.js';
-import { canEnforceUnion, generateUnionCheck, getUnionBranches, isInlineObjectProperty } from './generate-type-checks.js';
-import { getPrefixItems, prefixItemsCapsLength, scalarItemTypeCheck } from './generate-validation-expression.js';
-import { subschemaMatchExpr } from './subschema-match.js';
-/**
- * Returns the inline condition that is true when `accessor` is the wrong type
- * for the given JSON Schema primitive type.
- */
+import { escapeRegexPattern } 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 { generateEnumCheck } from "./generate-enum-check.js";
+import { canEnforceUnion, generateUnionCheck, getUnionBranches, isInlineObjectProperty } from "./generate-type-checks.js";
+import { getPrefixItems, prefixItemsCapsLength, scalarItemTypeCheck } from "./generate-validation-expression.js";
+import { subschemaMatchExpr } from "./subschema-match.js";
 const wrongTypeCondition = (accessor, type) => {
-    switch (type) {
-        case 'string':
-            return `typeof ${accessor} !== "string"`;
-        case 'number':
-            return `typeof ${accessor} !== "number"`;
-        case 'integer':
-            // `integer` also rejects non-integral numbers; a bare typeof accepts `1.5`.
-            return `(typeof ${accessor} !== "number" || !Number.isInteger(${accessor}))`;
-        case 'boolean':
-            return `typeof ${accessor} !== "boolean"`;
-        case 'null':
-            // Missing from this switch historically, which meant a null-typed
-            // property was never enforced on the assertion path — the strict-mode
-            // differential fuzzer caught non-null values sailing through.
-            return `${accessor} !== null`;
-        case 'array':
-            return `!Array.isArray(${accessor})`;
-        case 'object':
-            return `!isObject(${accessor})`;
-        default:
-            return null;
-    }
+  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 "null":
+      return `${accessor} !== null`;
+    case "array":
+      return `!Array.isArray(${accessor})`;
+    case "object":
+      return `!isObject(${accessor})`;
+    default:
+      return null;
+  }
 };
-/**
- * Maps a JSON Schema type to the label used in error messages.
- * `integer` collapses to `number` since both are validated via `typeof === "number"`.
- */
-const typeLabel = (type) => (type === 'integer' ? 'number' : type);
-/**
- * Emits `throw new Error(<message>[ + <suffixExpr>])`. The static message may
- * contain schema-controlled text (property names, patterns, enum values), so
- * it goes through the shared {@link quoteJsString} escape-or-quote decision.
- * `suffixExpr`, when given, is a runtime expression appended to the message
- * (e.g. `typeof input`).
- */
+const typeLabel = (type) => type === "integer" ? "number" : type;
 const throwError = (message, suffixExpr) => {
-    const literal = quoteJsString(message);
-    return suffixExpr ? `throw new Error(${literal} + (${suffixExpr}))` : `throw new Error(${literal})`;
+  const literal = quoteJsString(message);
+  return suffixExpr ? `throw new Error(${literal} + (${suffixExpr}))` : `throw new Error(${literal})`;
 };
-/**
- * Generates strict-mode constraint checks for a typed property
- * (pattern, length, min/max, multipleOf).
- */
 const generateConstraintChecks = (acc, propSchema, field, context = {}) => {
-    if (!isSchemaObject(propSchema) || !hasType(propSchema))
-        return [];
-    const t = propSchema.type;
-    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}`)};`);
-        }
-        if (hasMinLength(propSchema)) {
-            lines.push(`  if (typeof ${acc} === "string" && ${acc}.length < ${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`)};`);
-        }
+  if (!isSchemaObject(propSchema) || !hasType(propSchema))
+    return [];
+  const t = propSchema.type;
+  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}`)};`);
     }
-    if (t === 'number' || t === 'integer') {
-        if (hasMinimum(propSchema)) {
-            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}`)};`);
-        }
-        if (hasExclusiveMinimum(propSchema)) {
-            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}`)};`);
-        }
-        if (hasMultipleOf(propSchema)) {
-            lines.push(`  if (typeof ${acc} === "number" && ${multipleOfFailExpr(acc, propSchema.multipleOf)}) ${throwError(`${field} must be a multiple of ${propSchema.multipleOf}`)};`);
-        }
+    if (hasMinLength(propSchema)) {
+      lines.push(`  if (typeof ${acc} === "string" && ${acc}.length < ${propSchema.minLength}) ${throwError(`${field} must have at least ${propSchema.minLength} characters`)};`);
     }
-    if (t === 'array') {
-        if (hasMinItems(propSchema)) {
-            lines.push(`  if (Array.isArray(${acc}) && ${acc}.length < ${propSchema.minItems}) ${throwError(`${field} must have at least ${propSchema.minItems} items`)};`);
-        }
-        if (hasMaxItems(propSchema)) {
-            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) {
-            // Deep-equality dedupe via JSON keys, matching the interpreter's semantics —
-            // a plain `new Set` would only catch primitive duplicates, not equal objects.
-            lines.push(`  if (Array.isArray(${acc}) && new Set(${acc}.map((_u) => JSON.stringify(_u))).size !== ${acc}.length) ${throwError(`${field} must NOT have duplicate items`)};`);
-        }
-        // Item types: the fast path proves them via `.every`, but this slow path
-        // used to check only length/uniqueness, letting e.g. a number slip into a
-        // declared `string[]`. Enforce scalar and enum item schemas here; richer
-        // item schemas ($refs, objects) are validated by their own parsers.
-        const itemCheck = generateItemCheck(propSchema);
-        if (itemCheck) {
-            lines.push(`  if (Array.isArray(${acc}) && !${acc}.every((_it) => ${itemCheck.check})) ${throwError(`${field} ${itemCheck.message}`)};`);
-        }
-        // Tuple `prefixItems`: assert each position and cap length under items:false.
-        lines.push(...generatePrefixItemsAssertion(acc, field, propSchema, context.rootSchema));
+    if (hasMaxLength(propSchema)) {
+      lines.push(`  if (typeof ${acc} === "string" && ${acc}.length > ${propSchema.maxLength}) ${throwError(`${field} must have at most ${propSchema.maxLength} characters`)};`);
     }
-    return lines;
+  }
+  if (t === "number" || t === "integer") {
+    if (hasMinimum(propSchema)) {
+      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}`)};`);
+    }
+    if (hasExclusiveMinimum(propSchema)) {
+      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}`)};`);
+    }
+    if (hasMultipleOf(propSchema)) {
+      lines.push(`  if (typeof ${acc} === "number" && ${multipleOfFailExpr(acc, propSchema.multipleOf)}) ${throwError(`${field} must be a multiple of ${propSchema.multipleOf}`)};`);
+    }
+  }
+  if (t === "array") {
+    if (hasMinItems(propSchema)) {
+      lines.push(`  if (Array.isArray(${acc}) && ${acc}.length < ${propSchema.minItems}) ${throwError(`${field} must have at least ${propSchema.minItems} items`)};`);
+    }
+    if (hasMaxItems(propSchema)) {
+      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`)};`);
+    }
+    const itemCheck = generateItemCheck(propSchema);
+    if (itemCheck) {
+      lines.push(`  if (Array.isArray(${acc}) && !${acc}.every((_it) => ${itemCheck.check})) ${throwError(`${field} ${itemCheck.message}`)};`);
+    }
+    lines.push(...generatePrefixItemsAssertion(acc, field, propSchema, context.rootSchema));
+  }
+  return lines;
 };
-/**
- * Boolean per-item check (bound to `_it`) for an array schema's `items`, with
- * the error-message fragment describing what was expected. Only scalar types
- * and enums are checked — returns null for anything richer.
- */
 const generateItemCheck = (schema) => {
-    if (!isSchemaObject(schema) || !hasItems(schema) || Array.isArray(schema.items))
-        return null;
-    const items = schema.items;
-    if (isSchemaObject(items) && hasEnum(items) && items.enum.length > 0) {
-        const label = items.enum.map((v) => JSON.stringify(v)).join(', ');
-        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))
-        return null;
-    return { check: scalarCheck, message: `items expected ${typeLabel(items.type)}` };
+  if (!isSchemaObject(schema) || !hasItems(schema) || Array.isArray(schema.items))
+    return null;
+  const items = schema.items;
+  if (isSchemaObject(items) && hasEnum(items) && items.enum.length > 0) {
+    const label = items.enum.map((v) => JSON.stringify(v)).join(", ");
+    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))
+    return null;
+  return { check: scalarCheck, message: `items expected ${typeLabel(items.type)}` };
 };
-/**
- * Strict-mode `contains` / `minContains` / `maxContains`: at least `minContains`
- * (default 1) and at most `maxContains` (default ∞) items of the array must
- * match the `contains` subschema. Runtime-gated on `Array.isArray` so a
- * non-array value is left to the type check, and wrapped in a block so the
- * per-array count variable never collides with a sibling check. `minContains: 0`
- * makes the lower bound trivially satisfied. Emits nothing when there is no
- * `contains` or its subschema is not matchable inline (the generation-time guard
- * rejects the latter, so a strict parser never silently drops the constraint).
- */
-export const generateContainsCheck = (acc, schema, label) => {
-    if (!isSchemaObject(schema))
-        return [];
-    const sp = schema;
-    if (!('contains' in sp))
-        return [];
-    const match = subschemaMatchExpr('_c', sp['contains']);
-    if (match === null)
-        return [];
-    const min = typeof sp['minContains'] === 'number' ? sp['minContains'] : 1;
-    const max = typeof sp['maxContains'] === 'number' ? sp['maxContains'] : undefined;
-    const bound = max !== undefined ? `_cn < ${min} || _cn > ${max}` : `_cn < ${min}`;
-    return [
-        `  if (Array.isArray(${acc})) {`,
-        `    const _cn = (${acc} as unknown[]).filter((_c) => ${match}).length;`,
-        `    if (${bound}) ${throwError(`${label} array does not contain the required matching items`)};`,
-        `  }`,
-    ];
+const generateContainsCheck = (acc, schema, label) => {
+  if (!isSchemaObject(schema))
+    return [];
+  const sp = schema;
+  if (!("contains" in sp))
+    return [];
+  const match = subschemaMatchExpr("_c", sp["contains"]);
+  if (match === null)
+    return [];
+  const min = typeof sp["minContains"] === "number" ? sp["minContains"] : 1;
+  const max = typeof sp["maxContains"] === "number" ? sp["maxContains"] : void 0;
+  const bound = max !== void 0 ? `_cn < ${min} || _cn > ${max}` : `_cn < ${min}`;
+  return [
+    `  if (Array.isArray(${acc})) {`,
+    `    const _cn = (${acc} as unknown[]).filter((_c) => ${match}).length;`,
+    `    if (${bound}) ${throwError(`${label} array does not contain the required matching items`)};`,
+    `  }`
+  ];
 };
-/**
- * Strict-mode `dependentRequired`: when a trigger key is present, every declared
- * dependency key must be present too.
- */
 const generateDependentRequiredChecks = (obj, schema, label) => {
-    if (!hasDependentRequired(schema))
-        return [];
-    const lines = [];
-    for (const [trigger, deps] of Object.entries(schema.dependentRequired)) {
-        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`)};`);
-        }
+  if (!hasDependentRequired(schema))
+    return [];
+  const lines = [];
+  for (const [trigger, deps] of Object.entries(schema.dependentRequired)) {
+    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`)};`);
     }
-    return lines;
+  }
+  return lines;
 };
-/**
- * Strict-mode `dependentSchemas` (2020-12): when a trigger property is present,
- * the *whole object* must also match the associated subschema. A `true`
- * subschema is a no-op; a `false` subschema makes the trigger's presence always
- * invalid. Object subschemas are enforced via {@link subschemaMatchExpr}; a
- * subschema it cannot match inline is rejected at generation time by the guard.
- */
 const generateDependentSchemasChecks = (obj, schema, label) => {
-    const dep = schema['dependentSchemas'];
-    if (typeof dep !== 'object' || dep === null || Array.isArray(dep))
-        return [];
-    const lines = [];
-    for (const [trigger, sub] of Object.entries(dep)) {
-        if (sub === true)
-            continue;
-        if (sub === false) {
-            lines.push(`  if (${JSON.stringify(trigger)} in ${obj}) ${throwError(`${label} must NOT have property '${trigger}'`)};`);
-            continue;
-        }
-        const match = subschemaMatchExpr(obj, sub);
-        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`)};`);
+  const dep = schema["dependentSchemas"];
+  if (typeof dep !== "object" || dep === null || Array.isArray(dep))
+    return [];
+  const lines = [];
+  for (const [trigger, sub] of Object.entries(dep)) {
+    if (sub === true)
+      continue;
+    if (sub === false) {
+      lines.push(`  if (${JSON.stringify(trigger)} in ${obj}) ${throwError(`${label} must NOT have property '${trigger}'`)};`);
+      continue;
     }
-    return lines;
+    const match = subschemaMatchExpr(obj, sub);
+    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`)};`);
+  }
+  return lines;
 };
-/**
- * Resolves a tuple position's schema through a single `$ref` (via `rootSchema`)
- * so the assertion can read its `type`/`enum`. A `$ref` with no resolvable target
- * (or no root document) is returned as-is, leaving the position unasserted.
- */
 const resolvePositionSchema = (pos, rootSchema) => {
-    if (isSchemaObject(pos) && hasRef(pos) && rootSchema) {
-        const resolved = resolveRef(pos.$ref, rootSchema);
-        if (resolved)
-            return resolved;
-    }
-    return pos;
+  if (isSchemaObject(pos) && hasRef(pos) && rootSchema) {
+    const resolved = resolveRef(pos.$ref, rootSchema);
+    if (resolved)
+      return resolved;
+  }
+  return pos;
 };
-/**
- * Strict-mode assertion lines for a tuple `prefixItems`: each present position is
- * asserted against its subschema (a scalar type, an enum, or a `$ref`/inline
- * schema resolved to one via `rootSchema`), and a sibling `items: false` /
- * `additionalItems: false` rejects any extra element. `acc` is the array
- * accessor and `field` the error-message prefix (`[Type] field 'k'` or
- * `[Type]`). Mirrors the validators' tuple pass, but throws on the first
- * violation instead of collecting errors. Positions whose schema is richer than
- * a scalar/enum are left to their own downstream handling (like array `items`).
- */
 const generatePrefixItemsAssertion = (acc, field, schema, rootSchema) => {
-    const prefix = getPrefixItems(schema);
-    if (!prefix)
-        return [];
-    const lines = [];
-    for (let i = 0; i < prefix.length; i++) {
-        const pos = resolvePositionSchema(prefix[i], rootSchema);
-        const el = `${acc}[${i}]`;
-        // A shorter input simply has no element at this position — `prefixItems`
-        // does not require presence (that is `minItems`' job), so guard on length.
-        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}`)};`);
-            continue;
-        }
-        if (isSchemaObject(pos) && hasType(pos)) {
-            const pt = pos.type;
-            const wrong = wrongTypeCondition(el, pt);
-            if (wrong) {
-                lines.push(`  if (${present} && (${wrong})) ${throwError(`${field}[${i}] expected ${typeLabel(pt)}, got `, `typeof ${el}`)};`);
-            }
-        }
+  const prefix = getPrefixItems(schema);
+  if (!prefix)
+    return [];
+  const lines = [];
+  for (let i = 0; i < prefix.length; i++) {
+    const pos = resolvePositionSchema(prefix[i], 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}`)};`);
+      continue;
     }
-    if (prefixItemsCapsLength(schema)) {
-        lines.push(`  if (Array.isArray(${acc}) && ${acc}.length > ${prefix.length}) ${throwError(`${field} must NOT have more than ${prefix.length} items`)};`);
+    if (isSchemaObject(pos) && hasType(pos)) {
+      const pt = pos.type;
+      const wrong = wrongTypeCondition(el, pt);
+      if (wrong) {
+        lines.push(`  if (${present} && (${wrong})) ${throwError(`${field}[${i}] expected ${typeLabel(pt)}, got `, `typeof ${el}`)};`);
+      }
     }
-    return lines;
+  }
+  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;
 };
-/**
- * Strict-mode `propertyNames`: every own key of the object (keys are always
- * strings) must satisfy the name subschema. A trivially-true matcher imposes no
- * constraint, so no loop is emitted; an unmatchable subschema is rejected at
- * generation time by the guard.
- */
 const generatePropertyNameChecks = (obj, schema, label) => {
-    if (!hasPropertyNames(schema) || !isSchemaObject(schema.propertyNames))
-        return [];
-    const match = subschemaMatchExpr('_name', schema.propertyNames);
-    if (match === null || match === 'true')
-        return [];
-    return [
-        `  for (const _name of Object.keys(${obj})) {`,
-        `    if (!(${match})) ${throwError(`${label} invalid property name: `, '_name')};`,
-        `  }`,
-    ];
+  if (!hasPropertyNames(schema) || !isSchemaObject(schema.propertyNames))
+    return [];
+  const match = subschemaMatchExpr("_name", schema.propertyNames);
+  if (match === null || match === "true")
+    return [];
+  return [
+    `  for (const _name of Object.keys(${obj})) {`,
+    `    if (!(${match})) ${throwError(`${label} invalid property name: `, "_name")};`,
+    `  }`
+  ];
 };
-/**
- * Emits the object-level keyword checks (`dependentRequired`, `dependentSchemas`,
- * `propertyNames`) for the object reached by `obj`. When `guard` is true the
- * whole block is wrapped in a runtime `isObject` check — used for object-typed
- * *properties*, whose value may be absent or a non-object (the type check
- * reports that separately). The root object and inline sub-parsers pass
- * `guard = false` because the enclosing parser has already proven the value is
- * an object.
- */
-export const generateObjectKeywordChecks = (obj, schema, label, guard) => {
-    if (!isSchemaObject(schema))
-        return [];
-    const inner = [
-        ...generateDependentRequiredChecks(obj, schema, label),
-        ...generateDependentSchemasChecks(obj, schema, label),
-        ...generatePropertyNameChecks(obj, schema, label),
-    ];
-    if (inner.length === 0)
-        return [];
-    if (!guard)
-        return inner;
-    return [`  if (isObject(${obj})) {`, ...inner.map((line) => `  ${line}`), `  }`];
+const generateObjectKeywordChecks = (obj, schema, label, guard) => {
+  if (!isSchemaObject(schema))
+    return [];
+  const inner = [
+    ...generateDependentRequiredChecks(obj, schema, label),
+    ...generateDependentSchemasChecks(obj, schema, label),
+    ...generatePropertyNameChecks(obj, schema, label)
+  ];
+  if (inner.length === 0)
+    return [];
+  if (!guard)
+    return inner;
+  return [`  if (isObject(${obj})) {`, ...inner.map((line) => `  ${line}`), `  }`];
 };
-/**
- * Generates strict-mode lines for a single property of an object schema.
- * Properties with a `$ref` are skipped here — the nested parser handles its own
- * strict check when called from the parent's slow path.
- */
 const generatePropertyAssertion = (key, propSchema, isRequired, typeName, context = {}) => {
-    const acc = safeAccessor('input', key);
-    const field = `[${typeName}] field '${key}'`;
-    const lines = [];
-    if (isRequired) {
-        lines.push(`  if (!(${JSON.stringify(key)} in input)) ${throwError(`[${typeName}] missing required property '${key}'`)};`);
-    }
-    if (!isSchemaObject(propSchema))
-        return lines;
-    if (hasRef(propSchema))
-        return lines;
-    // Union properties: enforce membership when every branch check is
-    // false-sound (canEnforceUnion), so a value matching no variant throws
-    // instead of passing through untyped. Left unenforced (pass-through, the
-    // historical behavior) when any branch is too complex to check safely.
-    const unionBranches = getUnionBranches(propSchema);
-    if (unionBranches) {
-        if (!context.stripUnknown && canEnforceUnion(unionBranches, context.rootSchema)) {
-            const check = generateUnionCheck(acc, unionBranches, context.useRefImports ?? false, context.suffix ?? '');
-            if (check !== null) {
-                const failure = throwError(`${field} does not match any allowed variant`);
-                lines.push(isRequired ? `  if (!(${check})) ${failure};` : `  if (${acc} !== undefined && !(${check})) ${failure};`);
-            }
-        }
-        return lines;
-    }
-    const instanceOf = getMjstInstanceOf(propSchema);
-    if (instanceOf) {
-        if (isRequired) {
-            lines.push(`  if (!(${acc} instanceof ${instanceOf})) ${throwError(`${field} must be ${instanceOf}`)};`);
-        }
-        else {
-            lines.push(`  if (${acc} !== undefined && !(${acc} instanceof ${instanceOf})) ${throwError(`${field} must be ${instanceOf}`)};`);
-        }
-        return lines;
-    }
-    const primitive = getMjstPrimitive(propSchema);
-    if (primitive) {
-        if (isRequired) {
-            lines.push(`  if (typeof ${acc} !== "${primitive}") ${throwError(`${field} must be ${primitive}`)};`);
-        }
-        else {
-            lines.push(`  if (${acc} !== undefined && typeof ${acc} !== "${primitive}") ${throwError(`${field} must be ${primitive}`)};`);
-        }
-        return lines;
-    }
-    if (hasEnum(propSchema)) {
-        const allowed = JSON.stringify(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}`)};`);
-        }
-        else {
-            lines.push(`  if (${acc} !== undefined && !(${allowed} as readonly unknown[]).includes(${acc})) ${throwError(`${field} must be one of: ${label}`)};`);
-        }
-        return lines;
-    }
-    if (hasType(propSchema)) {
-        const t = propSchema.type;
-        const wrongType = wrongTypeCondition(acc, t);
-        if (wrongType) {
-            const expected = throwError(`${field} expected ${typeLabel(t)}, got `, `typeof ${acc}`);
-            if (isRequired) {
-                lines.push(`  if (${wrongType}) ${expected};`);
-            }
-            else {
-                lines.push(`  if (${acc} !== undefined && (${wrongType})) ${expected};`);
-            }
-        }
-        lines.push(...generateConstraintChecks(acc, propSchema, field, context));
+  const acc = safeAccessor("input", key);
+  const field = `[${typeName}] field '${key}'`;
+  const lines = [];
+  if (isRequired) {
+    lines.push(`  if (!(${JSON.stringify(key)} in input)) ${throwError(`[${typeName}] missing required property '${key}'`)};`);
+  }
+  if (!isSchemaObject(propSchema))
+    return lines;
+  if (hasRef(propSchema))
+    return lines;
+  const unionBranches = getUnionBranches(propSchema);
+  if (unionBranches) {
+    if (!context.stripUnknown && canEnforceUnion(unionBranches, context.rootSchema)) {
+      const check = generateUnionCheck(acc, unionBranches, context.useRefImports ?? false, context.suffix ?? "");
+      if (check !== null) {
+        const failure = throwError(`${field} does not match any allowed variant`);
+        lines.push(isRequired ? `  if (!(${check})) ${failure};` : `  if (${acc} !== undefined && !(${check})) ${failure};`);
+      }
     }
-    // Type-independent constraints, each runtime-gated on the value's shape:
-    //   - `contains` asserts on arrays (no-op otherwise),
-    //   - the object-level keywords assert on objects.
-    // Gated on a single `isSchemaObject` + a few `in` checks so a plain scalar
-    // property — the common case — skips the costlier `isInlineObjectProperty`
-    // probe and the check builders entirely. Inline object properties are
-    // deep-validated by their own sub-parser (which runs these same object-level
-    // checks), so emitting them here too would be premature and redundant.
-    if (isSchemaObject(propSchema)) {
-        const r = propSchema;
-        if ('contains' in r)
-            lines.push(...generateContainsCheck(acc, propSchema, field));
-        if (('dependentRequired' in r || 'dependentSchemas' in r || 'propertyNames' in r) &&
-            !isInlineObjectProperty(propSchema)) {
-            lines.push(...generateObjectKeywordChecks(acc, propSchema, field, true));
-        }
+    return lines;
+  }
+  const instanceOf = getMjstInstanceOf(propSchema);
+  if (instanceOf) {
+    if (isRequired) {
+      lines.push(`  if (!(${acc} instanceof ${instanceOf})) ${throwError(`${field} must be ${instanceOf}`)};`);
+    } else {
+      lines.push(`  if (${acc} !== undefined && !(${acc} instanceof ${instanceOf})) ${throwError(`${field} must be ${instanceOf}`)};`);
     }
     return lines;
-};
-/**
- * Generates strict-mode assertions for the body of an object parser.
- * Throws on:
- *   - non-object input
- *   - missing required property
- *   - property of the wrong primitive type
- *   - enum / pattern / length / min / max / multipleOf violations
- *
- * Properties with a `$ref` are validated by the nested parser's own strict
- * check when that parser is invoked downstream.
- */
-export const generateObjectStrictAssertion = (schema, typeName, context = {}) => {
-    const lines = [];
-    lines.push(`  if (!isObject(input)) ${throwError(`[${typeName}] expected object, got `, 'input === null ? "null" : typeof input')};`);
-    if (!isSchemaObject(schema))
-        return lines;
-    if (hasProperties(schema)) {
-        const required = new Set(hasRequired(schema) ? schema.required : []);
-        const props = schema.properties;
-        for (const key in props) {
-            lines.push(...generatePropertyAssertion(key, props[key], required.has(key), typeName, context));
-        }
+  }
+  const primitive = getMjstPrimitive(propSchema);
+  if (primitive) {
+    if (isRequired) {
+      lines.push(`  if (typeof ${acc} !== "${primitive}") ${throwError(`${field} must be ${primitive}`)};`);
+    } else {
+      lines.push(`  if (${acc} !== undefined && typeof ${acc} !== "${primitive}") ${throwError(`${field} must be ${primitive}`)};`);
     }
-    // Object-level keywords for the object itself. `input` is already proven an
-    // object above, so no runtime guard is needed. Emitted even when the schema
-    // has no `properties` (e.g. a constrained-key map: `{ type: 'object',
-    // propertyNames: {...} }`). Gated on a cheap presence check so a keyword-free
-    // object skips the three check builders.
-    const sr = schema;
-    if ('dependentRequired' in sr || 'dependentSchemas' in sr || 'propertyNames' in sr) {
-        lines.push(...generateObjectKeywordChecks('input', schema, `[${typeName}]`, false));
+    return lines;
+  }
+  if (hasEnum(propSchema)) {
+    const allowed = JSON.stringify(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}`)};`);
+    } else {
+      lines.push(`  if (${acc} !== undefined && !(${allowed} as readonly unknown[]).includes(${acc})) ${throwError(`${field} must be one of: ${label}`)};`);
     }
     return lines;
-};
-/**
- * Generates a single strict-mode assertion line for a non-object scalar parser.
- * Returns null when the schema has no type information to assert on.
- */
-export const generateScalarStrictAssertion = (schema, typeName, rootSchema) => {
-    const got = 'input === null ? "null" : typeof input';
-    const instanceOf = getMjstInstanceOf(schema);
-    if (instanceOf) {
-        return `  if (!(input instanceof ${instanceOf})) ${throwError(`[${typeName}] expected ${instanceOf}, got `, got)};`;
+  }
+  if (hasType(propSchema)) {
+    const t = propSchema.type;
+    const wrongType = wrongTypeCondition(acc, t);
+    if (wrongType) {
+      const expected = throwError(`${field} expected ${typeLabel(t)}, got `, `typeof ${acc}`);
+      if (isRequired) {
+        lines.push(`  if (${wrongType}) ${expected};`);
+      } else {
+        lines.push(`  if (${acc} !== undefined && (${wrongType})) ${expected};`);
+      }
     }
-    const primitive = getMjstPrimitive(schema);
-    if (primitive) {
-        return `  if (typeof input !== "${primitive}") ${throwError(`[${typeName}] expected ${primitive}, got `, got)};`;
+    lines.push(...generateConstraintChecks(acc, propSchema, field, context));
+  }
+  if (isSchemaObject(propSchema)) {
+    const r = propSchema;
+    if ("contains" in r)
+      lines.push(...generateContainsCheck(acc, propSchema, field));
+    if (("dependentRequired" in r || "dependentSchemas" in r || "propertyNames" in r) && !isInlineObjectProperty(propSchema)) {
+      lines.push(...generateObjectKeywordChecks(acc, propSchema, field, true));
     }
-    if (!isSchemaObject(schema))
-        return null;
-    const label = `[${typeName}]`;
-    const lines = [];
-    // `const` / `enum` apply to a root value regardless of a declared `type` — a
-    // root `{ enum: [...] }` or `{ const: ... }` must reject a non-member, not
-    // silently coerce it. `const` is compared through `JSON.stringify` so it works
-    // for any JSON value; the value must match exactly.
-    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)}`)};`);
+  }
+  return lines;
+};
+const generateObjectStrictAssertion = (schema, typeName, context = {}) => {
+  const lines = [];
+  lines.push(`  if (!isObject(input)) ${throwError(`[${typeName}] expected object, got `, 'input === null ? "null" : typeof input')};`);
+  if (!isSchemaObject(schema))
+    return lines;
+  if (hasProperties(schema)) {
+    const required = new Set(hasRequired(schema) ? schema.required : []);
+    const props = schema.properties;
+    for (const key in props) {
+      lines.push(...generatePropertyAssertion(key, props[key], required.has(key), typeName, context));
     }
-    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}`)};`);
+  }
+  const sr = schema;
+  if ("dependentRequired" in sr || "dependentSchemas" in sr || "propertyNames" in sr) {
+    lines.push(...generateObjectKeywordChecks("input", schema, `[${typeName}]`, false));
+  }
+  return lines;
+};
+const generateScalarStrictAssertion = (schema, typeName, rootSchema) => {
+  const got = 'input === null ? "null" : typeof input';
+  const instanceOf = getMjstInstanceOf(schema);
+  if (instanceOf) {
+    return `  if (!(input instanceof ${instanceOf})) ${throwError(`[${typeName}] expected ${instanceOf}, got `, got)};`;
+  }
+  const primitive = getMjstPrimitive(schema);
+  if (primitive) {
+    return `  if (typeof input !== "${primitive}") ${throwError(`[${typeName}] expected ${primitive}, got `, got)};`;
+  }
+  if (!isSchemaObject(schema))
+    return null;
+  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)}`)};`);
+  } 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}`)};`);
+  }
+  if (hasType(schema)) {
+    const t = schema.type;
+    const wrongType = wrongTypeCondition("input", t);
+    if (wrongType) {
+      lines.push(`  if (${wrongType}) ${throwError(`${label} expected ${typeLabel(t)}, got `, got)};`);
     }
-    if (hasType(schema)) {
-        const t = schema.type;
-        const wrongType = wrongTypeCondition('input', t);
-        if (wrongType) {
-            lines.push(`  if (${wrongType}) ${throwError(`${label} expected ${typeLabel(t)}, got `, got)};`);
-        }
-        // Root-level arrays enforce scalar/enum item types too — the same gap the
-        // property path closes in generateConstraintChecks — plus `contains`.
-        if (t === 'array') {
-            const itemCheck = generateItemCheck(schema);
-            if (itemCheck) {
-                lines.push(`  if (!(input as readonly unknown[]).every((_it) => ${itemCheck.check})) ${throwError(`${label} ${itemCheck.message}`)};`);
-            }
-            lines.push(...generateContainsCheck('input', schema, label));
-            // Tuple `prefixItems`: assert each position and cap length under items:false.
-            lines.push(...generatePrefixItemsAssertion('input', label, schema, rootSchema));
-        }
-        // String (pattern, min/maxLength), number/integer (bounds, multipleOf) and
-        // array (length, uniqueItems) constraints — previously enforced only for
-        // named properties, so a root scalar accepted e.g. `{type:'string',minLength:5}`
-        // violations.
-        lines.push(...generateConstraintChecks('input', schema, label, rootSchema ? { rootSchema } : {}));
+    if (t === "array") {
+      const itemCheck = generateItemCheck(schema);
+      if (itemCheck) {
+        lines.push(`  if (!(input as readonly unknown[]).every((_it) => ${itemCheck.check})) ${throwError(`${label} ${itemCheck.message}`)};`);
+      }
+      lines.push(...generateContainsCheck("input", schema, label));
+      lines.push(...generatePrefixItemsAssertion("input", label, schema, rootSchema));
     }
-    return lines.length > 0 ? lines.join('\n') : null;
+    lines.push(...generateConstraintChecks("input", schema, label, rootSchema ? { rootSchema } : {}));
+  }
+  return lines.length > 0 ? lines.join("\n") : null;
+};
+export {
+  generateContainsCheck,
+  generateObjectKeywordChecks,
+  generateObjectStrictAssertion,
+  generateScalarStrictAssertion
 };