@amritk/generate-parsers 0.17.2 → 0.19.0

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

@@ -41,15 +41,43 @@ export declare const isInlineObjectArrayProperty: (propSchema: JSONSchema) => bo
  * turn into a membership check).
  */
 export declare const getUnionBranches: (schema: JSONSchema) => readonly JSONSchema[] | null;
+/**
+ * True when {@link getUnionBranches} came from a `oneOf` rather than an `anyOf` —
+ * i.e. the value must match *exactly one* branch, not at least one.
+ *
+ * The distinction was dropped before: both spellings produced a plain
+ * disjunction, so `{ oneOf: [{…a}, {…b}] }` accepted `{ a: 'x', b: 1 }`, which
+ * matches both branches. Ajv, the runtime interpreter, and `generate-validators`
+ * all reject it, so the two mjst engines disagreed on the same contract.
+ */
+export declare const isExclusiveUnion: (schema: JSONSchema) => boolean;
 /**
  * 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.
+ * `dependentRequired` / `dependentSchemas` (cross-property presence),
+ * `propertyNames` (per-key constraints), the conditional and composition
+ * keywords (`if`/`then`/`else`, `not`, a constraining `allOf`), or per-key value
+ * schemas (`patternProperties`, a constraining `additionalProperties`). 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;
+/**
+ * The membership check for an array-form `type` (the multi-type / nullable
+ * idiom, e.g. `["string","null"]`): the disjunction of the per-type checks.
+ * Returns `undefined` when the schema has no array `type`, and `null` when it
+ * has one that cannot be checked soundly — a type name we do not model, or a
+ * constraint keyword a bare `typeof` would skip.
+ *
+ * Without this every nullable property fell through to `hasType`, which is false
+ * for an array `type`, and produced no check at all: no fast path (so the shape
+ * validator degraded to the `=> false` stub) and, in strict mode, nothing to
+ * throw on.
+ */
+export declare const multiTypeCheck: (varName: string, schema: JSONSchema, options?: {
+    readonly ignoreConstraints?: boolean;
+}) => string | null | undefined;
 /**
  * Generates a fast-path type check expression for a property.
  * Returns null if the schema is too complex for a simple type check.
@@ -68,13 +96,21 @@ export declare const generatePropertyTypeCheck: (varName: string, schema: JSONSc
  */
 export declare const generateInlineObjectCheck: (varName: string, schema: JSONSchema, useRefImports: boolean, suffix: string) => string | null;
 /**
- * Generates a union membership check: true when `varName` matches at least one
- * branch of a `oneOf`/`anyOf`. Inline object branches get a per-property check;
- * everything else goes through {@link generatePropertyTypeCheck} ($refs call
- * the imported shape validator, consts/enums/scalars check directly). Returns
- * null when any branch cannot be checked.
+ * Generates a union membership check. Inline object branches get a per-property
+ * check; everything else goes through {@link generatePropertyTypeCheck} ($refs
+ * call the imported shape validator, consts/enums/scalars check directly).
+ * Returns null when any branch cannot be checked.
+ *
+ * `exclusive` (a `oneOf` — see {@link isExclusiveUnion}) counts the matching
+ * branches and demands exactly one, instead of the `anyOf` disjunction. The count
+ * form is *tighter* than the disjunction it replaces — anything it accepts, the
+ * disjunction accepted too — so a true-sound caller (a fast path, a shape
+ * validator) can only get safer: a value it now declines merely takes the slow
+ * path, which re-validates. A caller that *throws* on a false result needs each
+ * branch check to be exact in both directions, which is precisely what
+ * {@link canEnforceUnion} certifies.
  */
-export declare const generateUnionCheck: (varName: string, branches: readonly JSONSchema[], useRefImports: boolean, suffix: string) => string | null;
+export declare const generateUnionCheck: (varName: string, branches: readonly JSONSchema[], useRefImports: boolean, suffix: string, exclusive?: boolean) => string | null;
 /**
  * True when the union membership check emitted by {@link generateUnionCheck}
  * is also *false-sound* — a false result definitely means the value is invalid

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

@@ -1,17 +1,21 @@
-import { escapeRegexPattern } from "@amritk/helpers/escape-regex-pattern";
+import { regexLiteral } from "@amritk/helpers/escape-regex-pattern";
 import { multipleOfPassExpr } from "@amritk/helpers/multiple-of-check";
 import { refToName } from "@amritk/helpers/ref-to-name";
 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 { hasOwnCheck, safeAccessor } from "@amritk/helpers/safe-accessor";
+import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMaxProperties, hasMinItems, hasMinimum, hasMinLength, hasMinProperties, hasMultipleOf, hasOneOf, hasPattern, hasProperties, hasRef, hasType, hasUniqueItems, isObjectSchema, isSchemaObject } from "@amritk/helpers/schema-guards";
 import { generateEnumCheck } from "./generate-enum-check.js";
-import { getPrefixItems, prefixItemsCapsLength, scalarItemTypeCheck } from "./generate-validation-expression.js";
+import { generateUniqueItemsCheck } from "./generate-unique-items-check.js";
+import { everyTailItem, getPrefixItems, prefixItemsCapsLength, scalarItemTypeCheck, singleTypeCheck } from "./generate-validation-expression.js";
+import { hasConstrainingRefSibling, subschemaMatchExpr } from "./subschema-match.js";
 const shapeValidatorName = (typeName) => `validate${typeName}Shape`;
 const isInlineObjectProperty = (propSchema) => {
   if (!isSchemaObject(propSchema))
     return false;
   if (hasRef(propSchema) || hasEnum(propSchema) || hasConst(propSchema))
     return false;
+  if (Array.isArray(propSchema.type))
+    return false;
   if (hasOneOf(propSchema) || hasAnyOf(propSchema) || hasAllOf(propSchema))
     return false;
   if ("patternProperties" in propSchema || "not" in propSchema)
@@ -42,19 +46,74 @@ const getUnionBranches = (schema) => {
     return schema.anyOf;
   return null;
 };
+const isExclusiveUnion = (schema) => isSchemaObject(schema) && !hasAllOf(schema) && !("not" in schema) && hasOneOf(schema) && schema.oneOf.length > 0;
 const hasFastPathBlockingKeyword = (schema) => {
   if (!isSchemaObject(schema))
     return false;
   const record = schema;
-  return "contains" in record || "dependentSchemas" in record || "propertyNames" in record || "dependentRequired" in record;
+  return "contains" in record || "dependentSchemas" in record || "propertyNames" in record || "dependentRequired" in record || // Composition and conditionals: the strict assertions now enforce these, but
+  // a guard built from per-property type checks cannot mirror them — it said
+  // "already in shape" for `{ kind: 'a' }` under `if: {kind: 'a'}, then:
+  // {required: ['n']}` and returned before the conditional was ever tested.
+  "if" in record || "then" in record || "else" in record || "not" in record || "patternProperties" in record || // `unevaluated*` is answered against the whole node's annotation coverage,
+  // which a per-property guard has no way to reproduce.
+  "unevaluatedProperties" in record && record["unevaluatedProperties"] !== true || "unevaluatedItems" in record && record["unevaluatedItems"] !== true || // A `$ref` guard calls the target's shape validator, which knows nothing
+  // about the siblings 2020-12 still applies: `{ $ref: …, minProperties: 2 }`
+  // was waved through on the target's shape alone.
+  hasConstrainingRefSibling(schema) || hasConstrainingAllOf(schema) || hasConstrainingAdditionalProperties(schema);
+};
+const hasConstrainingAllOf = (schema) => hasAllOf(schema) && schema.allOf.some((member) => !(isSchemaObject(member) && hasRef(member)));
+const hasConstrainingAdditionalProperties = (schema) => {
+  if (!hasAdditionalProperties(schema))
+    return false;
+  const additional = schema.additionalProperties;
+  if (typeof additional === "boolean")
+    return false;
+  return subschemaMatchExpr("_x", additional) !== "true";
+};
+const CONSTRAINT_KEYWORDS = [
+  "pattern",
+  "minLength",
+  "maxLength",
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "multipleOf",
+  "minItems",
+  "maxItems",
+  "uniqueItems",
+  "items",
+  "prefixItems",
+  "properties",
+  "required",
+  "additionalProperties",
+  "patternProperties",
+  "minProperties",
+  "maxProperties"
+];
+const multiTypeCheck = (varName, schema, options = {}) => {
+  if (!isSchemaObject(schema) || !Array.isArray(schema.type))
+    return void 0;
+  const record = schema;
+  if (!options.ignoreConstraints && CONSTRAINT_KEYWORDS.some((keyword) => keyword in record))
+    return null;
+  const checks = [];
+  for (const type of schema.type) {
+    const check = singleTypeCheck(varName, type);
+    if (check === null)
+      return null;
+    checks.push(`(${check})`);
+  }
+  if (checks.length === 0)
+    return null;
+  return checks.length === 1 ? checks[0] : `(${checks.join(" || ")})`;
 };
 const generatePropertyTypeCheck = (varName, schema, useRefImports, suffix) => {
   if (!isSchemaObject(schema))
     return null;
-  const record = schema;
-  if ("contains" in record || "dependentSchemas" in record || "propertyNames" in record || "dependentRequired" in record) {
+  if (hasFastPathBlockingKeyword(schema))
     return null;
-  }
   if (useRefImports && hasRef(schema)) {
     const refName = refToName(schema.$ref, suffix);
     return `${shapeValidatorName(refName)}(${varName})`;
@@ -66,7 +125,7 @@ const generatePropertyTypeCheck = (varName, schema, useRefImports, suffix) => {
   }
   const branches = getUnionBranches(schema);
   if (branches) {
-    return generateUnionCheck(varName, branches, useRefImports, suffix);
+    return generateUnionCheck(varName, branches, useRefImports, suffix, isExclusiveUnion(schema));
   }
   if (hasOneOf(schema) || hasAnyOf(schema) || hasAllOf(schema) || "not" in schema) {
     return null;
@@ -75,6 +134,9 @@ const generatePropertyTypeCheck = (varName, schema, useRefImports, suffix) => {
     const c = schema.const;
     return c === null || typeof c !== "object" ? `${varName} === ${JSON.stringify(c)}` : null;
   }
+  const multiType = multiTypeCheck(varName, schema);
+  if (multiType !== void 0)
+    return multiType;
   if (!hasType(schema))
     return null;
   if (useRefImports && schema.type === "array" && hasItems(schema) && isSchemaObject(schema.items) && hasRef(schema.items)) {
@@ -86,7 +148,7 @@ const generatePropertyTypeCheck = (varName, schema, useRefImports, suffix) => {
     case "string": {
       checks.push(`typeof ${varName} === "string"`);
       if (hasPattern(schema))
-        checks.push(`/${escapeRegexPattern(schema.pattern)}/.test(${varName})`);
+        checks.push(`${regexLiteral(schema.pattern)}.test(${varName})`);
       if (hasMinLength(schema))
         checks.push(`${varName}.length >= ${schema.minLength}`);
       if (hasMaxLength(schema))
@@ -120,13 +182,20 @@ const generatePropertyTypeCheck = (varName, schema, useRefImports, suffix) => {
       if (hasMaxItems(schema))
         checks.push(`${varName}.length <= ${schema.maxItems}`);
       if (hasUniqueItems(schema) && schema.uniqueItems === true) {
-        checks.push(`new Set(${varName}).size === ${varName}.length`);
+        checks.push(generateUniqueItemsCheck(varName, schema));
       }
       if (hasItems(schema) && !Array.isArray(schema.items)) {
         const items = schema.items;
         const itemCheck = scalarItemTypeCheck(items, "_it") ?? (isSchemaObject(items) && hasEnum(items) && items.enum.length > 0 ? generateEnumCheck("_it", items.enum) : null);
-        if (itemCheck)
-          checks.push(`${varName}.every((_it) => ${itemCheck})`);
+        if (itemCheck) {
+          checks.push(everyTailItem(varName, itemCheck, schema));
+        } else if (!(isSchemaObject(items) && (hasRef(items) || isInlineObjectProperty(items)))) {
+          const match = subschemaMatchExpr("_it", items);
+          if (match === null)
+            return null;
+          if (match !== "true")
+            checks.push(everyTailItem(varName, match, schema));
+        }
       }
       const prefix = getPrefixItems(schema);
       if (prefix) {
@@ -143,6 +212,10 @@ const generatePropertyTypeCheck = (varName, schema, useRefImports, suffix) => {
     }
     case "object":
       checks.push(`isObject(${varName})`);
+      if (hasMinProperties(schema))
+        checks.push(`Object.keys(${varName}).length >= ${schema.minProperties}`);
+      if (hasMaxProperties(schema))
+        checks.push(`Object.keys(${varName}).length <= ${schema.maxProperties}`);
       break;
     default:
       return null;
@@ -175,15 +248,19 @@ const generateInlineObjectCheck = (varName, schema, useRefImports, suffix) => {
     required.delete(key);
   }
   for (const key of required) {
-    checks.push(`${JSON.stringify(key)} in ${varName}`);
+    checks.push(hasOwnCheck(varName, key));
   }
   if (hasAdditionalProperties(schema) && schema.additionalProperties === false) {
     const allowedKeys = JSON.stringify(Object.keys(schema.properties));
     checks.push(`Object.keys(${varName}).every((_k) => ${allowedKeys}.includes(_k))`);
   }
+  if (hasMinProperties(schema))
+    checks.push(`Object.keys(${varName}).length >= ${schema.minProperties}`);
+  if (hasMaxProperties(schema))
+    checks.push(`Object.keys(${varName}).length <= ${schema.maxProperties}`);
   return checks.join(" && ");
 };
-const generateUnionCheck = (varName, branches, useRefImports, suffix) => {
+const generateUnionCheck = (varName, branches, useRefImports, suffix, exclusive = false) => {
   if (branches.length === 0)
     return null;
   const parts = [];
@@ -195,7 +272,11 @@ const generateUnionCheck = (varName, branches, useRefImports, suffix) => {
       return null;
     parts.push(`(${check})`);
   }
-  return parts.length === 1 ? parts[0] : `(${parts.join(" || ")})`;
+  if (parts.length === 1)
+    return parts[0];
+  if (exclusive)
+    return `((${parts.map((part) => `(${part} ? 1 : 0)`).join(" + ")}) === 1)`;
+  return `(${parts.join(" || ")})`;
 };
 const canEnforceUnion = (branches, rootSchema) => {
   const visiting = /* @__PURE__ */ new Set();
@@ -225,6 +306,9 @@ const canTrustPropertyCheck = (schema, rootSchema, visiting) => {
     return false;
   if (hasConst(schema))
     return schema.const === null || typeof schema.const !== "object";
+  const multiType = multiTypeCheck("_x", schema);
+  if (multiType !== void 0)
+    return multiType !== null;
   if (!hasType(schema))
     return false;
   if (schema.type === "array" && hasItems(schema) && isSchemaObject(schema.items) && hasRef(schema.items)) {
@@ -256,6 +340,13 @@ const canTrustShapeProperty = (propSchema, rootSchema, visiting) => {
   }
   return canTrustPropertyCheck(propSchema, rootSchema, visiting);
 };
+const KEYWORDS_INLINE_CHECK_IGNORES = [
+  "propertyNames",
+  "dependentRequired",
+  "dependentSchemas",
+  "contains",
+  "unevaluatedProperties"
+];
 const canTrustInlineObjectCheck = (schema, rootSchema, visiting) => {
   if (!isSchemaObject(schema) || !isObjectSchema(schema) || !hasProperties(schema))
     return false;
@@ -265,6 +356,9 @@ const canTrustInlineObjectCheck = (schema, rootSchema, visiting) => {
     return false;
   if (hasAdditionalProperties(schema) && typeof schema.additionalProperties !== "boolean")
     return false;
+  const record = schema;
+  if (KEYWORDS_INLINE_CHECK_IGNORES.some((keyword) => keyword in record))
+    return false;
   return Object.values(schema.properties).every((propSchema) => canTrustPropertyCheck(propSchema, rootSchema, visiting));
 };
 const canTrustReferencedValidator = (ref, rootSchema, visiting) => {
@@ -307,7 +401,9 @@ export {
   generateUnionCheck,
   getUnionBranches,
   hasFastPathBlockingKeyword,
+  isExclusiveUnion,
   isInlineObjectArrayProperty,
   isInlineObjectProperty,
+  multiTypeCheck,
   shapeValidatorName
 };

package/dist/generators/generate-unique-items-check.d.ts

@@ -0,0 +1,16 @@
+import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
+/**
+ * Builds the boolean expression that is TRUE when every element of `accessor` is
+ * distinct — the `uniqueItems: true` contract.
+ *
+ * Scalar-only arrays take the cheap native `Set` (exact for primitives, and
+ * allocation is a single pass). Anything that might hold an object or an array
+ * falls back to the canonical-JSON projection above, because JSON Schema compares
+ * items by *structural* equality and neither a plain `Set` (reference equality)
+ * nor a raw `JSON.stringify` key (order sensitive) answers that question.
+ *
+ * @param accessor - Expression yielding the array; the caller must already have
+ *   proven `Array.isArray`.
+ * @param schema - The array schema, read for its item types.
+ */
+export declare const generateUniqueItemsCheck: (accessor: string, schema: JSONSchema) => string;

package/dist/generators/generate-unique-items-check.js

@@ -0,0 +1,32 @@
+import { hasType, isSchemaObject } from "@amritk/helpers/schema-guards";
+const SCALAR_TYPES = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean", "null"]);
+const schemaIsScalarOnly = (schema) => {
+  if (schema === void 0 || !isSchemaObject(schema) || !hasType(schema))
+    return false;
+  const type = schema["type"];
+  const types = Array.isArray(type) ? type : [type];
+  return types.length > 0 && types.every((t) => typeof t === "string" && SCALAR_TYPES.has(t));
+};
+const arrayItemsAreScalarOnly = (schema) => {
+  if (!isSchemaObject(schema))
+    return false;
+  const record = schema;
+  const prefix = record["prefixItems"];
+  if (Array.isArray(prefix)) {
+    if (!prefix.every((position) => schemaIsScalarOnly(position)))
+      return false;
+    const tail = "items" in record ? record["items"] : record["additionalItems"];
+    return tail === false ? true : schemaIsScalarOnly(tail);
+  }
+  if (Array.isArray(record["items"])) {
+    if (!record["items"].every((position) => schemaIsScalarOnly(position)))
+      return false;
+    return record["additionalItems"] === false ? true : schemaIsScalarOnly(record["additionalItems"]);
+  }
+  return schemaIsScalarOnly(record["items"]);
+};
+const CANONICAL_JSON = 'JSON.stringify(_u, (_k, _v) => (_v !== null && typeof _v === "object" && !Array.isArray(_v)) ? Object.fromEntries(Object.keys(_v).sort().map((_sk) => [_sk, (_v as Record<string, unknown>)[_sk]])) : _v)';
+const generateUniqueItemsCheck = (accessor, schema) => arrayItemsAreScalarOnly(schema) ? `new Set(${accessor}).size === ${accessor}.length` : `new Set((${accessor} as unknown[]).map((_u) => ${CANONICAL_JSON})).size === ${accessor}.length`;
+export {
+  generateUniqueItemsCheck
+};

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

@@ -14,18 +14,43 @@ export declare const scalarItemTypeCheck: (itemSchema: JSONSchema, accessor: str
  */
 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.
+ * The tuple positions a schema declares, else `null`. `prefixItems` (JSON
+ * Schema 2020-12) positions each element against its own subschema; draft-07
+ * spelled the same construct as an array-valued `items`, which every other item
+ * path skips (they all read `items` as a single schema), so it is normalized
+ * here rather than left unchecked.
  */
 export declare const getPrefixItems: (schema: JSONSchema) => readonly JSONSchema[] | null;
+/**
+ * Wraps a per-element boolean check into the `.every(...)` call that proves it
+ * for a whole array, skipping the positions `prefixItems` already owns.
+ *
+ * In 2020-12 `items` is only the *tail* schema: it applies from
+ * `prefixItems.length` onward. Checking every element against it made
+ * `{ prefixItems: [{type:'string'}], items: {type:'number'} }` reject
+ * `["a", 1, 2]` — a value Ajv accepts, and one the `[string?, ...number[]]` type
+ * this generator emits admits, so the strict parser threw on its own declared
+ * type. The index guard is short-circuited rather than sliced so the check stays
+ * allocation-free on the hot path.
+ *
+ * The draft-07 tuple spelling needs no guard: there `items` *is* the tuple and
+ * the tail lives in `additionalItems`, which no item check reads.
+ */
+export declare const everyTailItem: (accessor: string, itemCheck: string, schema: JSONSchema) => string;
 /**
  * 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;
+/**
+ * A boolean type check for a single JSON Schema primitive type name. Unlike
+ * {@link scalarItemTypeCheck} this also covers `array`/`object` (as inline shape
+ * checks, so no `isObject` import is assumed) and enforces `integer` with
+ * `Number.isInteger` — a bare `typeof === "number"` accepts `1.5`. Used to build
+ * the disjunction for an array-form `type` (e.g. `["string","null"]`).
+ */
+export declare const singleTypeCheck: (accessor: string, type: string) => string | null;
 /**
  * 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.

package/dist/generators/generate-validation-expression.js

@@ -1,8 +1,8 @@
-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 { multipleOfPassExpr } from "@amritk/helpers/multiple-of-check";
 import { resolveRef } from "@amritk/helpers/resolve-ref";
-import { safeAccessor } from "@amritk/helpers/safe-accessor";
+import { hasOwnCheck, safeAccessor } from "@amritk/helpers/safe-accessor";
 import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMaxProperties, hasMinItems, hasMinimum, hasMinLength, hasMinProperties, hasMultipleOf, hasOneOf, hasPattern, hasProperties, hasRef, hasRequired, hasType, hasUniqueItems, isSchemaObject } from "@amritk/helpers/schema-guards";
 import { findDiscriminator } from "../helpers/find-discriminator.js";
 import { getDefaultValue } from "../helpers/get-default-value.js";
@@ -42,7 +42,14 @@ const getPrefixItems = (schema) => {
   if (!isSchemaObject(schema))
     return null;
   const prefix = schema["prefixItems"];
-  return Array.isArray(prefix) ? prefix : null;
+  if (Array.isArray(prefix))
+    return prefix;
+  return Array.isArray(schema.items) ? schema.items : null;
+};
+const everyTailItem = (accessor, itemCheck, schema) => {
+  const prefix = isSchemaObject(schema) ? schema["prefixItems"] : void 0;
+  const tailStart = Array.isArray(prefix) ? prefix.length : 0;
+  return tailStart === 0 ? `${accessor}.every((_it) => ${itemCheck})` : `${accessor}.every((_it, _ix) => _ix < ${tailStart} || (${itemCheck}))`;
 };
 const prefixItemsCapsLength = (schema) => {
   if (!isSchemaObject(schema))
@@ -204,7 +211,7 @@ const generateValidationExpression = (key, schema, defaultValue, isRequired, roo
       case "string": {
         checks.push(`typeof ${accessor} === "string"`);
         if (hasPattern(schema)) {
-          checks.push(`/${escapeRegexPattern(schema.pattern)}/.test(${accessor})`);
+          checks.push(`${regexLiteral(schema.pattern)}.test(${accessor})`);
         }
         if (hasMinLength(schema)) {
           checks.push(`${accessor}.length >= ${schema.minLength}`);
@@ -260,7 +267,7 @@ const generateValidationExpression = (key, schema, defaultValue, isRequired, roo
         checks.push(`isObject(${accessor})`);
         if (hasRequired(schema) && schema.required.length > 0) {
           for (const requiredKey of schema.required) {
-            checks.push(`${JSON.stringify(requiredKey)} in ${accessor}`);
+            checks.push(hasOwnCheck(accessor, requiredKey));
           }
         }
         if (hasMinProperties(schema)) {
@@ -323,10 +330,12 @@ const generatePrefixItemsMap = (accessor, prefix, capLength, rootSchema, visited
   return capLength ? `${mapped}.slice(0, ${prefix.length})` : mapped;
 };
 export {
+  everyTailItem,
   generatePrefixItemsMap,
   generateValidationExpression,
   getPrefixItems,
   isCoercibleItemSchema,
   prefixItemsCapsLength,
-  scalarItemTypeCheck
+  scalarItemTypeCheck,
+  singleTypeCheck
 };

package/dist/generators/subschema-match.d.ts

@@ -1,4 +1,15 @@
 import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
+/**
+ * What the matcher needs beyond the schema node itself: the root document (to
+ * resolve `$ref`), the recursion depth (which seeds collision-free loop variable
+ * names and caps expression growth), and the `$ref` pointers already open on this
+ * path (a cycle cannot be inlined, so it bails rather than recursing forever).
+ */
+export type MatchContext = {
+    readonly rootSchema?: Record<string, unknown>;
+    readonly depth?: number;
+    readonly seen?: ReadonlySet<string>;
+};
 /**
  * Builds a boolean expression that is `true` *exactly* when `accessor` matches
  * `schema` — sound in **both** directions (true ⇒ valid, false ⇒ invalid) — or
@@ -17,13 +28,21 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * types), so a type-less schema guards each family by its runtime type rather
  * than ignoring it — the subtlety `propertyNames: { maxLength: 3 }` depends on.
  *
- * `depth` seeds the `.every` element variable so nested array matches never
- * shadow one another.
+ * `ctx.depth` seeds the loop variable names so nested walks never shadow one
+ * another, and caps how far the expression may grow.
+ */
+export declare const subschemaMatchExpr: (accessor: string, schema: JSONSchema, ctx?: MatchContext) => string | null;
+/**
+ * True when a `$ref` node carries a keyword that constrains the value on its own.
+ * 2020-12 applies a `$ref`'s siblings alongside the target, so delegating the
+ * whole node to the referenced parser (which knows nothing about them) drops
+ * every one of them — and a fast path built from the target's shape validator
+ * skips them too.
  */
-export declare const subschemaMatchExpr: (accessor: string, schema: JSONSchema, depth?: number) => string | null;
+export declare const hasConstrainingRefSibling: (schema: JSONSchema) => boolean;
 /**
  * Whether {@link subschemaMatchExpr} can build an exact matcher for `schema`.
  * The generation-time guard uses this to decide whether a `contains`,
  * `propertyNames`, or `dependentSchemas` subschema is enforceable.
  */
-export declare const canMatchSubschema: (schema: JSONSchema) => boolean;
+export declare const canMatchSubschema: (schema: JSONSchema, rootSchema?: Record<string, unknown>) => boolean;