@amritk/generate-validators 0.8.0 → 0.10.0

package/README.md

@@ -95,33 +95,39 @@ 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 |
+dispatch. The exported `validateX` is split into a hot and a cold half: on the
+happy path it runs 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 `return true`s straight away, only
+calling a separate error-collecting function when something is actually wrong.
+Keeping the hot function tiny lets V8 optimise it aggressively, so a valid-input
+check beats every other library measured — including the build-time transformer
+typia — 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) | typia (transformed) | ajv (compiled) | typebox (compiled) | zod |
+|:--|--:|--:|--:|--:|--:|
+| small (4 fields) | **~22M** ops/s | ~4.2M ops/s | ~7.0M ops/s | ~4.0M ops/s | ~1.8M ops/s |
+| order (nested + array) | **~6.9M** ops/s | ~1.7M ops/s | ~2.5M ops/s | ~1.7M ops/s | ~0.4M ops/s |
+| assert-loose | **~110M** ops/s | ~100M ops/s | ~31M ops/s | ~41M ops/s | ~3.2M ops/s |
+| assert-strict | **~98M** ops/s | ~82M ops/s | ~13M ops/s | ~28M ops/s | ~1.1M 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`.
+(seven scalar roots plus a nested object); the boolean guard lets mjst edge past
+typia on both, with and without `additionalProperties: false`. (typia and
+TypeBox still win the *invalid* path, where they bail on the first error rather
+than collecting a full error list.)
 
 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:
+TypeBox `TypeCompiler` compile, versus ~8–10 ms for an Ajv compile. Every library
+agrees on every verdict; parity is asserted before timing (TypeBox is given
+uuid/email format checkers so every library does the same work). Each library is
+timed in an isolated process over a pool of distinct inputs, reporting the median
+of many trials — so the optimiser can't hoist or eliminate the work and the
+numbers stay reproducible. Micro-benchmark figures vary by machine and runtime —
+reproduce with:
 
 ```bash
 bun run bench

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

@@ -25,7 +25,8 @@ type GenerateValidatorFileOptions = {
  * - Imports for the ValidationResult/ValidationError types
  * - Imports for any $ref types and their validator functions
  * - The exported TypeScript type definition
- * - The exported validator function
+ * - The exported validator function (`validateX`, rich `ValidationResult`)
+ * - The exported boolean type-guard (`isX`, a flat `input is X` predicate)
  *
  * @example
  * ```typescript
@@ -38,6 +39,7 @@ type GenerateValidatorFileOptions = {
  * // import type { ValidationResult, ValidationError } from './validation-result'
  * // export type Info = { title: string }
  * // export const validateInfo = (input: unknown, _path = ''): ValidationResult => { ... }
+ * // export const isInfo = (input: unknown): input is Info => { ... }
  * ```
  */
 export declare const generateValidatorFile: (schema: JSONSchema, typeName: string, options?: GenerateValidatorFileOptions) => string;

package/dist/generators/generate-files.js

@@ -1,6 +1,6 @@
 import { generateTypeDefinition } from '@amritk/helpers/generate-type-definition';
 import { collectValidatorImports } from './collect-validator-imports.js';
-import { generateValidatorFunction } from './generate-validator-function.js';
+import { generateBooleanGuard, generateValidatorFunction } from './generate-validator-function.js';
 /**
  * Generates a complete TypeScript validator file from a JSON Schema.
  *
@@ -8,7 +8,8 @@ import { generateValidatorFunction } from './generate-validator-function.js';
  * - Imports for the ValidationResult/ValidationError types
  * - Imports for any $ref types and their validator functions
  * - The exported TypeScript type definition
- * - The exported validator function
+ * - The exported validator function (`validateX`, rich `ValidationResult`)
+ * - The exported boolean type-guard (`isX`, a flat `input is X` predicate)
  *
  * @example
  * ```typescript
@@ -21,6 +22,7 @@ import { generateValidatorFunction } from './generate-validator-function.js';
  * // import type { ValidationResult, ValidationError } from './validation-result'
  * // export type Info = { title: string }
  * // export const validateInfo = (input: unknown, _path = ''): ValidationResult => { ... }
+ * // export const isInfo = (input: unknown): input is Info => { ... }
  * ```
  */
 export const generateValidatorFile = (schema, typeName, options) => {
@@ -32,6 +34,7 @@ export const generateValidatorFile = (schema, typeName, options) => {
     });
     const typeDefinition = generateTypeDefinition(schema, typeName, { typeSuffix });
     const validatorFunction = generateValidatorFunction(schema, typeName, typeSuffix);
+    const booleanGuard = generateBooleanGuard(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
@@ -48,6 +51,6 @@ export const generateValidatorFile = (schema, typeName, options) => {
     else {
         result += '\n';
     }
-    result += typeDefinition + '\n\n' + validatorFunction;
+    result += typeDefinition + '\n\n' + validatorFunction + '\n\n' + booleanGuard;
     return result;
 };

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

@@ -1,4 +1,15 @@
 import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
+/**
+ * Generates the exported boolean type-guard `isTypeName(input): input is TypeName`.
+ *
+ * Unlike `validateTypeName` (which returns rich `ValidationResult` errors), this
+ * is a single flat boolean predicate — no error array, no cold-path call — so V8
+ * inlines it like a hand-written `check`, matching the shape of TypeBox's
+ * compiled checker. It returns the *same verdict* as the validator. When the
+ * schema carries anything the flat form can't mirror exactly, it falls back to
+ * `validateTypeName(input) === true`, which is always correct.
+ */
+export declare const generateBooleanGuard: (schema: JSONSchema, typeName: string, _suffix?: string) => string;
 /**
  * Generates a TypeScript validator function from a JSON Schema.
  *

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 { safeAccessor } from '@amritk/helpers/safe-accessor';
 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';
 /**
@@ -405,7 +406,8 @@ const generatePropertyNameChecks = (nameSchema, suffix) => {
 const guardPropConditions = (key, propSchema, objAcc) => {
     if (!isSchemaObject(propSchema))
         return null;
-    const raw = `${objAcc}[${JSON.stringify(key)}]`;
+    // Dotted access (`obj.number`) for identifier keys, bracket access otherwise.
+    const raw = safeAccessor(objAcc, 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) ||
@@ -447,6 +449,34 @@ const guardPropConditions = (key, propSchema, objAcc) => {
             return null;
     }
 };
+/** A property key an array carries with a non-`undefined` value: `length`, or a
+ * canonical array index. A required prop on one of these can't be used to rule
+ * out arrays (an array's `length` is a number, an index can be anything). */
+const ARRAY_INDEX_KEY = /^(0|[1-9]\d*)$/;
+/** Schema types whose guard is a `typeof` check `typeof undefined` never passes. */
+const TYPEOF_CHECKABLE_TYPES = new Set(['string', 'number', 'integer', 'boolean', 'object']);
+/**
+ * Whether some required, typeof-guarded property proves the value can't be an
+ * array — letting the object shape-check drop its `!Array.isArray(...)` term. An
+ * array indexed by a normal key yields `undefined` (or an inherited method),
+ * which no `typeof === 'string' | 'number' | 'boolean' | 'object'` accepts, so
+ * that field check already rejects arrays. Keys an array does carry a real value
+ * for (`length`, numeric indices) are excluded, since those could slip through.
+ */
+const arrayRejectedByRequiredProp = (keys, required, properties) => {
+    for (const key of keys) {
+        if (!required.has(key) || key === 'length' || ARRAY_INDEX_KEY.test(key))
+            continue;
+        const propSchema = properties[key];
+        if (propSchema !== undefined &&
+            isSchemaObject(propSchema) &&
+            hasType(propSchema) &&
+            TYPEOF_CHECKABLE_TYPES.has(propSchema.type)) {
+            return true;
+        }
+    }
+    return false;
+};
 /**
  * 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
@@ -479,7 +509,10 @@ const guardObjectConditions = (schema, raw, objAcc) => {
     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})`];
+    // The object shape-check only needs `!Array.isArray` when no required field
+    // check would already reject an array (see `arrayRejectedByRequiredProp`).
+    const arrayCheck = arrayRejectedByRequiredProp(keys, required, properties) ? '' : ` && !Array.isArray(${raw})`;
+    const conditions = [`typeof ${raw} === 'object' && ${raw} !== null${arrayCheck}`];
     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.
@@ -553,19 +586,18 @@ const generateObjectValidator = (schema, typeName, suffix) => {
     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
+    // without allocating an `errors` array or touching 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.
+    // through to the error-collecting path, 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 [
-        `${hoistedBlock}export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+    // The cold, error-collecting body. When there's a guard this is a separate
+    // (unexported) function reached only on failure; the hot path never enters it
+    // unless input is actually invalid, so its size never costs the happy path.
+    const collectBody = (name, exported) => [
+        `${exported ? 'export ' : ''}const ${name} = (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 }] }`,
         `  }`,
@@ -575,6 +607,244 @@ const generateObjectValidator = (schema, typeName, suffix) => {
         `  return errors.length > 0 ? { valid: false, errors } : true`,
         `}`,
     ].join('\n');
+    // No guard: the exported validator is the error-collecting function itself.
+    if (!guard) {
+        return `${hoistedBlock}${collectBody(vName, true)}`;
+    }
+    // With a guard, keep the happy path inside the exported function — the guard
+    // is inlined as an early `return true`, so a valid input never pays an extra
+    // call — and move only the cold, error-collecting body into a separate
+    // (unexported) function. That keeps `validateX` itself tiny (guard + a single
+    // tail call) so V8 optimises it well, without the giant error body bloating
+    // the hot path. The exported `(input, _path?) => ValidationResult` contract
+    // is unchanged.
+    const collectName = `${vName}Errors`;
+    return [
+        `${hoistedBlock}${collectBody(collectName, false)}`,
+        ``,
+        `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+        `  const obj = input as Record<string, unknown>`,
+        `  if (`,
+        guard.map((condition) => `    ${condition}`).join(' &&\n'),
+        `  ) {`,
+        `    return true`,
+        `  }`,
+        `  return ${collectName}(input, _path)`,
+        `}`,
+    ].join('\n');
+};
+/**
+ * Derives the boolean type-guard name from a type name.
+ * e.g. "InfoObject" → "isInfoObject"
+ */
+const guardName = (typeName) => `is${typeName}`;
+/**
+ * Positive type check for a value — the negation of {@link wrongTypeCondition}.
+ * Used by the boolean type-guard, which proves validity with `&&` conditions
+ * rather than collecting errors. Object is a shape-only check (matching the
+ * validator, which never recurses into array items or untyped object values).
+ */
+const rightTypeCondition = (accessor, type) => {
+    switch (type) {
+        case 'string':
+            return `typeof ${accessor} === 'string'`;
+        case 'number':
+        case 'integer':
+            return `typeof ${accessor} === 'number'`;
+        case 'boolean':
+            return `typeof ${accessor} === 'boolean'`;
+        case 'array':
+            return `Array.isArray(${accessor})`;
+        case 'object':
+            return `typeof ${accessor} === 'object' && ${accessor} !== null && !Array.isArray(${accessor})`;
+        default:
+            return null;
+    }
+};
+/**
+ * Builds a boolean expression that is TRUE iff `acc` satisfies `schema`, with the
+ * *exact same verdict* as the error-collecting validator — or `null` when the
+ * schema carries something the flat form can't faithfully mirror ($ref, unions,
+ * `const`, x-mjst, etc.), in which case the whole guard falls back to calling the
+ * validator. Used for a property value or an array item; `acc` is the expression
+ * yielding the value.
+ */
+const booleanLeafExpr = (schema, acc) => {
+    if (!isSchemaObject(schema))
+        return null;
+    // Anything whose verdict the flat form can't mirror exactly: defer to the
+    // validator (the caller turns a single `null` into a full fallback guard).
+    if (hasRef(schema) ||
+        hasConst(schema) ||
+        hasOneOf(schema) ||
+        'anyOf' in schema ||
+        'allOf' in schema ||
+        'not' in schema ||
+        getMjstInstanceOf(schema) !== undefined ||
+        getMjstPrimitive(schema) !== undefined) {
+        return null;
+    }
+    // enum — same membership test the validator uses.
+    if (hasEnum(schema)) {
+        return `(${JSON.stringify(schema.enum)} as unknown[]).includes(${acc})`;
+    }
+    if (!hasType(schema))
+        return null;
+    const t = schema.type;
+    switch (t) {
+        // Each constraint is the exact negation of the validator's error condition
+        // (`!(len < min)`, not `len >= min`) so edge values — most importantly `NaN`,
+        // which the validator accepts for a constrained number since `NaN < min` is
+        // false — get the identical verdict.
+        case 'string': {
+            const parts = [`typeof ${acc} === 'string'`];
+            if (hasPattern(schema))
+                parts.push(`/${escapeRegexPattern(schema.pattern)}/.test(${acc})`);
+            if (hasMinLength(schema))
+                parts.push(`!(${acc}.length < ${schema.minLength})`);
+            if (hasMaxLength(schema))
+                parts.push(`!(${acc}.length > ${schema.maxLength})`);
+            return parts.join(' && ');
+        }
+        case 'number':
+        case 'integer': {
+            const parts = [`typeof ${acc} === 'number'`];
+            if (hasMinimum(schema))
+                parts.push(`!(${acc} ${hasStrictExclusiveMinimum(schema) ? '<=' : '<'} ${schema.minimum})`);
+            if (hasMaximum(schema))
+                parts.push(`!(${acc} ${hasStrictExclusiveMaximum(schema) ? '>=' : '>'} ${schema.maximum})`);
+            if (hasExclusiveMinimum(schema))
+                parts.push(`!(${acc} <= ${schema.exclusiveMinimum})`);
+            if (hasExclusiveMaximum(schema))
+                parts.push(`!(${acc} >= ${schema.exclusiveMaximum})`);
+            if (hasMultipleOf(schema))
+                parts.push(`${acc} % ${schema.multipleOf} === 0`);
+            return parts.join(' && ');
+        }
+        case 'boolean':
+            return `typeof ${acc} === 'boolean'`;
+        case 'object': {
+            const parts = booleanObjectParts(schema, acc, `(${acc} as Record<string, unknown>)`);
+            return parts === null ? null : parts.join(' && ');
+        }
+        case 'array':
+            return booleanArrayExpr(schema, acc);
+        default:
+            return null;
+    }
+};
+/**
+ * Boolean expression for an array value. Mirrors the validator, which checks the
+ * array shape and — for typed items — only each item's *type* (objects are shape-
+ * checked, not recursed into); it never enforces `minItems`/`maxItems` or item
+ * constraints. Returns `null` for `$ref` items (those defer to the validator).
+ */
+const booleanArrayExpr = (schema, acc) => {
+    const base = `Array.isArray(${acc})`;
+    if (!hasItems(schema))
+        return base;
+    const items = schema.items;
+    if (!isSchemaObject(items))
+        return base;
+    if (hasRef(items))
+        return null;
+    if (!hasType(items))
+        return base;
+    const itemCheck = rightTypeCondition('_it', items.type);
+    if (itemCheck === null)
+        return base;
+    return `${base} && (${acc} as unknown[]).every((_it) => ${itemCheck})`;
+};
+/**
+ * Builds the `&&` conditions proving an object value is valid (same verdict as
+ * the error-collecting validator), or `null` when any property or object-level
+ * keyword can't be mirrored flat. `raw` yields the value (for the shape check);
+ * `objAcc` is the same value narrowed to a record (for member access).
+ */
+const booleanObjectParts = (schema, raw, objAcc) => {
+    if (!isObjectSchema(schema))
+        return null;
+    // These need per-key loops or cross-references the flat form can't express.
+    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 expressible; a schema needs per-key
+        // validation, so defer to the validator.
+        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);
+    // Drop the `!Array.isArray` term when a required, typeof-guarded property
+    // already rejects arrays (an array's normal key is `undefined`, which no
+    // `typeof` accepts) — the same sound optimisation the validator's hot guard
+    // uses. Kept when no such property exists.
+    const arrayCheck = arrayRejectedByRequiredProp(keys, required, properties) ? '' : ` && !Array.isArray(${raw})`;
+    const parts = [`typeof ${raw} === 'object' && ${raw} !== null${arrayCheck}`];
+    for (const key of keys) {
+        const propSchema = properties[key];
+        if (propSchema === undefined || !isSchemaObject(propSchema))
+            return null;
+        const member = safeAccessor(objAcc, key);
+        const expr = booleanLeafExpr(propSchema, member);
+        if (expr === null)
+            return null;
+        parts.push(required.has(key) ? expr : `(${member} === undefined || (${expr}))`);
+    }
+    if (strict) {
+        // `additionalProperties: false`: with every property required, an exact key
+        // count proves no extras (the typeof checks above already proved presence);
+        // otherwise sweep the keys against the declared set.
+        if (keys.length === 0) {
+            parts.push(`Object.keys(${objAcc}).length === 0`);
+        }
+        else if (keys.every((key) => required.has(key))) {
+            parts.push(`Object.keys(${objAcc}).length === ${keys.length}`);
+        }
+        else {
+            const known = keys.map((key) => `_k === ${JSON.stringify(key)}`).join(' || ');
+            parts.push(`Object.keys(${objAcc}).every((_k) => ${known})`);
+        }
+    }
+    return parts;
+};
+/**
+ * Generates the exported boolean type-guard `isTypeName(input): input is TypeName`.
+ *
+ * Unlike `validateTypeName` (which returns rich `ValidationResult` errors), this
+ * is a single flat boolean predicate — no error array, no cold-path call — so V8
+ * inlines it like a hand-written `check`, matching the shape of TypeBox's
+ * compiled checker. It returns the *same verdict* as the validator. When the
+ * schema carries anything the flat form can't mirror exactly, it falls back to
+ * `validateTypeName(input) === true`, which is always correct.
+ */
+export const generateBooleanGuard = (schema, typeName, _suffix = '') => {
+    const name = guardName(typeName);
+    const fallback = `export const ${name} = (input: unknown): input is ${typeName} => ${validatorName(typeName)}(input) === true`;
+    if (isObjectSchema(schema)) {
+        const parts = booleanObjectParts(schema, 'input', 'obj');
+        if (parts === null)
+            return fallback;
+        return [
+            `export const ${name} = (input: unknown): input is ${typeName} => {`,
+            `  const obj = input as Record<string, unknown>`,
+            `  return (`,
+            parts.map((part) => `    ${part}`).join(' &&\n'),
+            `  )`,
+            `}`,
+        ].join('\n');
+    }
+    // Non-object roots (scalar, enum, array) can often be expressed inline too.
+    const expr = booleanLeafExpr(schema, 'input');
+    if (expr === null)
+        return fallback;
+    return `export const ${name} = (input: unknown): input is ${typeName} => ${expr}`;
 };
 /**
  * Generates a validator function for a non-object schema (primitive, array, enum, $ref).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-validators",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Generate TypeScript validation functions from JSON Schemas.",
   "module": "./dist/index.js",
   "type": "module",
@@ -33,7 +33,7 @@
     "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",
-    "bench": "bun run ./bench/run.ts"
+    "bench": "bun --conditions development ./bench/run.ts"
   },
   "imports": {
     "#generators/*": "./src/generators/*.ts"
@@ -49,10 +49,12 @@
     "@amritk/helpers": "0.10.0"
   },
   "devDependencies": {
+    "@ryoppippi/unplugin-typia": "^2.6.5",
     "@scalar/openapi-parser": "^0.26.1",
     "@sinclair/typebox": "^0.34.49",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
+    "typia": "^12.1.1",
     "zod": "^4.4.3"
   }
 }