@amritk/generate-parsers 0.16.0 → 0.16.1

package/dist/generators/generate-schema-checks.js

@@ -1,8 +1,158 @@
 import { escapeRegexPattern } from '@amritk/helpers/escape-regex-pattern';
 import { getMjstInstanceOf, getMjstPrimitive } from '@amritk/helpers/mjst-extension';
 import { multipleOfPassExpr } from '@amritk/helpers/multiple-of-check';
-import { hasAdditionalProperties, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasMaxItems, hasMaximum, hasMaxLength, hasMaxProperties, hasMinItems, hasMinimum, hasMinLength, hasMinProperties, hasMultipleOf, hasPattern, hasProperties, hasRequired, hasType, hasUniqueItems, } from '@amritk/helpers/schema-guards';
+import { hasAdditionalProperties, hasConst, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasMaxItems, hasMaximum, hasMaxLength, hasMaxProperties, hasMinItems, hasMinimum, hasMinLength, hasMinProperties, hasMultipleOf, hasPattern, hasProperties, hasRequired, hasType, hasUniqueItems, isSchemaObject, } from '@amritk/helpers/schema-guards';
 import { generateEnumCheck } from './generate-enum-check.js';
+// Keywords that only make sense on a given type. A branch that carries any of
+// them but no explicit `type` is treated as that type for discrimination.
+const OBJECT_KEYWORDS = [
+    'properties',
+    'required',
+    'minProperties',
+    'maxProperties',
+    'additionalProperties',
+    'patternProperties',
+    'dependentRequired',
+    'propertyNames',
+];
+const ARRAY_KEYWORDS = ['items', 'prefixItems', 'minItems', 'maxItems', 'uniqueItems', 'contains'];
+const STRING_KEYWORDS = ['minLength', 'maxLength', 'pattern', 'format'];
+const NUMBER_KEYWORDS = ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'multipleOf'];
+const countKeywords = (schema, keywords) => keywords.reduce((total, keyword) => (keyword in schema ? total + 1 : total), 0);
+/** Resolves the JSON Schema type of a single literal (a `const` value). */
+const typeOfLiteral = (value) => {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    const type = typeof value;
+    if (type === 'boolean')
+        return 'boolean';
+    if (type === 'number' || type === 'bigint')
+        return 'number';
+    if (type === 'string')
+        return 'string';
+    return 'object';
+};
+/**
+ * Infers the type of a schema branch that omits an explicit `type`.
+ *
+ * A `const` pins the value to one literal, so its type is definitive. An enum
+ * of only `null`s can only be the null type. Otherwise each candidate type is
+ * scored by how many of its characteristic keywords the schema carries and the
+ * highest wins, with ties resolved in `object > array > string > number` order
+ * (so `{ minProperties, minItems }` is an object and `{ minItems, maxItems,
+ * minLength }` is an array). Returns undefined when nothing points at a type —
+ * e.g. a bare `{ description }` — so the caller emits no checks.
+ */
+const inferSchemaType = (schema) => {
+    if (!isSchemaObject(schema))
+        return undefined;
+    if (hasConst(schema)) {
+        return typeOfLiteral(schema.const);
+    }
+    if (hasEnum(schema) && schema.enum.length > 0 && schema.enum.every((value) => value === null)) {
+        return 'null';
+    }
+    const scores = {
+        object: countKeywords(schema, OBJECT_KEYWORDS),
+        array: countKeywords(schema, ARRAY_KEYWORDS),
+        string: countKeywords(schema, STRING_KEYWORDS),
+        number: countKeywords(schema, NUMBER_KEYWORDS),
+    };
+    // Iterating in priority order and only replacing on a strictly-greater score
+    // means the earliest (highest-priority) type wins any tie.
+    let best;
+    for (const type of ['object', 'array', 'string', 'number']) {
+        if (scores[type] > 0 && (best === undefined || scores[type] > scores[best])) {
+            best = type;
+        }
+    }
+    return best;
+};
+/**
+ * Emits the checks for a branch whose type was inferred (not explicit). It
+ * mirrors the explicit-type switch below, with two deliberate differences: the
+ * enum membership check uses the `.includes` form (appended by the caller) and
+ * `multipleOf` uses the plain `% === 0` form, matching the inference spec.
+ */
+const generateInferredChecks = (accessor, schema, type) => {
+    const checks = [];
+    switch (type) {
+        case 'object':
+            checks.push(`typeof ${accessor} === "object" && ${accessor} !== null && !Array.isArray(${accessor})`);
+            if (hasRequired(schema) && schema.required.length > 0) {
+                for (const requiredKey of schema.required) {
+                    checks.push(`${JSON.stringify(requiredKey)} in ${accessor}`);
+                }
+            }
+            if (hasMinProperties(schema)) {
+                checks.push(`Object.keys(${accessor}).length >= ${schema.minProperties}`);
+            }
+            if (hasMaxProperties(schema)) {
+                checks.push(`Object.keys(${accessor}).length <= ${schema.maxProperties}`);
+            }
+            if (hasAdditionalProperties(schema) && schema.additionalProperties === false && hasProperties(schema)) {
+                const allowedKeysStr = JSON.stringify(Object.keys(schema.properties));
+                checks.push(`Object.keys(${accessor}).every(k => ${allowedKeysStr}.includes(k))`);
+            }
+            break;
+        case 'array':
+            checks.push(`Array.isArray(${accessor})`);
+            if (hasMinItems(schema)) {
+                checks.push(`${accessor}.length >= ${schema.minItems}`);
+            }
+            if (hasMaxItems(schema)) {
+                checks.push(`${accessor}.length <= ${schema.maxItems}`);
+            }
+            if (hasUniqueItems(schema) && schema.uniqueItems === true) {
+                checks.push(`new Set(${accessor}).size === ${accessor}.length`);
+            }
+            break;
+        case 'string':
+            checks.push(`typeof ${accessor} === "string"`);
+            if (hasPattern(schema)) {
+                checks.push(`/${escapeRegexPattern(schema.pattern)}/.test(${accessor})`);
+            }
+            if (hasMinLength(schema)) {
+                checks.push(`${accessor}.length >= ${schema.minLength}`);
+            }
+            if (hasMaxLength(schema)) {
+                checks.push(`${accessor}.length <= ${schema.maxLength}`);
+            }
+            break;
+        case 'number':
+            checks.push(`typeof ${accessor} === "number"`);
+            if (hasMinimum(schema)) {
+                checks.push(`${accessor} >= ${schema.minimum}`);
+            }
+            if (hasMaximum(schema)) {
+                checks.push(`${accessor} <= ${schema.maximum}`);
+            }
+            if (hasExclusiveMinimum(schema)) {
+                checks.push(`${accessor} > ${schema.exclusiveMinimum}`);
+            }
+            if (hasExclusiveMaximum(schema)) {
+                checks.push(`${accessor} < ${schema.exclusiveMaximum}`);
+            }
+            if (hasMultipleOf(schema)) {
+                checks.push(`${accessor} % ${schema.multipleOf} === 0`);
+            }
+            break;
+        case 'boolean':
+            checks.push(`typeof ${accessor} === "boolean"`);
+            break;
+        case 'null':
+            // A `null` inferred from an all-null enum is covered by the membership
+            // check the caller appends; only a `const: null` needs its own identity
+            // check here.
+            if (hasConst(schema)) {
+                checks.push(`${accessor} === null`);
+            }
+            break;
+    }
+    return checks;
+};
 /**
  * Generates validation checks for a single schema (used in union validation).
  */
@@ -18,7 +168,17 @@ export const generateSchemaChecks = (accessor, schema) => {
     if (primitive) {
         return [`typeof ${accessor} === "${primitive}"`];
     }
+    // Without an explicit `type`, a branch's keywords still imply one. Inferring
+    // it lets union discrimination reject the branch instead of matching anything.
     if (!hasType(schema)) {
+        const inferred = inferSchemaType(schema);
+        if (!inferred) {
+            return checks;
+        }
+        checks.push(...generateInferredChecks(accessor, schema, inferred));
+        if (hasEnum(schema) && schema.enum.length > 0) {
+            checks.push(`${JSON.stringify(schema.enum)}.includes(${accessor} as never)`);
+        }
         return checks;
     }
     switch (schema.type) {

package/dist/generators/generate-strict-assertion.d.ts

@@ -14,6 +14,27 @@ export type StrictAssertionContext = {
     readonly rootSchema?: Record<string, unknown>;
     readonly stripUnknown?: boolean;
 };
+/**
+ * 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 declare const generateContainsCheck: (acc: string, schema: JSONSchema, label: string) => string[];
+/**
+ * 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 declare const generateObjectKeywordChecks: (obj: string, schema: JSONSchema, label: string, guard: boolean) => string[];
 /**
  * Generates strict-mode assertions for the body of an object parser.
  * Throws on:
@@ -30,4 +51,4 @@ export declare const generateObjectStrictAssertion: (schema: JSONSchema, typeNam
  * 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 declare const generateScalarStrictAssertion: (schema: JSONSchema, typeName: string) => string | null;
+export declare const generateScalarStrictAssertion: (schema: JSONSchema, typeName: string, rootSchema?: Record<string, unknown>) => string | null;

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

@@ -2,11 +2,13 @@ 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 { hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMinItems, hasMinimum, hasMinLength, hasMultipleOf, hasPattern, hasProperties, hasRef, hasRequired, hasType, hasUniqueItems, isSchemaObject, } from '@amritk/helpers/schema-guards';
+import { 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 } from './generate-type-checks.js';
-import { scalarItemTypeCheck } from './generate-validation-expression.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.
@@ -55,7 +57,7 @@ const throwError = (message, suffixExpr) => {
  * Generates strict-mode constraint checks for a typed property
  * (pattern, length, min/max, multipleOf).
  */
-const generateConstraintChecks = (acc, propSchema, typeName, key) => {
+const generateConstraintChecks = (acc, propSchema, typeName, key, context = {}) => {
     if (!isSchemaObject(propSchema) || !hasType(propSchema))
         return [];
     const t = propSchema.type;
@@ -110,6 +112,8 @@ const generateConstraintChecks = (acc, propSchema, typeName, key) => {
         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));
     }
     return lines;
 };
@@ -131,6 +135,172 @@ const generateItemCheck = (schema) => {
         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`)};`,
+        `  }`,
+    ];
+};
+/**
+ * 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`)};`);
+        }
+    }
+    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`)};`);
+    }
+    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;
+};
+/**
+ * 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}`)};`);
+            }
+        }
+    }
+    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')};`,
+        `  }`,
+    ];
+};
+/**
+ * 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}`), `  }`];
+};
 /**
  * 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
@@ -205,7 +375,24 @@ const generatePropertyAssertion = (key, propSchema, isRequired, typeName, contex
                 lines.push(`  if (${acc} !== undefined && (${wrongType})) ${expected};`);
             }
         }
-        lines.push(...generateConstraintChecks(acc, propSchema, typeName, key));
+        lines.push(...generateConstraintChecks(acc, propSchema, typeName, key, context));
+    }
+    // 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;
 };
@@ -223,12 +410,23 @@ const generatePropertyAssertion = (key, propSchema, isRequired, typeName, contex
 export const generateObjectStrictAssertion = (schema, typeName, context = {}) => {
     const lines = [];
     lines.push(`  if (!isObject(input)) ${throwError(`[${typeName}] expected object, got `, 'input === null ? "null" : typeof input')};`);
-    if (!hasProperties(schema) || !isSchemaObject(schema))
+    if (!isSchemaObject(schema))
         return lines;
-    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));
+    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));
+        }
+    }
+    // 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;
 };
@@ -236,7 +434,7 @@ export const generateObjectStrictAssertion = (schema, typeName, context = {}) =>
  * 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) => {
+export const generateScalarStrictAssertion = (schema, typeName, rootSchema) => {
     const got = 'input === null ? "null" : typeof input';
     const instanceOf = getMjstInstanceOf(schema);
     if (instanceOf) {
@@ -254,12 +452,15 @@ export const generateScalarStrictAssertion = (schema, typeName) => {
         return null;
     const lines = [`  if (${wrongType}) ${throwError(`[${typeName}] expected ${typeLabel(t)}, got `, got)};`];
     // Root-level arrays enforce scalar/enum item types too — the same gap the
-    // property path closes in generateConstraintChecks.
+    // 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(`[${typeName}] ${itemCheck.message}`)};`);
         }
+        lines.push(...generateContainsCheck('input', schema, `[${typeName}]`));
+        // Tuple `prefixItems`: assert each position and cap length under items:false.
+        lines.push(...generatePrefixItemsAssertion('input', `[${typeName}]`, schema, rootSchema));
     }
     return lines.join('\n');
 };

package/dist/generators/generate-type-checks.d.ts

@@ -41,6 +41,15 @@ export declare const isInlineObjectArrayProperty: (propSchema: JSONSchema) => bo
  * turn into a membership check).
  */
 export declare const getUnionBranches: (schema: JSONSchema) => readonly JSONSchema[] | null;
+/**
+ * True when a schema carries a keyword the strict slow path enforces but which
+ * no flat type check can mirror: `contains` (array item counting),
+ * `dependentRequired` / `dependentSchemas` (cross-property presence), or
+ * `propertyNames` (per-key constraints). A fast path or shape validator that
+ * accepted such a value on a bare type check would skip the enforcement, so
+ * both must bail when this is true — the slow path then runs the real checks.
+ */
+export declare const hasFastPathBlockingKeyword: (schema: JSONSchema) => boolean;
 /**
  * Generates a fast-path type check expression for a property.
  * Returns null if the schema is too complex for a simple type check.

package/dist/generators/generate-type-checks.js

@@ -5,7 +5,7 @@ import { resolveRef } from '@amritk/helpers/resolve-ref';
 import { safeAccessor } from '@amritk/helpers/safe-accessor';
 import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMinItems, hasMinimum, hasMinLength, hasMultipleOf, hasOneOf, hasPattern, hasProperties, hasRef, hasType, hasUniqueItems, isObjectSchema, isSchemaObject, } from '@amritk/helpers/schema-guards';
 import { generateEnumCheck } from './generate-enum-check.js';
-import { scalarItemTypeCheck } from './generate-validation-expression.js';
+import { getPrefixItems, prefixItemsCapsLength, scalarItemTypeCheck } from './generate-validation-expression.js';
 /**
  * Boolean type-check expression builders shared by the shape validators, the
  * parsers' fast paths, and the strict-mode assertions. They live in their own
@@ -86,6 +86,23 @@ export const getUnionBranches = (schema) => {
         return schema.anyOf;
     return null;
 };
+/**
+ * True when a schema carries a keyword the strict slow path enforces but which
+ * no flat type check can mirror: `contains` (array item counting),
+ * `dependentRequired` / `dependentSchemas` (cross-property presence), or
+ * `propertyNames` (per-key constraints). A fast path or shape validator that
+ * accepted such a value on a bare type check would skip the enforcement, so
+ * both must bail when this is true — the slow path then runs the real checks.
+ */
+export const hasFastPathBlockingKeyword = (schema) => {
+    if (!isSchemaObject(schema))
+        return false;
+    const record = schema;
+    // Plain `in` checks (not the typed `hasDependentRequired`): this runs several
+    // times per property during codegen, and a present-but-malformed keyword still
+    // belongs on the slow path, where the typed guards handle it.
+    return ('contains' in record || 'dependentSchemas' in record || 'propertyNames' in record || 'dependentRequired' in record);
+};
 /**
  * Generates a fast-path type check expression for a property.
  * Returns null if the schema is too complex for a simple type check.
@@ -97,6 +114,19 @@ export const getUnionBranches = (schema) => {
 export const generatePropertyTypeCheck = (varName, schema, useRefImports, suffix) => {
     if (!isSchemaObject(schema))
         return null;
+    // Keywords the strict slow path enforces but no flat check can prove: bail so
+    // neither the fast path nor the shape validator accepts a value they would
+    // otherwise wave through untested. Inlined here (rather than calling
+    // hasFastPathBlockingKeyword) to reuse the isSchemaObject narrowing above —
+    // this is a codegen hot path hit several times per property. Keep in sync with
+    // hasFastPathBlockingKeyword.
+    const record = schema;
+    if ('contains' in record ||
+        'dependentSchemas' in record ||
+        'propertyNames' in record ||
+        'dependentRequired' in record) {
+        return null;
+    }
     // $ref via shape predicate (deep fast-path through nested types).
     if (useRefImports && hasRef(schema)) {
         const refName = refToName(schema.$ref, suffix);
@@ -195,6 +225,24 @@ export const generatePropertyTypeCheck = (varName, schema, useRefImports, suffix
                 if (itemCheck)
                     checks.push(`${varName}.every((_it) => ${itemCheck})`);
             }
+            // Tuple `prefixItems`: every present position must already match its
+            // subschema, and a sibling `items: false` bars extra elements. Positions
+            // are checked with ref imports disabled, so no imported shape-validator
+            // call is introduced here — a position needing one returns null and simply
+            // disables the fast path, keeping the union trust-walk sound without a
+            // mirrored prefixItems traversal. A mistyped tuple then routes to the slow
+            // path (coerced) or the strict assertion (thrown).
+            const prefix = getPrefixItems(schema);
+            if (prefix) {
+                for (let i = 0; i < prefix.length; i++) {
+                    const posCheck = generatePropertyTypeCheck(`${varName}[${i}]`, prefix[i], false, suffix);
+                    if (posCheck === null)
+                        return null;
+                    checks.push(`(${varName}.length <= ${i} || (${posCheck}))`);
+                }
+                if (prefixItemsCapsLength(schema))
+                    checks.push(`${varName}.length <= ${prefix.length}`);
+            }
             break;
         }
         case 'object':

package/dist/generators/generate-validation-expression.d.ts

@@ -13,9 +13,32 @@ export declare const scalarItemTypeCheck: (itemSchema: JSONSchema, accessor: str
  * Anything richer (objects, unions, `$ref`s) needs a real item parser instead.
  */
 export declare const isCoercibleItemSchema: (itemSchema: JSONSchema) => boolean;
+/**
+ * The tuple `prefixItems` array when the schema declares one, else `null`.
+ * `prefixItems` (JSON Schema 2020-12) positions each element against its own
+ * subschema; the draft array-form `items` is handled by the existing item
+ * paths, not here.
+ */
+export declare const getPrefixItems: (schema: JSONSchema) => readonly JSONSchema[] | null;
+/**
+ * True when a sibling `items: false` (2020-12) or `additionalItems: false`
+ * (draft) caps a tuple's length — any element past the declared prefix is
+ * disallowed, so the coercer drops it and strict mode rejects it.
+ */
+export declare const prefixItemsCapsLength: (schema: JSONSchema) => boolean;
 /**
  * Generates a validation expression that checks if a value matches the expected type.
  * Returns the value if valid, coerces to the correct type if invalid, or uses default if required and missing.
  * Supports type checking, pattern validation, enum validation, union types, and $ref resolution.
  */
 export declare const generateValidationExpression: (key: string, schema: JSONSchema, defaultValue: string, isRequired: boolean, rootSchema?: Record<string, unknown>, visitedRefs?: Set<string>, accessorOverride?: string, knownNotUndefined?: boolean, caseInsensitive?: boolean) => string;
+/**
+ * Builds the coercion transform for a tuple `prefixItems` array: an index-matched
+ * `.map` where each declared position runs through its own subschema's coercion
+ * (present positions only — a shorter input keeps its absent trailing positions),
+ * and every element past the tuple passes through unchanged. When `capLength` is
+ * set (a sibling `items: false`), a trailing `.slice(0, N)` drops those extras.
+ * `accessor` must already be known to be an array (the caller guards with
+ * `Array.isArray`). `$ref` positions resolve against `rootSchema` when provided.
+ */
+export declare const generatePrefixItemsMap: (accessor: string, prefix: readonly JSONSchema[], capLength: boolean, rootSchema?: Record<string, unknown>, visitedRefs?: Set<string>, caseInsensitive?: boolean) => string;