ata-validator 1.60.0 → 1.61.0

package/README.md

@@ -12,11 +12,17 @@ JSON Schema validation that compiles for speed and still runs where code generat
 
 ## Who uses ata
 
-Projects whose code depends on ata, from GitHub's dependency graph, and the framework that lists
-its plugin, with what each does with it:
+Projects whose code depends on ata, from GitHub's dependency graph, a framework that lists its
+plugin, a form library that ships its resolver, and one company whose use is not public code,
+with what each does with it:
 
+- [Trendyol](https://github.com/Trendyol) validates configuration with ata in Puzzle, its
+  internal config tooling. The package is internal, so it is not in the public dependency
+  graph; this line rests on its maintainer.
 - [Socket](https://github.com/SocketDev) uses ata, compiled ahead of time, in the shared build
   tooling of its repositories.
+- [React Hook Form](https://github.com/react-hook-form/resolvers) ships an ata resolver in
+  `@hookform/resolvers` (`@hookform/resolvers/ata-validator`), beside its other validators.
 - [Fastify](https://fastify.dev/ecosystem/) lists the
   [`fastify-ata`](https://github.com/ata-core/fastify-ata) plugin in its ecosystem.
 - [react-jsonschema-form](https://github.com/rjsf-team/react-jsonschema-form) ships an ata
@@ -68,7 +74,7 @@ details, and what Deno Deploy's refusal of dynamic code means for it, are in
 
 Those four now agree with `validate()` on every case of the official suite, 3365 across three dialects. The native walker behind them does not handle every shape (`contains`, `unevaluatedProperties`, `patternProperties`, tuple `items`, cross-document `$ref`, a few formats), so for schemas using one of those the buffer APIs parse the bytes and answer through `validate()`; the list is in `lib/buffer-gate.js`. Typical request schemas stay on the zero-copy path. `npm test` holds the disagreement count at zero.
 
-Where `new Function` is refused altogether, on Cloudflare Workers, Deno Deploy or under a strict Content-Security-Policy, ata drops to the interpreted engine and scores the same 1301 of 1301 with code generation blocked. No flags, and on Workers no `nodejs_compat` either. See [docs/edge-runtimes.md](docs/edge-runtimes.md).
+Where `new Function` is refused altogether, on Cloudflare Workers, Deno Deploy or under a strict Content-Security-Policy, ata drops to the interpreted engine and scores the same 1301 of 1301 with code generation blocked. No flags, and on Workers no `nodejs_compat` either. See [docs/edge-runtimes.md](docs/edge-runtimes.md). Where generated code runs but slowly, as in an ahead-of-time compiled Bun executable, a module from `ata build` is plain JavaScript that imports nothing and calls no `new Function`: on Bun 1.4.0, import plus a first validation takes 0.66 ms with such a module against 10.70 ms with the runtime compiler (medians of 21 runs). [docs/proof-no-code-generation.md](docs/proof-no-code-generation.md) runs one schema in five of these places, Workers and a CSP page included, and shows the same answers from each.
 
 Node has a switch for exactly that environment, so this takes thirty seconds to check for yourself, on ata or on whatever you use today:
 
@@ -667,6 +673,102 @@ first request, so counting only registration would overstate the gap. The first
 here comes in the same tick as setup; a server that listens first has the code generator
 loaded by then. Reproduce with `node benchmark/bench_fastify_boot.mjs`.
 
+A server that listens first also gets the engine warmed: once the event loop is free, if a
+validator was built and not yet called, ata runs one check of a small schema, accepted and
+rejected, so that V8 compiles the generator's functions and the error builders then rather
+than on the first request. Measured on a four-field schema with the generator already
+loaded: the first verdict 3.1 to 3.4 ms without it, 0.5 to 0.6 with it; the first error
+list 6.7 against 0.8; a second route's first verdict 0.9 to 1.0 against 0.7 to 0.9. It costs
+the process 1.5 to 2 ms of CPU once. A script that builds a validator and checks in the
+same tick never runs it, and the timer is unref'd, so a finished script does not stay for
+it; `ATA_NO_WARM=1` turns it off.
+
+### Proving the build (`ata verify`)
+
+A module written at build time is only a good idea if it answers as the
+runtime it replaced. `ata verify` checks that on the project's own schemas:
+
+```bash
+npx ata verify 'schemas/*.json' --samples test/fixtures
+```
+
+For each schema it loads the module `ata build` wrote beside it, makes
+documents from the schema (200 by default, half of them with one rule broken),
+reads the project's sample documents (JSON files, JSON Lines, or a directory
+of them), and has both the module and a `Validator` built from the schema now
+answer every one. Verdicts and error lists have to agree; a module whose
+schema hash no longer matches the schema is reported stale. The exit code is
+non-zero on any disagreement, stale module or missing module, so the command
+works as a CI step. This is the check that found the two silent divergences
+fixed in 1.59.0 and 1.60.0, now in a form a project can run on every change.
+It does not run the `.bun.ts` target, which needs Bun's compiler.
+
+### Bun, compiled ahead of time
+
+Bun's ahead-of-time compiler (`bun build --compile --aot`, an open pull
+request as of October 2026) runs code that a library hands to `new Function`
+through an interpreter. Measured with its pull request build on one schema
+and 1024 parsed documents, nanoseconds per document (`benchmark/proof/aot`):
+
+| | JIT | ahead of time |
+|---|---|---|
+| a module from `ata build --target bun` | 25 | 24 |
+| `new Validator(schema)`, generated code | 28 | 492 |
+| `new Validator(schema)`, interpreted engine | 52 | 80 |
+
+So, in order of preference:
+
+1. Compile the schema at build time. `@ata-project/unplugin/bun` does it in
+   `Bun.build`, including `Bun.build({ compile })`; `ata build` writes the
+   module by hand. The module is plain JavaScript and compiles with the
+   program: 24 ns, the same errors as the runtime.
+2. Where the runtime `Validator` stays, let it take the interpreted engine.
+   It does so by itself when Bun reports `Bun.isAOT`, when the executable is
+   built with `--disallow-code-generation-from-strings` (the program then
+   counts as closed for the compiler, too), or when `ATA_ENGINE=interpreter`
+   is set: 80 ns against 492 for the generated code there.
+3. Write the module for the compiler. `ata build schema.json --target bun`
+   writes it with a closed object's keys read once and compared with the
+   declared list in order (on a ten-item order with 1024 distinct documents,
+   10% of them invalid, 105 to 107 ns under the compiler against 223 for the
+   form V8 gets; on V8 the module keeps for...in, on Bun's JIT a plain count,
+   each the cheaper form there), and answers a rejection with the one-pass
+   error function (189 ns with the error list on that order, against 724
+   with the older collector), the form every other build takes only with
+   `--one-pass` since it is 20% larger gzipped. Beside the module it writes
+   `schema.compiled.bun.ts`: the schema as a TypeScript type (kinds,
+   properties and which are required, items and fixed tuples, literals,
+   local definitions as named types), `validate` and `isValid` with that
+   type on them, and `parse(text)`, which declares the type where it parses
+   and has the module check the content. Every check is the module's, and
+   the file is a type for the program, not a faster path: on that order,
+   with the pull request build of 2026-10-25, `isValid` 118 ns through the
+   file against 118 to 121 through the module, `parse` 564 to 574 against
+   570 to 578 for a plain parse and the module, and reading the parsed
+   object after a typed parse 593 to 595 against 587 to 591 after a plain
+   one. The file is for executables built with
+   `--aot`; a project points that compiler at it with an `"aot"` condition
+   in its `package.json` `imports`, which nothing else reads:
+
+   ```json
+   { "imports": { "#schemas/*": { "aot": "./schemas/*.bun.ts", "default": "./schemas/*.js" } } }
+   ```
+
+   A schema no type can be written for (a remote `$ref`, `$dynamicRef`, a
+   root the type says nothing about) gets a warning and the plain module
+   alone.
+
+The pull request carried its own typed validator until 2026-10-25, and
+`--target bun` wrote the schema's rules as a type for it; it left the pull
+request to return as a change of its own. `docs/API.md` has what ata keeps
+for it. A schema's `pattern` is a `new RegExp` at run time in the runtime
+`Validator`, which that compiler runs through its regular expression
+interpreter; the module writes each pattern as a literal, which it compiles.
+`--aot` makes TypeScript errors fatal; ata's declarations say `message?:
+string` on an error, so read it as such. The numbers are from the pull
+request build of 2026-10-24 on one machine and will be run again when the
+compiler ships.
+
 ### Standard Schema V1
 
 ```javascript
@@ -745,9 +847,10 @@ Copy-paste recipes for the common frameworks. Most need 10-20 lines of glue. See
 | Vite (build-time compile) | dedicated plugin | [`ata-vite`](https://github.com/ata-core/ata-vite), the Vite entry of the plugin above |
 | Next.js (build-time compile) | webpack entry of the plugin above | `@ata-project/unplugin/webpack` in `next.config.js` |
 | Hono | async middleware | [docs/integrations/hono.md](docs/integrations/hono.md) |
-| Elysia | direct handler check | [docs/integrations/elysia.md](docs/integrations/elysia.md) |
+| Elysia | Standard Schema V1 in the `body` slot | [docs/integrations/elysia.md](docs/integrations/elysia.md) |
 | tRPC | Standard Schema V1 input | [docs/integrations/trpc.md](docs/integrations/trpc.md) |
 | TanStack Form | Standard Schema V1 validator | [docs/integrations/tanstack-form.md](docs/integrations/tanstack-form.md) |
+| React Hook Form | resolver | [`@hookform/resolvers/ata-validator`](https://github.com/react-hook-form/resolvers/tree/master/ata-validator) |
 | Express | sync middleware | [docs/integrations/express.md](docs/integrations/express.md) |
 | Koa | async ctx middleware | [docs/integrations/koa.md](docs/integrations/koa.md) |
 | NestJS | validation pipe | [docs/integrations/nestjs.md](docs/integrations/nestjs.md) |

package/bin/ata.js

@@ -13,6 +13,15 @@ Usage:
   ata build    <glob>...     [options]  Compile a project's schemas (glob pattern) per file.
   ata validate <schema> <data> [options] Validate a JSON data file against a schema.
   ata migrate  [dir]         [options]  Report what switching from ajv would change; --write applies it.
+  ata verify   <glob>...     [options]  Check that each schema's compiled module answers as the runtime
+                                        does, on generated documents and the project's samples.
+
+Verify options:
+  --generate <n>          Documents made from each schema, half with one rule broken. Default: 200
+  --samples <path>        A JSON, JSON Lines file or a directory of them, checked too (repeatable)
+  --seed <n>              Seed for the generated documents. Default: 1
+  --json                  Report as JSON
+  --out-dir, --suffix, --format    Where the modules are, as given to ata build
 
 Validate options:
   --pretty                Render errors with source frames (default on TTY)
@@ -65,6 +74,9 @@ Build options:
   --cache-file <path>     Cache file for incremental builds (default: cache disabled)
   --max-size <bytes>      Fail build if any compiled module exceeds this gzipped size
   --strict                Treat any AOT-incompatible schema as a build error (default: skip + warn)
+  --target bun            Write every module for Bun's ahead-of-time compiler, and beside
+                          each a .bun.ts with the schema as a TypeScript type and a typed
+                          parse(text); the plain module answers every check
   --strict-schema         Fail the build on schema authoring mistakes: unknown
                           keywords (with a spelling suggestion), keywords the
                           node's type makes inert, unresolvable local $refs,
@@ -117,6 +129,11 @@ function parseArgs(argv) {
     if (a === '--check') { out.opts.check = true; continue; }
     if (a === '--strict') { out.opts.strict = true; continue; }
     if (a === '--strict-schema') { out.opts.strictSchema = true; continue; }
+    if (a === '--target') { out.opts.target = argv[++i]; continue; }
+    if (a === '--generate') { out.opts.generate = Number(argv[++i]); continue; }
+    if (a === '--samples') { (out.opts.samples = out.opts.samples || []).push(argv[++i]); continue; }
+    if (a === '--seed') { out.opts.seed = Number(argv[++i]); continue; }
+    if (a === '--json') { out.opts.json = true; continue; }
     if (a === '--out-dir') { out.opts.outDir = argv[++i]; continue; }
     if (a === '--suffix') { out.opts.suffix = argv[++i]; continue; }
     if (a === '--cache-file') { out.opts.cacheFile = argv[++i]; continue; }
@@ -239,6 +256,15 @@ function cmdCompile(args) {
 
   const { Validator } = require('..');
   const aot = require('../lib/aot');
+  // `--target bun`: the module is written for JavaScriptCore, the engine the
+  // executable the target is for runs on.
+  if (args.opts.target === 'bun') {
+    require('../lib/js-compiler').setTargetEngine('jsc-aot');
+    // The executable's module answers rejections with the one-pass error
+    // function and carries no schema-source frames unless asked for.
+    if (args.opts.onePass === undefined) args.opts.onePass = true;
+    if (args.opts.source === undefined) args.opts.source = false;
+  }
   let v;
   try {
     v = new Validator(schema);
@@ -277,6 +303,25 @@ function cmdCompile(args) {
   const sizeBytes = Buffer.byteLength(src, 'utf8');
   process.stdout.write(`ata: compiled ${input} -> ${output} (${sizeBytes.toLocaleString()} bytes, ${format}${abortEarly ? ', abort-early' : ''})\n`);
 
+  if (args.opts.target !== undefined) {
+    if (args.opts.target !== 'bun') {
+      reportCompileError(input, `--target must be bun (got ${JSON.stringify(args.opts.target)})`);
+      process.exit(1);
+    }
+    const { writeBunTarget, Declined } = require('../lib/bun-target');
+    const tn = (args.opts.name || path.basename(input, path.extname(input)).replace(/[^A-Za-z0-9_]/g, '_').replace(/^([a-z])/, (m) => m.toUpperCase())) || 'Data';
+    try {
+      const w = writeBunTarget({ schema, input, output, typeName: tn });
+      process.stdout.write(`ata: bun target -> ${w.bunPath} (for bun build --compile --aot)\n`);
+    } catch (e) {
+      if (!(e instanceof Declined)) throw e;
+      // No type can be written; the plain module stands alone.
+      const msg = `--target bun: ${e.message}; the plain module stands alone`;
+      if (args.opts.strict) { reportCompileError(input, msg); process.exit(1); }
+      process.stderr.write(`ata: warning: ${input}: ${msg}\n`);
+    }
+  }
+
   // Emit paired declaration file unless --no-types.
   // TypeScript resolution: .mjs -> .d.mts, .cjs -> .d.cts, .js -> .d.ts.
   const emitTypes = args.opts.types !== false;
@@ -298,6 +343,10 @@ function cmdCompile(args) {
 }
 
 function cmdBuild(args) {
+  if (args.opts.target !== undefined && args.opts.target !== 'bun') {
+    process.stderr.write(`error: --target must be bun (got ${JSON.stringify(args.opts.target)})\n`);
+    process.exit(1);
+  }
   if (args._.length === 0) {
     process.stderr.write('error: missing <glob>\n\n');
     usage();
@@ -323,6 +372,7 @@ function cmdBuild(args) {
     check: !!args.opts.check,
     maxSize: args.opts.maxSize,
     strict: !!args.opts.strict,
+    target: args.opts.target,
     types: args.opts.types,
     cacheFile: args.opts.cacheFile,
     // Forward the explicit user choice (true / false / undefined). The
@@ -337,6 +387,8 @@ function cmdBuild(args) {
     }
     for (const c of report.compiled) {
       process.stdout.write(`ata: ${c.input} -> ${c.output} (${c.bytes.toLocaleString()} bytes${c.errors === 'compact' ? ', shared errors' : c.errors === 'schema' ? ', schema module' : ''})\n`);
+      for (const t of (report.bunTargets || []).filter((t) => t.input === c.input)) process.stdout.write(`ata: bun target -> ${t.output} (for bun build --compile --aot)\n`);
+      for (const d of (report.bunDeclined || []).filter((d) => d.input === c.input)) process.stderr.write(`ata: warning: ${d.input}: ${d.reason}\n`);
     }
     if (report.runtime) {
       process.stdout.write(`ata: error runtime -> ${report.runtime.output} (${report.runtime.bytes.toLocaleString()} bytes, shared by the modules above)\n`);
@@ -408,6 +460,33 @@ function cmdBuild(args) {
   });
 }
 
+function cmdVerify (args) {
+  if (args._.length === 0) {
+    process.stderr.write('error: missing <glob>\n\n');
+    usage();
+    process.exit(1);
+  }
+  const buildLib = require('../lib/aot-build');
+  const { verifyOne, renderReport, ok } = require('../lib/verify');
+  const format = args.opts.format || 'esm';
+  (async () => {
+    const inputs = await buildLib.expandGlobs(args._);
+    if (inputs.length === 0) {
+      process.stderr.write(`error: no schema files match ${args._.join(' ')}\n`);
+      process.exit(1);
+    }
+    const reports = [];
+    for (const input of inputs) {
+      let schema;
+      try { schema = buildLib.parseSchemaFile(input); } catch (e) { reports.push({ schema: input, module: '', error: e.message, documents: 0, agree: 0, disagreements: [] }); continue; }
+      const moduleFile = buildLib.outputPathFor(input, { format, outDir: args.opts.outDir, suffix: args.opts.suffix });
+      reports.push(await verifyOne({ schemaFile: input, moduleFile, schema, generate: Number.isFinite(args.opts.generate) ? args.opts.generate : 200, seed: Number.isFinite(args.opts.seed) ? args.opts.seed : 1, samples: args.opts.samples || [] }));
+    }
+    process.stdout.write(renderReport(reports, { json: !!args.opts.json }) + '\n');
+    process.exit(reports.every(ok) ? 0 : 1);
+  })().catch((e) => { process.stderr.write(`error: ${e.message}\n`); process.exit(1); });
+}
+
 function cmdValidate (args) {
   if (args._.length < 2) {
     process.stderr.write('error: ata validate <schema> <data-file>\n');
@@ -508,6 +587,11 @@ function main() {
     return;
   }
 
+  if (cmd === 'verify') {
+    cmdVerify(args);
+    return;
+  }
+
   if (cmd === 'migrate') {
     const { migrate, formatReport } = require('../lib/migrate');
     const result = migrate(args._[0] || '.', { write: !!args.opts.write });

package/build.d.ts

@@ -204,3 +204,32 @@ export function compiledModuleFor(schema: unknown, opts?: { format?: 'esm' | 'cj
  * ata-validator 1.37.0, where only calls without options can be.
  */
 export const compiledOptions: readonly string[];
+
+/**
+ * The Bun target, for a build plugin: the schema as a TypeScript type and the
+ * `.bun.ts` module `ata build --target bun` writes beside a compiled module.
+ * With `tags: true` the type carries Bun's `Schema` tags and `residual` holds
+ * the schema of every rule the tagged type does not carry, the split made for
+ * Bun's `validate<T>`, which left the compiler's pull request on 2026-10-25
+ * and is to return as a change of its own; without tags `residual` is null.
+ */
+export const bunTarget: {
+  schemaToBunType(schema: unknown, opts?: { name?: string; aliasPrefix?: string; tags?: boolean; assertFormat?: boolean }): { name: string; type: string; aliases: Array<[string, string]>; residual: unknown | null; carried: string[] };
+  toBunModule(args: { schemaFile: string; moduleImport: string; typeName: string; typeSource: string; aliases: Array<[string, string]> }): string;
+  writeBunTarget(args: { schema: unknown; input: string; output: string; typeName: string }): { bunPath: string; definitions: number; carried: number };
+  Declined: new (reason: string, pointer: string) => Error & { reason: string; pointer: string };
+};
+
+/** `ata verify` as functions: a compiled module held against the runtime on generated documents and samples. */
+export const verify: {
+  verifyOne(args: { schemaFile: string; moduleFile: string; schema: unknown; generate?: number; seed?: number; samples?: string[] }): Promise<VerifyReport>;
+  verifySource(schema: unknown, src: string, opts?: { name?: string; format?: 'esm' | 'cjs'; generate?: number; seed?: number; samples?: string[] }): Promise<VerifyReport>;
+  generate(schema: unknown, count: number, seed: number): unknown[];
+  renderReport(reports: VerifyReport[], opts?: { json?: boolean }): string;
+  ok(report: VerifyReport): boolean;
+};
+export interface VerifyReport {
+  schema: string; module: string; documents: number; generated: number; samples: number; valid: number; agree: number;
+  disagreements: Array<{ source: string; document: string; runtime: string; module: string; runtimeIsValid: boolean; moduleIsValid: boolean } | { more: number }>;
+  stale: boolean; missing: boolean; ataVersion: string | null; error: string | null;
+}

package/build.mjs

@@ -12,5 +12,7 @@ export const schemaHash = mod.schemaHash;
 export const compiledEligible = mod.compiledEligible;
 export const compiledSchemaFor = mod.compiledSchemaFor;
 export const compiledModuleFor = mod.compiledModuleFor;
+export const bunTarget = mod.bunTarget;
+export const verify = mod.verify;
 export const compiledOptions = mod.compiledOptions;
 export default mod;

package/compiled.d.ts

@@ -3,7 +3,9 @@
 import type { ValidationResult } from './index.js';
 
 export interface CompiledModule {
-  validate(data: unknown): { valid: boolean; errors: unknown[] };
+  // A module's accepted result is frozen, so the array is read-only here;
+  // under Bun's ahead-of-time compiler a type error fails the build.
+  validate(data: unknown): { valid: boolean; errors: readonly unknown[] };
   isValid(data: unknown): boolean;
 }
 

package/index.browser.mjs

@@ -15,6 +15,6 @@ import { toTypeScript, renderPretty, renderCompact, toOutput, toRetryMessage, de
 
 core._registerTiering(tiering.createTiering(() => import('./lib/codegen-engine.js')));
 
-export const { Validator, compile, validate, validateAsync, parseAsync, version, createPaddedBuffer, SIMDJSON_PADDING, parseJSON, defineSchema } = core;
+export const { Validator, compile, validate, validateAsync, parseAsync, version, createPaddedBuffer, SIMDJSON_PADDING, parseJSON, defineSchema, schemaOf } = core;
 export { toTypeScript, renderPretty, renderCompact, toOutput, toRetryMessage, describeSchema, renderJSON };
-export default { Validator, compile, validate, validateAsync, parseAsync, version, createPaddedBuffer, SIMDJSON_PADDING, parseJSON, toTypeScript, defineSchema, renderPretty, renderCompact, toOutput, toRetryMessage, describeSchema, renderJSON };
+export default { Validator, compile, validate, validateAsync, parseAsync, version, createPaddedBuffer, SIMDJSON_PADDING, parseJSON, toTypeScript, defineSchema, schemaOf, renderPretty, renderCompact, toOutput, toRetryMessage, describeSchema, renderJSON };

package/index.bundle.mjs

@@ -10,6 +10,6 @@ import { toTypeScript, renderPretty, renderCompact, toOutput, toRetryMessage, de
 
 core._registerCodegen(engine);
 
-export const { Validator, compile, validate, validateAsync, parseAsync, version, createPaddedBuffer, SIMDJSON_PADDING, parseJSON, defineSchema } = core;
+export const { Validator, compile, validate, validateAsync, parseAsync, version, createPaddedBuffer, SIMDJSON_PADDING, parseJSON, defineSchema, schemaOf } = core;
 export { toTypeScript, renderPretty, renderCompact, toOutput, toRetryMessage, describeSchema, renderJSON };
-export default { Validator, compile, validate, validateAsync, parseAsync, version, createPaddedBuffer, SIMDJSON_PADDING, parseJSON, toTypeScript, defineSchema, renderPretty, renderCompact, toOutput, toRetryMessage, describeSchema, renderJSON };
+export default { Validator, compile, validate, validateAsync, parseAsync, version, createPaddedBuffer, SIMDJSON_PADDING, parseJSON, toTypeScript, defineSchema, schemaOf, renderPretty, renderCompact, toOutput, toRetryMessage, describeSchema, renderJSON };

package/index.d.ts

@@ -678,3 +678,12 @@ export function toTypeScript(schema: object, options?: { name?: string }): strin
  * Requires TypeScript >= 5.0 for the `const` type parameter.
  */
 export declare function defineSchema<const S extends JSONSchema>(schema: S): S;
+
+/**
+ * The JSON Schema of a TypeScript type, written in at build time by
+ * `@ata-project/unplugin` from the type and the JSDoc tags on its properties
+ * (`@format email`, `@minimum 1`, `@pattern`, `@minLength`, `@maxItems`,
+ * `@asType integer`). `new Validator(schemaOf<User>())` then compiles like any
+ * static schema. Without the plugin the call throws: it has no run-time form.
+ */
+export declare function schemaOf<T>(): JSONSchema;

package/index.edge.mjs

@@ -8,6 +8,6 @@ import { toTypeScript, renderPretty, renderCompact, toOutput, toRetryMessage, de
 
 core._registerAot(() => aotBrowser);
 
-export const { Validator, compile, validate, validateAsync, parseAsync, version, createPaddedBuffer, SIMDJSON_PADDING, parseJSON, defineSchema } = core;
+export const { Validator, compile, validate, validateAsync, parseAsync, version, createPaddedBuffer, SIMDJSON_PADDING, parseJSON, defineSchema, schemaOf } = core;
 export { toTypeScript, renderPretty, renderCompact, toOutput, toRetryMessage, describeSchema, renderJSON };
-export default { Validator, compile, validate, validateAsync, parseAsync, version, createPaddedBuffer, SIMDJSON_PADDING, parseJSON, toTypeScript, defineSchema, renderPretty, renderCompact, toOutput, toRetryMessage, describeSchema, renderJSON };
+export default { Validator, compile, validate, validateAsync, parseAsync, version, createPaddedBuffer, SIMDJSON_PADDING, parseJSON, toTypeScript, defineSchema, schemaOf, renderPretty, renderCompact, toOutput, toRetryMessage, describeSchema, renderJSON };

package/index.js

@@ -20,6 +20,53 @@ core._setCodegenLoader(loadCodegen);
 const warm = setTimeout(loadCodegen, 0);
 if (typeof warm === 'object' && typeof warm.unref === 'function') warm.unref();
 
+// A process whose first check comes after the event loop has turned, a
+// server's first request, pays on that check for V8 compiling the generator's
+// functions and the error builders: on a four-field schema 5 ms for the
+// verdict and 7 to 10 ms for the first error list, measured with the
+// generator already loaded. One check of a small schema, accepted and
+// rejected, run once the loop is free, moves that off the request: 0.5 and
+// 0.7 ms after it (the same warm-up as the browser build's, lib/tiering.js).
+// It runs only where a validator was built and is still uncompiled when the
+// loop turns: a script that builds one and checks in the same tick never runs
+// it, and the timer is unref'd, so a finished script does not stay for it.
+// ATA_NO_WARM=1 turns it off.
+let built = null;
+core._registerBuiltHook((v) => {
+  if (built === null) {
+    built = [];
+    const t = setTimeout(warmUp, 0);
+    if (typeof t === 'object' && typeof t.unref === 'function') t.unref();
+  }
+  if (built.length < 8) built.push(new WeakRef(v));
+});
+function warmUp () {
+  const list = built;
+  built = [];
+  core._registerBuiltHook(null);
+  if (process.env.ATA_NO_WARM === '1') return;
+  // Untouched: neither compiled for validate() nor a verdict or validate
+  // method read off it (the prototype's accessors bind the method on the
+  // instance at the first read, a verdict-only compile sets no other mark).
+  const untouched = (v) => !v._initialized && !Object.prototype.hasOwnProperty.call(v, 'isValidObject') && !Object.prototype.hasOwnProperty.call(v, 'validate');
+  if (!list.some((r) => { const v = r.deref(); return v !== undefined && untouched(v); })) return;
+  try {
+    const v = new core.Validator({
+      type: 'object',
+      properties: {
+        a: { type: 'string', minLength: 2, maxLength: 9, pattern: '^[a-z]+$', format: 'email' },
+        b: { type: 'integer', minimum: 1, maximum: 9 },
+        c: { type: 'array', items: { type: 'string' }, maxItems: 3 },
+        d: { const: true },
+        e: { type: 'object', properties: { f: { type: 'string' } }, required: ['f'] },
+      },
+      required: ['a', 'b'],
+    });
+    v.isValidObject({ a: 'ab@c.de', b: 2, c: ['x'], d: true, e: { f: 'x' } });
+    void v.validate({ a: '1', b: 0, c: [1], d: false, e: {} }).errors.length;
+  } catch { /* a warm-up never reaches the caller */ }
+}
+
 // The public names. lib/public-api.js holds the same for index.edge.js; they
 // are written out here rather than required so that loading the package in
 // Node reads one file fewer (tests/test_edge_entry.js and
@@ -91,6 +138,7 @@ module.exports = {
   parseJSON: core.parseJSON,
   toTypeScript,
   defineSchema: core.defineSchema,
+  schemaOf: core.schemaOf,
   renderPretty,
   renderCompact,
   toOutput,

package/index.mjs

@@ -1,3 +1,3 @@
 import mod from './index.js';
-export const { Validator, compile, validate, validateAsync, parseAsync, version, createPaddedBuffer, SIMDJSON_PADDING, parseJSON, toTypeScript, defineSchema, renderPretty, renderCompact, toOutput, toRetryMessage, describeSchema, renderJSON } = mod;
+export const { Validator, compile, validate, validateAsync, parseAsync, version, createPaddedBuffer, SIMDJSON_PADDING, parseJSON, toTypeScript, defineSchema, schemaOf, renderPretty, renderCompact, toOutput, toRetryMessage, describeSchema, renderJSON } = mod;
 export default mod;

package/index.node.mjs

@@ -6,5 +6,5 @@
 // static import they can follow.
 import { createRequire } from 'node:module';
 const mod = createRequire(import.meta.url)('./index.js');
-export const { Validator, compile, validate, validateAsync, parseAsync, version, createPaddedBuffer, SIMDJSON_PADDING, parseJSON, toTypeScript, defineSchema, renderPretty, renderCompact, toOutput, toRetryMessage, describeSchema, renderJSON } = mod;
+export const { Validator, compile, validate, validateAsync, parseAsync, version, createPaddedBuffer, SIMDJSON_PADDING, parseJSON, toTypeScript, defineSchema, schemaOf, renderPretty, renderCompact, toOutput, toRetryMessage, describeSchema, renderJSON } = mod;
 export default mod;

package/lib/aot-build.js

@@ -202,7 +202,29 @@ function pruneRegistry(roots, byId) {
   return out;
 }
 
+function bunTargetPath (output) {
+  const ext = path.extname(output);
+  return output.slice(0, output.length - ext.length) + '.bun.ts';
+}
+
 async function build(opts) {
+  // `--target bun`: every module written for JavaScriptCore, the plain ones
+  // included, since the executable the target is for runs on it.
+  const { setTargetEngine } = require('./js-compiler');
+  const prevEngine = setTargetEngine(opts.target === 'bun' ? 'jsc-aot' : null);
+  // An executable compiled ahead of time pays no bundle size and answers
+  // rejections: the one-pass error function (3.6x cheaper on a rejection, 20%
+  // larger gzipped) is the default there, and schema-source frames, which it
+  // does not carry, are off unless asked for.
+  if (opts.target === 'bun') opts = { ...opts, onePass: opts.onePass === undefined ? true : opts.onePass, source: opts.source === true ? true : false };
+  try {
+    return await buildWith(opts);
+  } finally {
+    setTargetEngine(prevEngine);
+  }
+}
+
+async function buildWith(opts) {
   const globs = opts.globs || [];
   if (globs.length === 0) throw new Error('build: at least one glob required');
   const format = opts.format || 'esm';
@@ -226,6 +248,10 @@ async function build(opts) {
 
   const compiled = [];
   const cached = [];
+  // --target bun: the .bun.ts written beside a module, and the schemas whose
+  // rules a type cannot carry.
+  const bunTargets = [];
+  const bunDeclined = [];
   const skipped = [];
   const failed = [];
   const warnings = [];
@@ -345,7 +371,10 @@ async function build(opts) {
         // the registry is put together from such modules: always rebuilt.
         !cacheEntry.usesSiblings &&
         fs.existsSync(output) &&
-        cacheEntry.outputHash === hashContent(fs.readFileSync(output))
+        cacheEntry.outputHash === hashContent(fs.readFileSync(output)) &&
+        // The Bun target is written beside the module; when it is asked for
+        // and missing, the module is rebuilt so that it gets written.
+        (opts.target !== 'bun' || fs.existsSync(bunTargetPath(output)))
       );
       if (opts.check) {
         if (fresh) cached.push({ input, output });
@@ -460,12 +489,25 @@ async function build(opts) {
         continue;
       }
       compiled.push({ input, output, bytes: outBytes, gzipBytes: gzBytes, errors: e.mode });
+      const stem = path.basename(input, path.extname(input)).replace(/\.schema$/, '');
+      const typeName = stem
+        .replace(/[^A-Za-z0-9_]/g, '_')
+        .replace(/^([a-z])/, (m) => m.toUpperCase()) || 'Data';
+      if (opts.target === 'bun') {
+        const { writeBunTarget, Declined } = require('./bun-target');
+        try {
+          const w = writeBunTarget({ schema: e.schema, input, output, typeName });
+          bunTargets.push({ input, output: w.bunPath, definitions: w.definitions });
+        } catch (err) {
+          if (!(err instanceof Declined)) throw err;
+          // No type can be written; the plain module stands alone.
+          const reason = `--target bun: ${err.message}; the plain module stands alone`;
+          if (opts.strict) { failed.push({ input, error: reason }); continue; }
+          bunDeclined.push({ input, reason });
+        }
+      }
       if (opts.types !== false) {
         const { toTypeScript } = require('./ts-gen');
-        const stem = path.basename(input, path.extname(input)).replace(/\.schema$/, '');
-        const typeName = stem
-          .replace(/[^A-Za-z0-9_]/g, '_')
-          .replace(/^([a-z])/, (m) => m.toUpperCase()) || 'Data';
         const dts = toTypeScript(e.schema, { name: typeName, applyDefaults: /\nfunction applyDefaults\(/.test(src) });
         const ext = path.extname(output);
         const dtsExt = ext === '.mjs' ? '.d.mts'
@@ -514,7 +556,7 @@ async function build(opts) {
   // module, whose errors come from the runtime. Only the written one counts.
   const fromRuntime = new Set(entries.filter((e) => e.mode !== 'inline').map((e) => e.input));
   const kept = warnings.filter((w) => !(w.kind === 'error-detail' && fromRuntime.has(w.input)));
-  return { compiled, cached, skipped, failed, warnings: kept, runtime: runtimeReport };
+  return { compiled, cached, skipped, failed, warnings: kept, runtime: runtimeReport, bunTargets, bunDeclined };
 }
 
 async function watch(opts, onReport) {
@@ -647,6 +689,10 @@ function compiledModuleFor(schema, opts) {
   try {
     src = aot.toStandaloneModule(validatorFor(schema), {
       format: (opts && opts.format) || 'esm',
+      // The one-pass error function where the caller asks (a plugin writing
+      // for a Bun executable): 3.6x cheaper on a rejection, 20% larger gzipped.
+      onePass: opts && opts.onePass === true ? true : undefined,
+      source: opts && opts.onePass === true ? false : undefined,
       // Errors in the runtime's order, for a reader that does not sort them
       // itself (a form resolver); fromCompiled sorts, so a plugin putting
       // that wrapper around the module leaves it off.
@@ -664,7 +710,28 @@ function compiledModuleFor(schema, opts) {
 // not export this, and a plugin should then replace only calls without options.
 const { COMPILED_OPTIONS: compiledOptions } = require('./compiled');
 
+// For a build plugin: the Bun target (lib/bun-target.js) and the verification
+// (lib/verify.js), loaded on first use.
+const bunTarget = {
+  get schemaToBunType () { return require('./bun-target').schemaToBunType },
+  get toBunModule () { return require('./bun-target').toBunModule },
+  get writeBunTarget () { return require('./bun-target').writeBunTarget },
+  get Declined () { return require('./bun-target').Declined },
+  // The generated code's target engine (lib/js-compiler): a plugin that
+  // writes for a Bun executable compiled ahead of time sets 'jsc-aot'.
+  setTargetEngine (engine) { return require('./js-compiler').setTargetEngine(engine) },
+}
+const verify = {
+  get verifyOne () { return require('./verify').verifyOne },
+  get verifySource () { return require('./verify').verifySource },
+  get generate () { return require('./verify').generate },
+  get renderReport () { return require('./verify').renderReport },
+  get ok () { return require('./verify').ok },
+}
+
 module.exports = {
+  bunTarget,
+  verify,
   compiledOptions,
   compiledEligible,
   compiledSchemaFor,