ata-validator 1.60.0 → 1.61.1

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
@@ -48,7 +54,14 @@ resolves to an entry without the code generator through the `workerd` and `edge-
 conditions: the same names and answers, and a Worker bundled by wrangler goes from 179.1 to
 70.4 KiB gzipped.
 
-In a browser bundle the code generator is not part of the page. Every schema starts on the
+In a browser, compile with the bundler plugin. [`@ata-project/unplugin`](https://github.com/ata-core/unplugin-ata)
+turns each `new Validator(schema)` whose schema it can read at build time into a compiled
+validator that gives the same answers, and the runtime stays out of the page. A form with two
+validators, one reading errors and one asking only for a verdict, bundles to 10.7 KB gzipped,
+or 3.1 KB with `richErrors: false` on the one that reads errors, against 53.2 KB for the same
+code on the runtime (esbuild, minified, the runtime with code splitting).
+
+Without the plugin, the code generator is still not part of the page. Every schema starts on the
 interpreted engine, which gives the same answers, and a validator called a thousand times within
 a second loads the generator in the background, through a dynamic import that Vite, webpack and
 Rollup put in a chunk of their own, and is rebuilt on generated code when the page is idle. A
@@ -68,7 +81,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:
 
@@ -643,7 +656,24 @@ checks takes 1.12 ms where the runtime takes 6.63 ms (median of 15 fresh process
 SchemaStore's 977 schemas, 725 can be compiled away; the rest stay on the runtime. Where the code only calls `isValidObject()` or `isValidJSON()`, the plugin uses
 `fromCompiledVerdict()` from `ata-validator/compiled-verdict` instead, which carries no error pipeline: a
 small app that only asks for a boolean bundles to 2.6 KB gzipped, against 12.1 KB with the full wrapper, on
-ata 1.40.0 with `@ata-project/unplugin` 0.5.0.
+ata 1.40.0 with `@ata-project/unplugin` 0.5.0. Where it reads errors but never validates JSON text, the plugin
+uses `fromCompiledObject()` from `ata-validator/compiled-object`, the full wrapper without
+`validateJSON()` and `isValidJSON()` and the position map behind them; and the wrappers fill
+defaults with the compiled module's own `applyDefaults`. A form app with one validator that reads
+errors and one that asks for a boolean went from 16.7 to 13.9 KB gzipped (esbuild, minified),
+ata 1.61.0 against master with `@ata-project/unplugin` 0.11.0 and the change. The wrappers on
+their own: full 13.8 to 12.8 KB, without JSON entry points 10.9, verdict only 2.7 to 1.6.
+A validator built with `{ richErrors: false }` is compiled away as well: the module writes its
+errors in that plain shape (`compiledModuleFor(schema, { plainErrors: true })`) and
+`fromCompiledPlain()` from `ata-validator/compiled-plain` hands them out as they are, with no
+error pipeline in the bundle, 2.6 KB gzipped for the wrapper. Where the plugin sees a
+validator only ever called (`v.validate(x)`, `v.isValidObject(x)`), never handed to other code,
+it uses the bare wrappers of `ata-validator/compiled-bare` instead, which leave out Standard
+Schema and the extension hook nothing can reach there: 0.3 KB gzipped for both, and
+`ata-validator/compiled-bare-rich` for one that reads ata's own errors. The same form app
+bundles to 10.7 KB gzipped, or 3.1 KB with `richErrors: false` on the validator that reads errors. The errors
+then carry `keyword`, `instancePath`, `schemaPath`, `params` and `message`, as that option has
+always given them, without `received`, `suggestion` or `docUrl`.
 
 Programmatic API if you prefer to script it:
 
@@ -667,6 +697,103 @@ 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,
+then a document on either side of each bound the schema states),
+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 +872,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-bare-rich.d.ts

@@ -0,0 +1,6 @@
+// ata-validator/compiled-bare-rich: the compiled-bare wrapper for a validator
+// a bundler plugin sees only called, that reads ata's own errors.
+import type { ValidationResult } from './index.js';
+import type { CompiledModule } from './compiled.js';
+
+export function bareRich<T = unknown>(mod: CompiledModule, schema: object | boolean, useDefaults?: boolean): { validate(data: unknown): ValidationResult<T>; isValidObject(data: unknown): data is T };

package/compiled-bare.d.ts

@@ -0,0 +1,7 @@
+// ata-validator/compiled-bare: the smallest compiled-module wrappers, for a
+// validator a bundler plugin sees used only through direct method calls.
+import type { ValidationResult } from './index.js';
+import type { CompiledModule } from './compiled.js';
+
+export function bareVerdict(mod: CompiledModule, useDefaults?: boolean): { isValidObject(data: unknown): boolean };
+export function barePlain<T = unknown>(mod: CompiledModule, useDefaults?: boolean): { validate(data: unknown): ValidationResult<T>; isValidObject(data: unknown): data is T };

package/compiled-bare.js

@@ -0,0 +1,5 @@
+'use strict';
+
+// ata-validator/compiled-bare: the smallest compiled-module wrappers, for a
+// bundler plugin. See lib/compiled-bare.js.
+module.exports = require('./lib/compiled-bare.js');

package/compiled-bare.mjs

@@ -0,0 +1,35 @@
+// ata-validator/compiled-bare as an ES module of its own rather than a
+// re-export of the CommonJS file: a bundler then has no CommonJS interop to
+// add, which was more than half of the bundled size (662 to 315 bytes
+// gzipped). The same functions as lib/compiled-bare.js;
+// tests/test_compiled_bare.js holds the two to the same answers.
+
+const EMPTY_ERRORS = Object.freeze([]);
+const VERDICT_DISAGREES = Object.freeze({
+  valid: false,
+  errors: Object.freeze([Object.freeze({ keyword: 'validation', instancePath: '', schemaPath: '#', params: Object.freeze({}), message: 'schema validation failed' })]),
+});
+
+function verdictOf(mod, useDefaults) {
+  const fill = useDefaults !== false && typeof mod.applyDefaults === 'function' ? mod.applyDefaults : null;
+  return fill ? (d) => { fill(d); return mod.isValid(d); } : mod.isValid;
+}
+
+export function bareVerdict(mod, useDefaults) {
+  return { isValidObject: verdictOf(mod, useDefaults) };
+}
+
+export function barePlain(mod, useDefaults) {
+  const isValid = verdictOf(mod, useDefaults);
+  const errFn = mod.validate;
+  return {
+    validate(data) {
+      if (isValid(data)) return { valid: true, data, errors: EMPTY_ERRORS };
+      const r = errFn(data);
+      return r && r.valid === false ? { valid: false, errors: r.errors } : VERDICT_DISAGREES;
+    },
+    isValidObject: isValid,
+  };
+}
+
+export default { bareVerdict, barePlain };

package/compiled-object.d.ts

@@ -0,0 +1,11 @@
+// ata-validator/compiled-object: ata-validator/compiled without the JSON text
+// entry points, for code that reads errors but never calls validateJSON().
+import type { ValidationResult } from './index.js';
+import type { CompiledModule, CompiledOptions } from './compiled.js';
+
+export interface CompiledObjectValidator<T = unknown> {
+  validate(data: unknown): ValidationResult<T>;
+  isValidObject(data: unknown): data is T;
+}
+
+export function fromCompiledObject<T = unknown>(mod: CompiledModule, schema: object, options?: CompiledOptions): CompiledObjectValidator<T>;

package/compiled-object.js

@@ -0,0 +1,6 @@
+'use strict';
+
+// ata-validator/compiled-object: ata-validator/compiled without validateJSON()
+// and isValidJSON(), for code that reads errors but never validates JSON text.
+// See lib/compiled-object.js.
+module.exports = require('./lib/compiled-object.js');

package/compiled-object.mjs

@@ -0,0 +1,3 @@
+import mod from './compiled-object.js';
+export const { fromCompiledObject } = mod;
+export default mod;

package/compiled-plain.d.ts

@@ -0,0 +1,16 @@
+// ata-validator/compiled-plain: the compiled-module wrapper for a Validator
+// built with `richErrors: false`, for a module written with `plainErrors: true`.
+import type { ValidationResult } from './index.js';
+import type { CompiledModule } from './compiled.js';
+
+export interface CompiledPlainValidator<T = unknown> {
+  validate(data: unknown): ValidationResult<T>;
+  isValidObject(data: unknown): data is T;
+}
+
+export interface CompiledPlainOptions {
+  richErrors?: false;
+  useDefaults?: boolean;
+}
+
+export function fromCompiledPlain<T = unknown>(mod: CompiledModule, schema: object, options?: CompiledPlainOptions): CompiledPlainValidator<T>;

package/compiled-plain.js

@@ -0,0 +1,5 @@
+'use strict';
+
+// ata-validator/compiled-plain: the compiled-module wrapper for a Validator
+// built with `richErrors: false`. See lib/compiled-plain.js.
+module.exports = require('./lib/compiled-plain.js');

package/compiled-plain.mjs

@@ -0,0 +1,3 @@
+import mod from './compiled-plain.js';
+export const { fromCompiledPlain } = mod;
+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;