@amritk/generate-validators 0.5.1 → 0.7.0

package/README.md

@@ -92,6 +92,30 @@ Returns: `Promise<GeneratedFile[]>` where `GeneratedFile = { filename: string; c
 
 ---
 
+## Benchmarks
+
+Generated validators are straight-line, monomorphic TypeScript with no generic
+dispatch, so they validate as fast as an Ajv-compiled function once emitted —
+and emitting them is far cheaper than compiling a schema at startup. Measured
+on Bun 1.3 (Linux x64), validating valid input at steady state:
+
+| schema | mjst (generated) | ajv (compiled) | typebox (compiled) | zod |
+|:--|--:|--:|--:|--:|
+| small (4 fields) | **~9.5M** ops/s | ~9.3M ops/s | ~4.8M ops/s | ~1.7M ops/s |
+| order (nested + array) | **~3.7M** ops/s | ~3.5M ops/s | ~2.0M ops/s | ~0.4M ops/s |
+
+Preparing a validator costs ~0.15–0.20 ms for mjst codegen and ~0.12–0.21 ms for
+a TypeBox `TypeCompiler` compile, versus ~13–14 ms for an Ajv compile. All four
+libraries agree on every verdict; parity is asserted before timing (TypeBox is
+given uuid/email format checkers so every library does the same work).
+Micro-benchmark figures vary by machine and runtime — reproduce with:
+
+```bash
+bun run bench
+```
+
+---
+
 ## Related packages
 
 - [`@amritk/generate-parsers`](../generate-parsers) — type definitions plus parsers that coerce input

package/dist/generators/build-schema.d.ts

@@ -29,4 +29,3 @@ export type GeneratedFile = {
  * ```
  */
 export declare const buildValidatorSchema: (rootSchema: JSONSchema, rootTypeName: string, typeSuffix?: string) => Promise<GeneratedFile[]>;
-//# sourceMappingURL=build-schema.d.ts.map

package/dist/generators/build-schema.js

@@ -16,6 +16,35 @@ export type ValidationError = {
  * and a list of errors when it is not.
  */
 export type ValidationResult = true | { valid: false; errors: ValidationError[] }
+
+/**
+ * Structural deep equality used by generated \`const\` checks. Objects compare by
+ * their key sets rather than serialization, so \`{ a: 1, b: 2 }\` and
+ * \`{ b: 2, a: 1 }\` are equal — unlike \`JSON.stringify\`, which is key-order
+ * sensitive and would reject a reordered-but-equal value.
+ */
+export const valuesEqual = (a: unknown, b: unknown): boolean => {
+  if (a === b) return true
+  if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null) return false
+  const aArray = Array.isArray(a)
+  const bArray = Array.isArray(b)
+  if (aArray !== bArray) return false
+  if (aArray) {
+    const aa = a as unknown[]
+    const bb = b as unknown[]
+    if (aa.length !== bb.length) return false
+    for (let i = 0; i < aa.length; i++) if (!valuesEqual(aa[i], bb[i])) return false
+    return true
+  }
+  const ao = a as Record<string, unknown>
+  const bo = b as Record<string, unknown>
+  const keys = Object.keys(ao)
+  if (keys.length !== Object.keys(bo).length) return false
+  for (const key of keys) {
+    if (!Object.hasOwn(bo, key) || !valuesEqual(ao[key], bo[key])) return false
+  }
+  return true
+}
 `;
 /**
  * Builds all TypeScript validator files from a JSON Schema by traversing all

package/dist/generators/collect-validator-imports.d.ts

@@ -32,4 +32,3 @@ type CollectValidatorImportsOptions = {
  */
 export declare const collectValidatorImports: (schema: JSONSchema, options?: CollectValidatorImportsOptions) => string[];
 export {};
-//# sourceMappingURL=collect-validator-imports.d.ts.map

package/dist/generators/collect-validator-imports.js

@@ -1,7 +1,7 @@
 import { refToFilename } from '@amritk/helpers/ref-to-filename';
 import { refToName } from '@amritk/helpers/ref-to-name';
 import { resolveRef } from '@amritk/helpers/resolve-ref';
-import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasItems, hasOneOf, hasRef } from '@amritk/helpers/schema-guards';
+import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasItems, hasOneOf, hasProperties, hasRef, } from '@amritk/helpers/schema-guards';
 /**
  * Generates an import statement for a single $ref, importing both the type
  * and the validator function from the ref's generated file.
@@ -43,6 +43,10 @@ const collectDirectRefs = (schema) => {
         if (hasAdditionalProperties(prop) && hasRef(prop.additionalProperties)) {
             refs.push(prop.additionalProperties.$ref);
         }
+        // Inline nested objects are validated recursively by the generator, so any
+        // $refs anywhere inside them must become imports as well.
+        if (hasProperties(prop))
+            refs.push(...collectDirectRefs(prop));
     }
     if (hasItems(schema) && hasRef(schema.items)) {
         refs.push(schema.items.$ref);

package/dist/generators/generate-files.d.ts

@@ -42,4 +42,3 @@ type GenerateValidatorFileOptions = {
  */
 export declare const generateValidatorFile: (schema: JSONSchema, typeName: string, options?: GenerateValidatorFileOptions) => string;
 export {};
-//# sourceMappingURL=generate-files.d.ts.map

package/dist/generators/generate-files.js

@@ -33,6 +33,12 @@ export const generateValidatorFile = (schema, typeName, options) => {
     const typeDefinition = generateTypeDefinition(schema, typeName, { typeSuffix });
     const validatorFunction = generateValidatorFunction(schema, typeName, typeSuffix);
     let result = `import type { ValidationResult, ValidationError } from './validation-result'\n`;
+    // `const` checks on object/array values call the runtime `valuesEqual` helper.
+    // Only import it when the generated body actually uses it, so files without a
+    // structural `const` do not carry an unused import.
+    if (validatorFunction.includes('valuesEqual(')) {
+        result += `import { valuesEqual } from './validation-result'\n`;
+    }
     for (const imp of refImports) {
         result += imp + '\n';
     }

package/dist/generators/generate-validator-function.d.ts

@@ -22,4 +22,3 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * ```
  */
 export declare const generateValidatorFunction: (schema: JSONSchema, typeName: string, suffix?: string) => string;
-//# sourceMappingURL=generate-validator-function.d.ts.map

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

@@ -1,6 +1,7 @@
+import { escapeRegexPattern } from '@amritk/helpers/escape-regex-pattern';
 import { getMjstInstanceOf, getMjstPrimitive } from '@amritk/helpers/mjst-extension';
 import { refToName } from '@amritk/helpers/ref-to-name';
-import { hasAdditionalProperties, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaximum, hasMaxLength, hasMinimum, hasMinLength, hasMultipleOf, hasOneOf, hasPattern, hasProperties, hasRef, hasRequired, hasType, isObjectSchema, isSchemaObject, } from '@amritk/helpers/schema-guards';
+import { hasAdditionalProperties, hasConst, hasDependentRequired, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaximum, hasMaxLength, hasMinimum, hasMinLength, hasMultipleOf, hasOneOf, hasPattern, hasProperties, hasPropertyNames, hasRef, hasRequired, hasStrictExclusiveMaximum, hasStrictExclusiveMinimum, hasType, isObjectSchema, isSchemaObject, } from '@amritk/helpers/schema-guards';
 /**
  * Derives the validator function name from a type name.
  * e.g. "InfoObject" → "validateInfoObject"
@@ -14,6 +15,19 @@ const typeofString = (type) => {
         return 'number';
     return type;
 };
+/**
+ * Generates the inline condition that is TRUE when `accessor` does NOT equal the
+ * `const` value. Primitives compare with `!==`; objects/arrays compare with the
+ * runtime `valuesEqual` helper so a reordered-but-equal value still matches (the
+ * interpreter uses order-independent deep equality, and `JSON.stringify` would
+ * disagree because it is key-order sensitive).
+ */
+const constMismatchCondition = (accessor, value) => {
+    if (value === null || typeof value !== 'object') {
+        return `${accessor} !== ${JSON.stringify(value)}`;
+    }
+    return `!valuesEqual(${accessor}, ${JSON.stringify(value)})`;
+};
 /**
  * Generates the inline condition that is TRUE when a value is the wrong type.
  */
@@ -34,23 +48,57 @@ const wrongTypeCondition = (accessor, type) => {
             return '';
     }
 };
+const createRootContext = () => ({ objVar: 'obj', pathPrefix: '${_path}', depth: 0, hoisted: [] });
+/**
+ * Generates the unknown-key sweep for `additionalProperties: false`, mirroring
+ * the interpreter's behaviour (same error message, one error per extra key).
+ * The known-keys Set is hoisted to module scope and the sweep uses `for...in`
+ * — the same allocation-free shape Ajv compiles to — so the hot path costs one
+ * Set lookup per key. Schemas that combine it with `patternProperties` are
+ * skipped: the generator does not evaluate key patterns yet, so rejecting
+ * every undeclared key would wrongly fail keys the patterns allow.
+ */
+const generateStrictKeyChecks = (schema, ctx) => {
+    if (!isSchemaObject(schema))
+        return [];
+    if (!hasAdditionalProperties(schema) || schema.additionalProperties !== false)
+        return [];
+    if ('patternProperties' in schema)
+        return [];
+    const known = Object.keys(hasProperties(schema) ? schema.properties : {});
+    const setName = `_knownKeys${ctx.hoisted.length}`;
+    ctx.hoisted.push(`const ${setName} = new Set(${JSON.stringify(known)})`);
+    const d = ctx.depth;
+    return [
+        `  for (const _key${d} in ${ctx.objVar}) {`,
+        `    if (!${setName}.has(_key${d})) {`,
+        `      errors.push({ message: 'must NOT have additional properties', path: \`${ctx.pathPrefix}/\${_key${d}}\` })`,
+        `    }`,
+        `  }`,
+    ];
+};
 /**
  * Generates validation lines for a single property in an object schema.
- * Handles $ref delegation, enum checks, type checks, and string/number constraints.
+ * Handles $ref delegation, enum checks, type checks, string/number constraints,
+ * and recursion into inline nested objects.
  */
-const generatePropertyChecks = (key, propSchema, isRequired, suffix) => {
+const generatePropertyChecks = (key, propSchema, isRequired, suffix, ctx) => {
     if (!isSchemaObject(propSchema))
         return [];
-    const raw = `obj[${JSON.stringify(key)}]`;
-    const path = `\`\${_path}/${key}\``;
+    const raw = `${ctx.objVar}[${JSON.stringify(key)}]`;
+    const path = `\`${ctx.pathPrefix}/${key}\``;
+    // Missing-property errors report at the parent object's path. At the root
+    // that is the `_path` parameter itself; inside nested objects it is the
+    // parent's accumulated static path.
+    const parentPath = ctx.depth === 0 ? '_path' : `\`${ctx.pathPrefix}\``;
     const lines = [];
     // $ref — delegate to the imported validator
     if (hasRef(propSchema)) {
         const ref = propSchema.$ref;
         const vName = validatorName(refToName(ref, suffix));
         if (isRequired) {
-            lines.push(`  if (!(${JSON.stringify(key)} in obj)) {`);
-            lines.push(`    errors.push({ message: "must have required property '${key}'", path: _path })`);
+            lines.push(`  if (!(${JSON.stringify(key)} in ${ctx.objVar})) {`);
+            lines.push(`    errors.push({ message: "must have required property '${key}'", path: ${parentPath} })`);
             lines.push(`  } else {`);
             lines.push(`    const _r = ${vName}(${raw}, ${path})`);
             lines.push(`    if (_r !== true) errors.push(..._r.errors)`);
@@ -68,8 +116,8 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix) => {
     const instanceOf = getMjstInstanceOf(propSchema);
     if (instanceOf) {
         if (isRequired) {
-            lines.push(`  if (!(${JSON.stringify(key)} in obj)) {`);
-            lines.push(`    errors.push({ message: "must have required property '${key}'", path: _path })`);
+            lines.push(`  if (!(${JSON.stringify(key)} in ${ctx.objVar})) {`);
+            lines.push(`    errors.push({ message: "must have required property '${key}'", path: ${parentPath} })`);
             lines.push(`  } else if (!(${raw} instanceof ${instanceOf})) {`);
             lines.push(`    errors.push({ message: 'must be ${instanceOf}', path: ${path} })`);
             lines.push(`  }`);
@@ -85,8 +133,8 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix) => {
     const primitive = getMjstPrimitive(propSchema);
     if (primitive) {
         if (isRequired) {
-            lines.push(`  if (!(${JSON.stringify(key)} in obj)) {`);
-            lines.push(`    errors.push({ message: "must have required property '${key}'", path: _path })`);
+            lines.push(`  if (!(${JSON.stringify(key)} in ${ctx.objVar})) {`);
+            lines.push(`    errors.push({ message: "must have required property '${key}'", path: ${parentPath} })`);
             lines.push(`  } else if (typeof ${raw} !== "${primitive}") {`);
             lines.push(`    errors.push({ message: 'must be ${primitive}', path: ${path} })`);
             lines.push(`  }`);
@@ -98,13 +146,31 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix) => {
         }
         return lines;
     }
+    // const — value must equal the fixed value exactly
+    if (hasConst(propSchema)) {
+        const mismatch = constMismatchCondition(raw, propSchema.const);
+        const msg = JSON.stringify(`must be ${JSON.stringify(propSchema.const)}`);
+        if (isRequired) {
+            lines.push(`  if (!(${JSON.stringify(key)} in ${ctx.objVar})) {`);
+            lines.push(`    errors.push({ message: "must have required property '${key}'", path: ${parentPath} })`);
+            lines.push(`  } else if (${mismatch}) {`);
+            lines.push(`    errors.push({ message: ${msg}, path: ${path} })`);
+            lines.push(`  }`);
+        }
+        else {
+            lines.push(`  if (${raw} !== undefined && ${mismatch}) {`);
+            lines.push(`    errors.push({ message: ${msg}, path: ${path} })`);
+            lines.push(`  }`);
+        }
+        return lines;
+    }
     // enum
     if (hasEnum(propSchema)) {
         const allowed = JSON.stringify(propSchema.enum);
         const label = propSchema.enum.map((v) => JSON.stringify(v)).join(', ');
         if (isRequired) {
-            lines.push(`  if (!(${JSON.stringify(key)} in obj)) {`);
-            lines.push(`    errors.push({ message: "must have required property '${key}'", path: _path })`);
+            lines.push(`  if (!(${JSON.stringify(key)} in ${ctx.objVar})) {`);
+            lines.push(`    errors.push({ message: "must have required property '${key}'", path: ${parentPath} })`);
             lines.push(`  } else if (!(${allowed} as unknown[]).includes(${raw})) {`);
             lines.push(`    errors.push({ message: \`must be one of: ${label}\`, path: ${path} })`);
             lines.push(`  }`);
@@ -122,8 +188,8 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix) => {
         const wrongType = wrongTypeCondition(raw, t);
         const typLabel = typeofString(t);
         if (isRequired) {
-            lines.push(`  if (!(${JSON.stringify(key)} in obj)) {`);
-            lines.push(`    errors.push({ message: "must have required property '${key}'", path: _path })`);
+            lines.push(`  if (!(${JSON.stringify(key)} in ${ctx.objVar})) {`);
+            lines.push(`    errors.push({ message: "must have required property '${key}'", path: ${parentPath} })`);
             if (wrongType) {
                 lines.push(`  } else if (${wrongType}) {`);
                 lines.push(`    errors.push({ message: 'must be ${typLabel}', path: ${path} })`);
@@ -138,8 +204,10 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix) => {
         // String constraints
         if (t === 'string') {
             if (hasPattern(propSchema)) {
-                lines.push(`  if (typeof ${raw} === 'string' && !/${propSchema.pattern}/.test(${raw})) {`);
-                lines.push(`    errors.push({ message: 'must match pattern ${propSchema.pattern}', path: ${path} })`);
+                const re = escapeRegexPattern(propSchema.pattern);
+                const msg = JSON.stringify(`must match pattern ${propSchema.pattern}`);
+                lines.push(`  if (typeof ${raw} === 'string' && !/${re}/.test(${raw})) {`);
+                lines.push(`    errors.push({ message: ${msg}, path: ${path} })`);
                 lines.push(`  }`);
             }
             if (hasMinLength(propSchema)) {
@@ -156,13 +224,20 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix) => {
         // Number constraints
         if (t === 'number' || t === 'integer') {
             if (hasMinimum(propSchema)) {
-                lines.push(`  if (typeof ${raw} === 'number' && ${raw} < ${propSchema.minimum}) {`);
-                lines.push(`    errors.push({ message: 'must be >= ${propSchema.minimum}', path: ${path} })`);
+                // Draft-04 `exclusiveMinimum: true` makes the paired `minimum` strict.
+                const strict = hasStrictExclusiveMinimum(propSchema);
+                const op = strict ? '<=' : '<';
+                const rel = strict ? '>' : '>=';
+                lines.push(`  if (typeof ${raw} === 'number' && ${raw} ${op} ${propSchema.minimum}) {`);
+                lines.push(`    errors.push({ message: 'must be ${rel} ${propSchema.minimum}', path: ${path} })`);
                 lines.push(`  }`);
             }
             if (hasMaximum(propSchema)) {
-                lines.push(`  if (typeof ${raw} === 'number' && ${raw} > ${propSchema.maximum}) {`);
-                lines.push(`    errors.push({ message: 'must be <= ${propSchema.maximum}', path: ${path} })`);
+                const strict = hasStrictExclusiveMaximum(propSchema);
+                const op = strict ? '>=' : '>';
+                const rel = strict ? '<' : '<=';
+                lines.push(`  if (typeof ${raw} === 'number' && ${raw} ${op} ${propSchema.maximum}) {`);
+                lines.push(`    errors.push({ message: 'must be ${rel} ${propSchema.maximum}', path: ${path} })`);
                 lines.push(`  }`);
             }
             if (hasExclusiveMinimum(propSchema)) {
@@ -188,7 +263,7 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix) => {
                 const vName = validatorName(refToName(itemSchema.$ref, suffix));
                 lines.push(`  if (Array.isArray(${raw})) {`);
                 lines.push(`    for (let _i = 0; _i < ${raw}.length; _i++) {`);
-                lines.push(`      const _ir = ${vName}(${raw}[_i], \`${path.slice(1, -1)}/${key}/\${_i}\`)`);
+                lines.push(`      const _ir = ${vName}(${raw}[_i], \`${path.slice(1, -1)}/\${_i}\`)`);
                 lines.push(`      if (_ir !== true) errors.push(..._ir.errors)`);
                 lines.push(`    }`);
                 lines.push(`  }`);
@@ -201,15 +276,100 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix) => {
                     lines.push(`  if (Array.isArray(${raw})) {`);
                     lines.push(`    for (let _i = 0; _i < ${raw}.length; _i++) {`);
                     lines.push(`      const _item = ${raw}[_i]`);
-                    lines.push(`      if (${itemWrong}) errors.push({ message: 'items must be ${itemLabel}', path: \`${path.slice(1, -1)}/${key}/\${_i}\` })`);
+                    lines.push(`      if (${itemWrong}) errors.push({ message: 'items must be ${itemLabel}', path: \`${path.slice(1, -1)}/\${_i}\` })`);
                     lines.push(`    }`);
                     lines.push(`  }`);
                 }
             }
         }
+        // Inline nested object — recurse so the nested fields are actually
+        // validated. Without this only the "must be object" shape check above
+        // runs and everything inside the nested object silently passes.
+        if (t === 'object') {
+            lines.push(...generateInlineObjectChecks(key, propSchema, raw, suffix, ctx));
+        }
     }
     return lines;
 };
+/**
+ * Generates the recursive checks for an inline nested object property, i.e. an
+ * object schema written directly under `properties` rather than referenced via
+ * `$ref` (those delegate to the referenced validator instead). The value is
+ * narrowed into its own block-scoped variable and each nested property runs
+ * through the same per-property generator, so nesting works to any depth.
+ */
+const generateInlineObjectChecks = (key, propSchema, raw, suffix, ctx) => {
+    if (!isSchemaObject(propSchema))
+        return [];
+    const child = {
+        objVar: `_obj${ctx.depth + 1}`,
+        pathPrefix: `${ctx.pathPrefix}/${key}`,
+        depth: ctx.depth + 1,
+        hoisted: ctx.hoisted,
+    };
+    const required = new Set(hasRequired(propSchema) ? propSchema.required : []);
+    const properties = hasProperties(propSchema) ? propSchema.properties : {};
+    const innerLines = [];
+    for (const [childKey, childSchema] of Object.entries(properties)) {
+        innerLines.push(...generatePropertyChecks(childKey, childSchema, required.has(childKey), suffix, child));
+    }
+    innerLines.push(...generateStrictKeyChecks(propSchema, child));
+    if (innerLines.length === 0)
+        return [];
+    // The shape check for the property itself already ran (or the property is
+    // optional), so re-guard here instead of assuming the value is an object.
+    return [
+        `  if (typeof ${raw} === 'object' && ${raw} !== null && !Array.isArray(${raw})) {`,
+        `    const ${child.objVar} = ${raw} as Record<string, unknown>`,
+        ...innerLines.map((line) => `  ${line}`),
+        `  }`,
+    ];
+};
+/**
+ * Generates the `propertyNames` loop: every object key is a string, so we apply
+ * the string-relevant constraints of the subschema (or delegate to a `$ref`'s
+ * validator). This keeps the generator in step with the interpreter, which runs
+ * the whole subschema against each key — not just the `pattern` form.
+ */
+const generatePropertyNameChecks = (nameSchema, suffix) => {
+    if (!isSchemaObject(nameSchema))
+        return [];
+    const at = '`${_path}/${_name}`';
+    const checks = [];
+    if (hasRef(nameSchema)) {
+        const vName = validatorName(refToName(nameSchema.$ref, suffix));
+        checks.push(`    const _nr = ${vName}(_name, ${at})`);
+        checks.push(`    if (_nr !== true) errors.push(..._nr.errors)`);
+    }
+    else {
+        if (hasPattern(nameSchema)) {
+            const re = escapeRegexPattern(nameSchema.pattern);
+            const msg = JSON.stringify(`property name must match pattern ${nameSchema.pattern}`);
+            checks.push(`    if (!/${re}/.test(_name)) errors.push({ message: ${msg}, path: ${at} })`);
+        }
+        if (hasMinLength(nameSchema)) {
+            const msg = JSON.stringify(`property name must have at least ${nameSchema.minLength} characters`);
+            checks.push(`    if (_name.length < ${nameSchema.minLength}) errors.push({ message: ${msg}, path: ${at} })`);
+        }
+        if (hasMaxLength(nameSchema)) {
+            const msg = JSON.stringify(`property name must have at most ${nameSchema.maxLength} characters`);
+            checks.push(`    if (_name.length > ${nameSchema.maxLength}) errors.push({ message: ${msg}, path: ${at} })`);
+        }
+        if (hasEnum(nameSchema)) {
+            const allowed = JSON.stringify(nameSchema.enum);
+            const label = nameSchema.enum.map((v) => JSON.stringify(v)).join(', ');
+            const msg = JSON.stringify(`property name must be one of: ${label}`);
+            checks.push(`    if (!(${allowed} as unknown[]).includes(_name)) errors.push({ message: ${msg}, path: ${at} })`);
+        }
+        if (hasConst(nameSchema)) {
+            const msg = JSON.stringify(`property name must be ${JSON.stringify(nameSchema.const)}`);
+            checks.push(`    if (_name !== ${JSON.stringify(nameSchema.const)}) errors.push({ message: ${msg}, path: ${at} })`);
+        }
+    }
+    if (checks.length === 0)
+        return [];
+    return [`  for (const _name of Object.keys(obj)) {`, ...checks, `  }`];
+};
 /**
  * Generates a validator function body for an object schema, checking each
  * property's presence and type and collecting all errors.
@@ -218,9 +378,10 @@ const generateObjectValidator = (schema, typeName, suffix) => {
     const vName = validatorName(typeName);
     const required = new Set(hasRequired(schema) ? schema.required : []);
     const properties = hasProperties(schema) ? schema.properties : {};
+    const ctx = createRootContext();
     const propertyLines = [];
     for (const [key, propSchema] of Object.entries(properties)) {
-        const checks = generatePropertyChecks(key, propSchema, required.has(key), suffix);
+        const checks = generatePropertyChecks(key, propSchema, required.has(key), suffix, ctx);
         if (checks.length > 0) {
             propertyLines.push(...checks);
         }
@@ -236,9 +397,32 @@ const generateObjectValidator = (schema, typeName, suffix) => {
         propertyLines.push(`    if (_r !== true) errors.push(..._r.errors)`);
         propertyLines.push(`  }`);
     }
+    // additionalProperties: false rejects every key not declared in properties
+    propertyLines.push(...generateStrictKeyChecks(schema, ctx));
+    // dependentRequired — when a trigger property is present, its dependencies must be too.
+    if (hasDependentRequired(schema)) {
+        for (const [trigger, deps] of Object.entries(schema.dependentRequired)) {
+            if (!Array.isArray(deps))
+                continue;
+            for (const dep of deps) {
+                const msg = JSON.stringify(`must have property '${dep}' when '${trigger}' is present`);
+                propertyLines.push(`  if (${JSON.stringify(trigger)} in obj && !(${JSON.stringify(dep)} in obj)) {`);
+                propertyLines.push(`    errors.push({ message: ${msg}, path: _path })`);
+                propertyLines.push(`  }`);
+            }
+        }
+    }
+    // propertyNames — every key (always a string) must satisfy the subschema. This
+    // mirrors the interpreter, which runs the full subschema against each key.
+    if (hasPropertyNames(schema) && isSchemaObject(schema.propertyNames)) {
+        propertyLines.push(...generatePropertyNameChecks(schema.propertyNames, suffix));
+    }
     const body = propertyLines.length > 0 ? '\n' + propertyLines.join('\n') + '\n' : '';
+    // Hoisted statements (e.g. known-keys Sets) come first so every call of the
+    // validator reuses them instead of rebuilding them.
+    const hoistedBlock = ctx.hoisted.length > 0 ? `${ctx.hoisted.join('\n')}\n\n` : '';
     return [
-        `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+        `${hoistedBlock}export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
         `  if (typeof input !== 'object' || input === null || Array.isArray(input)) {`,
         `    return { valid: false, errors: [{ message: 'must be object', path: _path }] }`,
         `  }`,
@@ -291,6 +475,19 @@ const generateScalarValidator = (schema, typeName, suffix) => {
             `}`,
         ].join('\n');
     }
+    // Top-level const
+    if (hasConst(schema)) {
+        const mismatch = constMismatchCondition('input', schema.const);
+        const msg = JSON.stringify(`must be ${JSON.stringify(schema.const)}`);
+        return [
+            `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+            `  if (${mismatch}) {`,
+            `    return { valid: false, errors: [{ message: ${msg}, path: _path }] }`,
+            `  }`,
+            `  return true`,
+            `}`,
+        ].join('\n');
+    }
     // Top-level enum
     if (hasEnum(schema)) {
         const allowed = JSON.stringify(schema.enum);
@@ -330,8 +527,10 @@ const generateScalarValidator = (schema, typeName, suffix) => {
         const constraintLines = [];
         if (t === 'string') {
             if (hasPattern(schema)) {
-                constraintLines.push(`  if (typeof input === 'string' && !/${schema.pattern}/.test(input)) {`);
-                constraintLines.push(`    errors.push({ message: 'must match pattern ${schema.pattern}', path: _path })`);
+                const re = escapeRegexPattern(schema.pattern);
+                const msg = JSON.stringify(`must match pattern ${schema.pattern}`);
+                constraintLines.push(`  if (typeof input === 'string' && !/${re}/.test(input)) {`);
+                constraintLines.push(`    errors.push({ message: ${msg}, path: _path })`);
                 constraintLines.push(`  }`);
             }
             if (hasMinLength(schema)) {

package/dist/index.d.ts

@@ -1,3 +1,2 @@
 export type { GeneratedFile } from './generators/build-schema.js';
 export { buildValidatorSchema } from './generators/build-schema.js';
-//# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-validators",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "description": "Generate TypeScript validation functions from JSON Schemas.",
   "module": "./dist/index.js",
   "type": "module",
@@ -24,8 +24,7 @@
     "url": "https://github.com/amritk/mjst/issues"
   },
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
   "publishConfig": {
     "access": "public"
@@ -33,23 +32,27 @@
   "scripts": {
     "build": "tsgo -p tsconfig.build.json && tsc-alias -p tsconfig.build.json -f",
     "types:check": "tsgo -p . --noEmit",
-    "test": "NODE_ENV=production vitest run --root ../.. generate-validators"
+    "test": "NODE_ENV=production vitest run --root ../.. generate-validators",
+    "bench": "bun run ./bench/run.ts"
   },
   "imports": {
     "#generators/*": "./src/generators/*.ts"
   },
   "exports": {
     ".": {
-      "development": "./src/index.ts",
       "default": "./dist/index.js",
       "types": "./dist/index.d.ts"
     }
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "0.7.1"
+    "@amritk/helpers": "0.9.0"
   },
   "devDependencies": {
-    "@scalar/openapi-parser": "^0.26.1"
+    "@scalar/openapi-parser": "^0.26.1",
+    "@sinclair/typebox": "^0.34.49",
+    "ajv": "^8.17.1",
+    "ajv-formats": "^3.0.1",
+    "zod": "^4.4.3"
   }
 }

package/dist/generators/build-schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"build-schema.d.ts","sourceRoot":"","sources":["../../src/generators/build-schema.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAIjE;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAmBD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,oBAAoB,eACnB,UAAU,gBACR,MAAM,0BAEnB,OAAO,CAAC,aAAa,EAAE,CAuBzB,CAAA"}

package/dist/generators/collect-validator-imports.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"collect-validator-imports.d.ts","sourceRoot":"","sources":["../../src/generators/collect-validator-imports.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAEjE;;GAEG;AACH,KAAK,8BAA8B,GAAG;IACpC;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACrC;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAA;IACzD;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAC7B,CAAA;AAoED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,uBAAuB,WAAY,UAAU,YAAY,8BAA8B,KAAG,MAAM,EA6B5G,CAAA"}

package/dist/generators/generate-files.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate-files.d.ts","sourceRoot":"","sources":["../../src/generators/generate-files.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAKjE;;GAEG;AACH,KAAK,4BAA4B,GAAG;IAClC;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;IACzB;;OAEG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC7C;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAC7B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,qBAAqB,WACxB,UAAU,YACR,MAAM,YACN,4BAA4B,KACrC,MA0BF,CAAA"}

package/dist/generators/generate-validator-function.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate-validator-function.d.ts","sourceRoot":"","sources":["../../src/generators/generate-validator-function.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAqajE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,yBAAyB,WAAY,UAAU,YAAY,MAAM,sBAAgB,MAM7F,CAAA"}

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAC9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA"}