@amritk/generate-validators 0.6.0 → 0.8.0

package/README.md

@@ -92,6 +92,43 @@ Returns: `Promise<GeneratedFile[]>` where `GeneratedFile = { filename: string; c
 
 ---
 
+## Benchmarks
+
+Generated validators are straight-line, monomorphic TypeScript with no generic
+dispatch. On the happy path they run a single allocation-free boolean guard — a
+pure `&&` chain of `typeof` checks (plus an `Object.keys().length` count when an
+object is closed with `additionalProperties: false`) — and only fall back to the
+error-collecting body when something is actually wrong. That makes a valid-input
+check as cheap as TypeBox's compiled checker while still emitting full
+JSON-Pointer errors for invalid input, and emitting the validator stays 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) | **~37M** ops/s | ~10M ops/s | ~4.9M ops/s | ~2.0M ops/s |
+| order (nested + array) | **~11M** ops/s | ~3.7M ops/s | ~2.0M ops/s | ~0.5M ops/s |
+| assert-loose | **~67M** ops/s | ~40M ops/s | ~57M ops/s | ~3.2M ops/s |
+| assert-strict | **~47M** ops/s | ~19M ops/s | ~36M ops/s | ~1.3M ops/s |
+
+The `assert-loose` / `assert-strict` rows are the exact shape used by
+[`moltar/typescript-runtime-type-benchmarks`](https://github.com/moltar/typescript-runtime-type-benchmarks)
+(seven scalar roots plus a nested object); the boolean guard lets mjst edge out
+TypeBox's compiled checker on both, with and without `additionalProperties:
+false`.
+
+Preparing a validator costs ~0.1 ms for mjst codegen and ~0.05–0.12 ms for a
+TypeBox `TypeCompiler` compile, versus ~8–10 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,7 +1,8 @@
 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, hasConst, hasDependentRequired, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaximum, hasMaxLength, hasMinimum, hasMinLength, hasMultipleOf, hasOneOf, hasPattern, hasProperties, hasPropertyNames, 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';
+import { unknownKeyCheck } from '@amritk/helpers/unknown-key-check';
 /**
  * Derives the validator function name from a type name.
  * e.g. "InfoObject" → "validateInfoObject"
@@ -17,15 +18,16 @@ const typeofString = (type) => {
 };
 /**
  * Generates the inline condition that is TRUE when `accessor` does NOT equal the
- * `const` value. Primitives compare with `!==`; objects/arrays compare by their
- * canonical JSON serialization (sufficient for the literal, fixed shapes `const`
- * is used for).
+ * `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 `JSON.stringify(${accessor}) !== ${JSON.stringify(JSON.stringify(value))}`;
+    return `!valuesEqual(${accessor}, ${JSON.stringify(value)})`;
 };
 /**
  * Generates the inline condition that is TRUE when a value is the wrong type.
@@ -47,23 +49,79 @@ const wrongTypeCondition = (accessor, type) => {
             return '';
     }
 };
+const createRootContext = () => ({ objVar: 'obj', pathPrefix: '${_path}', depth: 0, hoisted: [] });
+/**
+ * Returns the `patternProperties` regex sources, or an empty array when the
+ * schema declares none. The keys of `patternProperties` are the patterns.
+ */
+const patternPropertySources = (schema) => {
+    if (!isSchemaObject(schema) || !('patternProperties' in schema))
+        return [];
+    const patterns = schema.patternProperties;
+    if (typeof patterns !== 'object' || patterns === null)
+        return [];
+    return Object.keys(patterns);
+};
+/**
+ * Generates the unknown-key sweep for `additionalProperties: false`, mirroring
+ * the interpreter's behaviour (same error message, one error per extra key).
+ * The sweep uses `for...in` — the same allocation-free shape Ajv compiles to.
+ * The per-key "is this declared" test comes from `unknownKeyCheck`, which
+ * inlines `!==` comparisons for small key counts (faster than `Set.has` and
+ * allocation-free) and hoists a known-keys `Set` only when the list is long.
+ * When the schema also declares `patternProperties`, a key matching any pattern
+ * is not "additional": the patterns are compiled once at module scope (the same
+ * regex-caching the interpreter does) and a key survives the sweep if it is a
+ * known key or matches any pattern.
+ */
+const generateStrictKeyChecks = (schema, ctx) => {
+    if (!isSchemaObject(schema))
+        return [];
+    if (!hasAdditionalProperties(schema) || schema.additionalProperties !== false)
+        return [];
+    const known = Object.keys(hasProperties(schema) ? schema.properties : {});
+    const d = ctx.depth;
+    const check = unknownKeyCheck(known, `_knownKeys${ctx.hoisted.length}`);
+    ctx.hoisted.push(...check.declarations);
+    // A key that matches any `patternProperties` regex is allowed, so only keys
+    // outside both the known keys and every pattern count as additional.
+    const patterns = patternPropertySources(schema);
+    let patternGuard = '';
+    if (patterns.length > 0) {
+        const patternsName = `_patterns${ctx.hoisted.length}`;
+        ctx.hoisted.push(`const ${patternsName} = [${patterns.map((p) => `new RegExp(${JSON.stringify(p)})`).join(', ')}]`);
+        patternGuard = ` && !${patternsName}.some((re) => re.test(_key${d}))`;
+    }
+    return [
+        `  for (const _key${d} in ${ctx.objVar}) {`,
+        `    if (${check.isUnknown(`_key${d}`)}${patternGuard}) {`,
+        `      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)`);
@@ -81,8 +139,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(`  }`);
@@ -98,8 +156,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(`  }`);
@@ -116,8 +174,8 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix) => {
         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 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 (${mismatch}) {`);
             lines.push(`    errors.push({ message: ${msg}, path: ${path} })`);
             lines.push(`  }`);
@@ -134,8 +192,8 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix) => {
         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(`  }`);
@@ -153,8 +211,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} })`);
@@ -189,13 +247,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)) {
@@ -221,7 +286,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(`  }`);
@@ -234,15 +299,207 @@ 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, `  }`];
+};
+/**
+ * Builds the `&&` conditions that prove a single property is valid, or `null`
+ * when the property carries any keyword the slow path enforces beyond a bare
+ * type check (pattern, min/max, enum, const, `$ref`, items, x-mjst, …). A `null`
+ * makes the whole guard bail so that input still flows through the slow,
+ * error-collecting path — the guard only ever returns true for *provably* valid
+ * input, never weakening a verdict. `objAcc` is the expression yielding the
+ * parent object (already narrowed to a record); `key` indexes into it.
+ */
+const guardPropConditions = (key, propSchema, objAcc) => {
+    if (!isSchemaObject(propSchema))
+        return null;
+    const raw = `${objAcc}[${JSON.stringify(key)}]`;
+    // Anything the slow path enforces past a typeof is cheaper to leave to the
+    // slow path than to mirror here, so bail and keep the guard sound.
+    if (hasRef(propSchema) ||
+        hasEnum(propSchema) ||
+        hasConst(propSchema) ||
+        hasOneOf(propSchema) ||
+        getMjstInstanceOf(propSchema) !== undefined ||
+        getMjstPrimitive(propSchema) !== undefined ||
+        hasPattern(propSchema) ||
+        hasMinLength(propSchema) ||
+        hasMaxLength(propSchema) ||
+        hasMinimum(propSchema) ||
+        hasMaximum(propSchema) ||
+        hasExclusiveMinimum(propSchema) ||
+        hasExclusiveMaximum(propSchema) ||
+        hasMultipleOf(propSchema) ||
+        hasItems(propSchema)) {
+        return null;
+    }
+    if (!hasType(propSchema))
+        return null;
+    switch (propSchema.type) {
+        case 'string':
+            return [`typeof ${raw} === 'string'`];
+        // mjst treats `integer` like `number` (it never enforces integrality), so a
+        // `typeof === 'number'` guard matches the slow path's verdict exactly.
+        case 'number':
+        case 'integer':
+            return [`typeof ${raw} === 'number'`];
+        case 'boolean':
+            return [`typeof ${raw} === 'boolean'`];
+        case 'object':
+            // Member access into the nested record is only reached after the shape
+            // check ahead of it in the `&&` chain, so the cast is always safe.
+            return guardObjectConditions(propSchema, raw, `(${raw} as Record<string, unknown>)`);
+        // Arrays need a per-item loop the guard can't express, and any other type
+        // (null, multi-type, untyped) is left to the slow path.
+        default:
+            return null;
+    }
+};
+/**
+ * Builds the allocation-free boolean guard for an object schema as a list of
+ * `&&` conditions, or `null` when the schema can't be proven valid by a cheap
+ * expression. The conditions are ordered so every member access is guarded by
+ * the object-shape check that precedes it in the `&&` chain.
+ *
+ * The guard only handles the happy path: every declared property must be
+ * required and a bare-typed scalar or a likewise-guardable nested object. Any
+ * optional property, object-level constraint the slow path enforces
+ * (`patternProperties`, `propertyNames`, `dependentRequired`, an
+ * `additionalProperties` *schema*), or unguardable property makes it bail, and
+ * the validator falls back to its full error-collecting body.
+ */
+const guardObjectConditions = (schema, raw, objAcc) => {
+    if (!isObjectSchema(schema))
+        return null;
+    if (hasDependentRequired(schema) || hasPropertyNames(schema))
+        return null;
+    if (isSchemaObject(schema) && 'patternProperties' in schema)
+        return null;
+    let strict = false;
+    if (hasAdditionalProperties(schema)) {
+        // Only `additionalProperties: false` is guardable (via the key-count trick
+        // below); an additional-properties *schema* needs per-key validation.
+        if (schema.additionalProperties === false)
+            strict = true;
+        else
+            return null;
+    }
+    const required = new Set(hasRequired(schema) ? schema.required : []);
+    const properties = hasProperties(schema) ? schema.properties : {};
+    const keys = Object.keys(properties);
+    const conditions = [`typeof ${raw} === 'object' && ${raw} !== null && !Array.isArray(${raw})`];
+    for (const key of keys) {
+        // An optional property would need an `=== undefined ||` branch and breaks
+        // the key-count trick, so the guard only covers all-required objects.
+        if (!required.has(key))
+            return null;
+        const propConditions = guardPropConditions(key, properties[key], objAcc);
+        if (propConditions === null)
+            return null;
+        conditions.push(...propConditions);
+    }
+    if (strict) {
+        // `additionalProperties: false` with every declared property required: once
+        // the typeof checks confirm each key is present, an exact key count proves
+        // there are no extras — TypeBox's trick, with no loop and no Set.
+        if (!keys.every((key) => required.has(key)))
+            return null;
+        conditions.push(`Object.keys(${objAcc}).length === ${keys.length}`);
+    }
+    return conditions;
+};
 /**
  * Generates a validator function body for an object schema, checking each
  * property's presence and type and collecting all errors.
@@ -251,9 +508,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);
         }
@@ -269,6 +527,8 @@ 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)) {
@@ -282,26 +542,35 @@ const generateObjectValidator = (schema, typeName, suffix) => {
             }
         }
     }
-    // propertyNames with a pattern — every key must match. (Only the pattern form
-    // is emitted; a $ref/complex propertyNames schema is left to runtime validation.)
-    if (hasPropertyNames(schema) && isSchemaObject(schema.propertyNames) && hasPattern(schema.propertyNames)) {
-        const re = escapeRegexPattern(schema.propertyNames.pattern);
-        const msg = JSON.stringify(`property name must match pattern ${schema.propertyNames.pattern}`);
-        propertyLines.push(`  for (const _name of Object.keys(obj)) {`);
-        propertyLines.push(`    if (!/${re}/.test(_name)) {`);
-        propertyLines.push(`      errors.push({ message: ${msg}, path: \`\${_path}/\${_name}\` })`);
-        propertyLines.push(`    }`);
-        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` : '';
+    // A pure boolean guard for the happy path: when every property is present and
+    // well-typed (and, for strict objects, there are no extras) it returns true
+    // without allocating an `errors` array or walking the slow path. It returns
+    // true only for provably valid input; anything it can't prove cheaply falls
+    // through to the error-collecting body below, which produces the same verdict
+    // and full JSON-Pointer errors. Schemas with constraints the guard can't
+    // express produce no guard at all (`null`), leaving behaviour unchanged.
+    const guard = guardObjectConditions(schema, 'input', 'obj');
+    const guardBlock = guard
+        ? [`  if (`, guard.map((condition) => `    ${condition}`).join(' &&\n'), `  ) {`, `    return true`, `  }`, ``]
+        : [];
     return [
-        `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+        `${hoistedBlock}export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+        `  const obj = input as Record<string, unknown>`,
+        ...guardBlock,
         `  if (typeof input !== 'object' || input === null || Array.isArray(input)) {`,
         `    return { valid: false, errors: [{ message: 'must be object', path: _path }] }`,
         `  }`,
         ``,
         `  const errors: ValidationError[] = []`,
-        `  const obj = input as Record<string, unknown>`,
         body,
         `  return errors.length > 0 ? { valid: false, errors } : true`,
         `}`,

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