ata-validator 1.62.0 → 1.63.0

package/README.md

@@ -101,19 +101,14 @@ The `ata-validator` package itself is pure JavaScript. The native accelerator (s
 npm install ata-validator --omit=optional
 ```
 
-or set `ATA_NO_NATIVE=1` at runtime. Typical schemas compile to specialized JS; shapes the compiler cannot represent (some `$dynamicRef`, cyclic `$ref`, unusual keyword interactions) fall back to an interpreted engine, so every schema validates in every environment. The pure-JS setup scores the same on the official suite as the native one, 1301 of 1301 Draft 2020-12 cases. The buffer and parallel APIs (`isValid` on raw buffers, `isValidPrepadded`, `isValidNDJSON`, `isValidParallel`, `countValid`, `batchIsValid`, `validateAndParse`) work without the addon too, answering through the same checks as `isValidJSON()`, slower than the addon: 177 ns against 92 for a small document on Node 25. In a browser, which has no `Buffer`, they throw and name the methods to use instead.
+or set `ATA_NO_NATIVE=1` at runtime. Typical schemas compile to specialized JS; shapes the compiler cannot represent (some `$dynamicRef`, cyclic `$ref`, unusual keyword interactions) fall back to an interpreted engine, so every schema validates in every environment. The pure-JS setup scores the same on the official suite as the native one, 1302 of 1302 Draft 2020-12 cases. The buffer and parallel APIs (`isValid` on raw buffers, `isValidPrepadded`, `isValidNDJSON`, `isValidParallel`, `countValid`, `batchIsValid`, `validateAndParse`) work without the addon too, answering through the same checks as `isValidJSON()`, slower than the addon: 177 ns against 92 for a small document on Node 25. In a browser, which has no `Buffer`, they throw and name the methods to use instead.
 
 In Cloudflare Workers and Vercel Edge, where generated code cannot run, `ata-validator`
 resolves to an entry without the code generator through the `workerd` and `edge-light` export
 conditions: the same names and answers, and a Worker bundled by wrangler goes from 179.1 to
 70.4 KiB gzipped.
 
-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).
+In a browser, compile with the bundler plugin: see [In the browser](#in-the-browser).
 
 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
@@ -133,9 +128,9 @@ re-exports the npm one at the same version, and CI runs the official suite under
 details, and what Deno Deploy's refusal of dynamic code means for it, are in
 [docs/edge-runtimes.md](docs/edge-runtimes.md).
 
-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.
+Those four now agree with `validate()` on every case of the official suite, 3366 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 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.
+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 1302 of 1302 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:
 
@@ -162,7 +157,67 @@ if (isValid(req.body)) {
 
 The `.compiled.mjs` modules are self-contained: zero runtime dependency on ata-validator, fully tree-shakeable, with TypeScript types emitted alongside.
 
-Code already written with `new Validator(schema)` gets the same result from the bundler plugin, without changes: [`@ata-project/unplugin`](https://github.com/ata-core/unplugin-ata) replaces each call whose schema is known at build time with a compiled validator that answers the same, and the runtime leaves the bundle. For the plugin's three-schema test entry a minified Vite build goes from 122.5 KB to 16.7 KB gzipped on ata 1.39.2. Schemas that arrive at runtime keep the runtime, which is the right tool for them.
+Code already written with `new Validator(schema)` gets the same result from the bundler plugin, without changes: [`@ata-project/unplugin`](https://github.com/ata-core/unplugin-ata) replaces each call whose schema is known at build time with a compiled validator that answers the same, and the runtime leaves the bundle. The sizes are in [In the browser](#in-the-browser). Schemas that arrive at runtime keep the runtime, which is the right tool for them.
+
+## In the browser
+
+Add the bundler plugin. [`@ata-project/unplugin`](https://github.com/ata-core/unplugin-ata) compiles each `new Validator(schema)` whose schema it can read at build time, so the page carries that schema's checks and not the compiler. Your code does not change, and the answers, the errors and the filled defaults are the same.
+
+```js
+// vite.config.js
+import ata from '@ata-project/unplugin/vite'
+
+export default { plugins: [ata()] }
+```
+
+```js
+// next.config.mjs, for Turbopack (the default since Next.js 16) and webpack
+import withAta from '@ata-project/unplugin/next'
+
+export default withAta({ /* your config */ })
+```
+
+Webpack, Rspack, Rollup, Rolldown, esbuild and Bun take the same plugin; see its [setup](https://github.com/ata-core/unplugin-ata#setup).
+
+An order form with six fields, an email format, a pattern and a default, its errors read on submit:
+
+| | gzipped | ready, phone profile | first submit |
+|---|---|---|---|
+| without the plugin (code split) | 55.3 KB | 779 ms | 13.9 ms |
+| with the plugin | 4.5 KB | 372 ms | 1.6 ms |
+
+The sizes are an esbuild build, minified, gzip level 9. The times are Chrome with Lighthouse's mobile throttling (CPU 4x slower, 1.6 Mbps, 150 ms round trip), the files served gzipped, medians of 11 runs; the submit is made as soon as the page has loaded, before the runtime warms itself up in idle time, so a later submit on the runtime takes less than that.
+
+What a page's validators add to its first load, gzipped, in applications built the usual way (Vite + React, Next.js 16), forms of six fields reading their errors on submit:
+
+| | ata 1.62.1, plugin 0.11.3 | ata 1.63.0, plugin 0.12.0 |
+|---|---|---|
+| Vite, one form | 2.33 KB | 1.41 KB |
+| Vite, ten forms | 8.02 KB | 2.02 KB |
+| Vite, ten forms with email and uri fields | 12.07 KB | 2.70 KB |
+| Next.js with webpack, one form with rich errors | 10.71 KB | 4.63 KB |
+| Next.js with Turbopack, one form with rich errors | 67.52 KB (the plugin could not run) | 4.23 KB |
+
+Many forms go out as data for one shared interpreter instead of code, where that makes the bundle smaller; the plugin decides for the whole application, and keeps written code for a single form. Needs ata-validator 1.63.0 and the plugin's 0.12.0.
+
+With an OpenAPI document the plugin writes the validators from it (`ata({ openapi: 'openapi.json' })`, request bodies by operation, see [its README](https://github.com/ata-core/unplugin-ata#one-openapi-document-for-the-server-and-the-page)); a server reads the same document through `operationSchemas` in `ata-validator/openapi`.
+
+The form and the server decide alike. A validator the plugin compiles answers exactly as `new Validator(schema)` does on the server, the same schema read the same way, when the page is built with the same ata-validator version the server runs: on a nine-field signup schema (email, uri, a pattern, lengths counted in characters, a fixed set of fields) the compiled form and the server's validator disagreed on 0 of 50,000 generated documents, so a submit the page accepts is one the server accepts.
+
+A schema that arrives at run time (a form builder, a CMS, a schema served by the backend) can arrive as a plan instead. The server writes it with `tablePlan` from `ata-validator/ir`, which does the heavy work (references, dialects, normalization); the page reads it with `fromPlan` from `ata-validator/plan`, which carries the table interpreter and loads the format checks a plan names when it names them. Verdicts, errors and filled defaults are the server's for the same schema.
+
+```js
+// server
+import { tablePlan } from 'ata-validator/ir'
+app.get('/forms/signup', () => tablePlan(signupSchema, { richErrors: false }))
+
+// page
+import { fromPlan } from 'ata-validator/plan'
+const v = await fromPlan(await (await fetch('/forms/signup')).json())
+v.validate(data)
+```
+
+For the nine-field signup schema above, a Vite page that receives its schema at run time loads 53.0 KB of JavaScript gzipped with `new Validator(schema)` and 6.2 KB with `fromPlan`, the errors on the page the same. `ata-validator/plan-rich` reads plans with ata's rich errors as well. A plan is as trusted as a schema, so serve it from your own server: `fromPlan` refuses one that is not well formed before it runs, and says so once when a plan was written by another ata-validator version, whose answers may differ. A plan takes the keywords forms use (types, properties, required, additionalProperties, the leaf checks and formats, items, allOf, `$ref`, not, if, dependentRequired) and defaults; `tablePlan` returns `null` for anything else, and such a schema keeps the runtime.
 
 ## Measured by others
 
@@ -994,7 +1049,7 @@ Copy-paste recipes for the common frameworks. Most need 10-20 lines of glue. See
 | Fastify | dedicated plugin | [`fastify-ata`](https://github.com/ata-core/fastify-ata) |
 | Vite, Webpack, Rollup, Rolldown, esbuild, Rspack (build-time compile) | dedicated plugin | [`@ata-project/unplugin`](https://github.com/ata-core/unplugin-ata) |
 | 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` |
+| Next.js (build-time compile, Turbopack and webpack) | config wrapper of the plugin above | `withAta` from `@ata-project/unplugin/next` in `next.config.mjs` |
 | Hono | async middleware | [docs/integrations/hono.md](docs/integrations/hono.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) |
@@ -1024,7 +1079,7 @@ Copy-paste recipes for the common frameworks. Most need 10-20 lines of glue. See
 
 ### Dialects
 
-`$schema` selects the dialect. Draft 2020-12 is the default; draft-07, draft-06, draft-04 and Draft 2019-09 are rewritten to the 2020-12 spelling on the way in (draft-06 as draft-07 without `if`/`then`/`else`, draft-04 as draft-06 with `id` for `$id` and without `const`, `contains` and `propertyNames`, 2019-09's tuple `items` and `$recursiveRef` as `prefixItems` and `$dynamicRef`); and `https://json-schema.org/v1` (or the dated `https://json-schema.org/v1/2026`) selects JSON Schema v1. The official suite passes in full on all five: 1301 of 1301 on 2020-12, 1261 of 1261 on 2019-09, 929 of 929 on draft-07, 841 of 841 on draft-06 and 1135 of 1135 on v1, with code generation allowed and blocked. Draft-04 and earlier are not supported; draft-04's boolean `exclusiveMinimum`/`exclusiveMaximum` is read wherever it appears.
+`$schema` selects the dialect. Draft 2020-12 is the default; draft-07, draft-06, draft-04 and Draft 2019-09 are rewritten to the 2020-12 spelling on the way in (draft-06 as draft-07 without `if`/`then`/`else`, draft-04 as draft-06 with `id` for `$id` and without `const`, `contains` and `propertyNames`, 2019-09's tuple `items` and `$recursiveRef` as `prefixItems` and `$dynamicRef`); and `https://json-schema.org/v1` (or the dated `https://json-schema.org/v1/2026`) selects JSON Schema v1. The official suite passes in full on all five: 1302 of 1302 on 2020-12, 1261 of 1261 on 2019-09, 929 of 929 on draft-07, 841 of 841 on draft-06 and 1135 of 1135 on v1, with code generation allowed and blocked. Draft-04 and earlier are not supported; draft-04's boolean `exclusiveMinimum`/`exclusiveMaximum` is read wherever it appears.
 
 Two things differ under v1. `propertyDependencies` selects a subschema by the value of a property rather than by its presence, which is what `dependentSchemas` does. And `$dynamicRef` no longer requires bookending: the reference resolves through the dynamic scope whether or not the schema it first lands on carries a matching `$dynamicAnchor`, so the outermost matching anchor still in scope wins. Everything else ata implements is identical under both dialects, so a schema that declares no `$schema` behaves exactly as before.
 
@@ -1036,7 +1091,7 @@ Both are implemented in the interpreted engine, so a v1 schema that uses `$dynam
 
 ### Known limitations
 
-Running the whole Draft 2020-12 suite with nothing excluded, `format` and `default` under specification semantics (`assertFormat: false`, `useDefaults: false`), gives 1301 of 1301 cases. Draft 2019-09 gives 1261 of 1261, draft 7 929 of 929, draft-06 841 of 841, draft-04 618 of 618. The v1 dialect gives 1135 of 1135. `npm run test:suite` reproduces all three.
+Running the whole Draft 2020-12 suite with nothing excluded, `format` and `default` under specification semantics (`assertFormat: false`, `useDefaults: false`), gives 1302 of 1302 cases. Draft 2019-09 gives 1261 of 1261, draft 7 929 of 929, draft-06 841 of 841, draft-04 618 of 618. The v1 dialect gives 1135 of 1135. `npm run test:suite` reproduces all three.
 
 Areas that remain deliberate scope decisions for 1.x:
 

package/build.mjs

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

package/index.browser.mjs

@@ -12,9 +12,28 @@
 import core from './lib/validator-core.js';
 import tiering from './lib/tiering.js';
 import { toTypeScript, renderPretty, renderCompact, toOutput, toRetryMessage, describeSchema, renderJSON } from './lib/tools.mjs';
+import { defineSchema, schemaOf } from './lib/schema-helpers.mjs';
 
-core._registerTiering(tiering.createTiering(() => import('./lib/codegen-engine.js')));
-
-export const { Validator, compile, validate, validateAsync, parseAsync, version, createPaddedBuffer, SIMDJSON_PADDING, parseJSON, defineSchema, schemaOf } = core;
+// Pure-marked reads, so a bundler drops what goes unused (lib/schema-helpers.mjs).
+// In development, once: a page that loads this entry compiles its schemas in
+// the browser, and a schema the build can read could be compiled by the build
+// instead. A production build replaces process.env.NODE_ENV and drops the
+// whole statement, the try included; where nothing defines process, the
+// ReferenceError is caught. Not in Node (no document).
+const api = /* @__PURE__ */ (() => {
+  core._registerTiering(tiering.createTiering(() => import('./lib/codegen-engine.js')));
+  try { if (process.env.NODE_ENV !== 'production' && typeof document !== 'undefined') console.info('ata-validator: this page compiles its schemas in the browser, which takes the validator runtime (about 51 KB gzipped). A schema the build can read can be compiled by the build instead, a few KB for a form: https://github.com/ata-core/unplugin-ata') } catch {}
+  return core;
+})();
+export const Validator = /* @__PURE__ */ (() => api.Validator)();
+export const compile = /* @__PURE__ */ (() => api.compile)();
+export const validate = /* @__PURE__ */ (() => api.validate)();
+export const validateAsync = /* @__PURE__ */ (() => api.validateAsync)();
+export const parseAsync = /* @__PURE__ */ (() => api.parseAsync)();
+export const version = /* @__PURE__ */ (() => api.version)();
+export const createPaddedBuffer = /* @__PURE__ */ (() => api.createPaddedBuffer)();
+export const SIMDJSON_PADDING = /* @__PURE__ */ (() => api.SIMDJSON_PADDING)();
+export const parseJSON = /* @__PURE__ */ (() => api.parseJSON)();
+export { defineSchema, schemaOf };
 export { toTypeScript, 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 };
+export default /* @__PURE__ */ (() => ({ Validator: api.Validator, compile: api.compile, validate: api.validate, validateAsync: api.validateAsync, parseAsync: api.parseAsync, version: api.version, createPaddedBuffer: api.createPaddedBuffer, SIMDJSON_PADDING: api.SIMDJSON_PADDING, parseJSON: api.parseJSON, toTypeScript, defineSchema, schemaOf, renderPretty, renderCompact, toOutput, toRetryMessage, describeSchema, renderJSON }))();

package/index.bundle.mjs

@@ -7,9 +7,19 @@
 import core from './lib/validator-core.js';
 import engine from './lib/codegen-engine.js';
 import { toTypeScript, renderPretty, renderCompact, toOutput, toRetryMessage, describeSchema, renderJSON } from './lib/tools.mjs';
+import { defineSchema, schemaOf } from './lib/schema-helpers.mjs';
 
-core._registerCodegen(engine);
-
-export const { Validator, compile, validate, validateAsync, parseAsync, version, createPaddedBuffer, SIMDJSON_PADDING, parseJSON, defineSchema, schemaOf } = core;
+// Pure-marked reads, so a bundler drops what goes unused (lib/schema-helpers.mjs).
+const api = /* @__PURE__ */ (() => { core._registerCodegen(engine); return core; })();
+export const Validator = /* @__PURE__ */ (() => api.Validator)();
+export const compile = /* @__PURE__ */ (() => api.compile)();
+export const validate = /* @__PURE__ */ (() => api.validate)();
+export const validateAsync = /* @__PURE__ */ (() => api.validateAsync)();
+export const parseAsync = /* @__PURE__ */ (() => api.parseAsync)();
+export const version = /* @__PURE__ */ (() => api.version)();
+export const createPaddedBuffer = /* @__PURE__ */ (() => api.createPaddedBuffer)();
+export const SIMDJSON_PADDING = /* @__PURE__ */ (() => api.SIMDJSON_PADDING)();
+export const parseJSON = /* @__PURE__ */ (() => api.parseJSON)();
+export { defineSchema, schemaOf };
 export { toTypeScript, 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 };
+export default /* @__PURE__ */ (() => ({ Validator: api.Validator, compile: api.compile, validate: api.validate, validateAsync: api.validateAsync, parseAsync: api.parseAsync, version: api.version, createPaddedBuffer: api.createPaddedBuffer, SIMDJSON_PADDING: api.SIMDJSON_PADDING, parseJSON: api.parseJSON, toTypeScript, defineSchema, schemaOf, renderPretty, renderCompact, toOutput, toRetryMessage, describeSchema, renderJSON }))();

package/index.edge.mjs

@@ -5,9 +5,19 @@
 import core from './lib/validator-core.js';
 import aotBrowser from './lib/aot.browser.js';
 import { toTypeScript, renderPretty, renderCompact, toOutput, toRetryMessage, describeSchema, renderJSON } from './lib/tools.mjs';
+import { defineSchema, schemaOf } from './lib/schema-helpers.mjs';
 
-core._registerAot(() => aotBrowser);
-
-export const { Validator, compile, validate, validateAsync, parseAsync, version, createPaddedBuffer, SIMDJSON_PADDING, parseJSON, defineSchema, schemaOf } = core;
+// Pure-marked reads, so a bundler drops what goes unused (lib/schema-helpers.mjs).
+const api = /* @__PURE__ */ (() => { core._registerAot(() => aotBrowser); return core; })();
+export const Validator = /* @__PURE__ */ (() => api.Validator)();
+export const compile = /* @__PURE__ */ (() => api.compile)();
+export const validate = /* @__PURE__ */ (() => api.validate)();
+export const validateAsync = /* @__PURE__ */ (() => api.validateAsync)();
+export const parseAsync = /* @__PURE__ */ (() => api.parseAsync)();
+export const version = /* @__PURE__ */ (() => api.version)();
+export const createPaddedBuffer = /* @__PURE__ */ (() => api.createPaddedBuffer)();
+export const SIMDJSON_PADDING = /* @__PURE__ */ (() => api.SIMDJSON_PADDING)();
+export const parseJSON = /* @__PURE__ */ (() => api.parseJSON)();
+export { defineSchema, schemaOf };
 export { toTypeScript, 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 };
+export default /* @__PURE__ */ (() => ({ Validator: api.Validator, compile: api.compile, validate: api.validate, validateAsync: api.validateAsync, parseAsync: api.parseAsync, version: api.version, createPaddedBuffer: api.createPaddedBuffer, SIMDJSON_PADDING: api.SIMDJSON_PADDING, parseJSON: api.parseJSON, toTypeScript, defineSchema, schemaOf, renderPretty, renderCompact, toOutput, toRetryMessage, describeSchema, renderJSON }))();

package/index.js

@@ -136,6 +136,11 @@ function attachSuggestions (errors, data) {
   return errors;
 }
 
+// Loaded on first call, like the tools: a process that never calls them does
+// not read the file.
+function defineSchema (schema) { return require('./lib/schema-helpers.js').defineSchema(schema); }
+function schemaOf (...a) { return require('./lib/schema-helpers.js').schemaOf(...a); }
+
 module.exports = {
   Validator: core.Validator,
   compile: core.compile,
@@ -147,8 +152,8 @@ module.exports = {
   SIMDJSON_PADDING: core.SIMDJSON_PADDING,
   parseJSON: core.parseJSON,
   toTypeScript,
-  defineSchema: core.defineSchema,
-  schemaOf: core.schemaOf,
+  defineSchema,
+  schemaOf,
   renderPretty,
   renderCompact,
   toOutput,

package/lib/aot-build.js

@@ -737,6 +737,23 @@ function compiledModuleFor(schema, opts) {
   return src && !degraded ? src : null;
 }
 
+// The runtime's defaults pass for a schema as the body of a function of `d`
+// (preprocessSource in lib/codegen-engine.js, over the schema the runtime
+// builds it from, as the modules compiledModuleFor writes carry it), or null
+// where the generated pass declines the schema. For a writer of modules that
+// has no generated pass of its own for that schema (ata-validator/ir's
+// specialize, through its fillSource option).
+function defaultsSource(schema) {
+  if (!compiledEligible(schema)) return null;
+  try {
+    const v = validatorFor(schema);
+    const { resolveSchemaForPreprocess } = require('./validator-core')._internals;
+    return require('./codegen-engine').preprocessSource(resolveSchemaForPreprocess(v._schemaObj, v._schemaMap), { useDefaults: true });
+  } catch {
+    return null;
+  }
+}
+
 // The Validator options fromCompiled() reproduces, for a plugin deciding whether
 // `new Validator(schema, options)` can be replaced. An older ata-validator does
 // not export this, and a plugin should then replace only calls without options.
@@ -768,6 +785,7 @@ module.exports = {
   compiledEligible,
   compiledSchemaFor,
   compiledModuleFor,
+  defaultsSource,
   build,
   expandGlobs,
   parseSchemaFile,

package/lib/aot-impl.js

@@ -19,6 +19,20 @@ const VALID_RESULT = Object.freeze({ valid: true, errors: Object.freeze([]) });
 const { buildTargetedPositionMap } = require('./data-positions');
 const { schemaHash } = require('./schema-hash');
 const ATA_VERSION = require('./version');
+
+// The emitters write what the code generator produces, so they register it.
+// The browser build loads the generator on demand, once a validator is hot,
+// and until it had, bundleStandalone() compiled every schema to a null
+// validator without an error: a page calling it got an empty module. Done at
+// the first call rather than at load, where a loader that evaluates every
+// require first (esm.sh) would hand over the generator half built.
+let _codegenReady = false;
+function needCodegen() {
+  if (_codegenReady) return;
+  const core = require('./validator-core.js');
+  if (!core._codegenRegistered()) core._registerCodegen(require('./codegen-engine.js'));
+  _codegenReady = true;
+}
 const safeRegexEngineSource = () => require('./safe-regex').engineSource();
 
 // Embedded verbatim in standalone modules so the output file has no runtime
@@ -1378,5 +1392,11 @@ module.exports = {
   bundleCompact: htmlSafeResult(bundleCompact),
   loadBundle,
 };
+
+// Every emitter registers the code generator before it runs (needCodegen).
+for (const k of Object.keys(module.exports)) {
+  const f = module.exports[k];
+  if (typeof f === 'function') module.exports[k] = function (...a) { needCodegen(); return f.apply(this, a); };
+}
 // For the build only (lib/aot-build.js), not part of ata-validator/aot.
 Object.defineProperty(module.exports, '_refsResolveWithin', { value: refsResolveWithin, enumerable: false });

package/lib/codegen-engine.js

@@ -740,7 +740,10 @@ function emitRemovals(node, access, lines, depth, seen, own) {
   }
   seen.delete(node);
   if (body.length === 0) return;
-  if (depth === 0) lines.push(...body);
+  // At the root too, an array is not the object this node describes: its
+  // indices are not additional properties. The pass's own guard lets arrays
+  // through for the coercions of a schema whose root is an array.
+  if (depth === 0) lines.push(`if(!Array.isArray(${access})){${body.join('\n')}}`);
   else lines.push(`if(${own}${access}!==null&&typeof ${access}==='object'&&!Array.isArray(${access})){${body.join('\n')}}`);
 }
 
@@ -1194,6 +1197,63 @@ function buildParse (self, decline, extended) {
 // carry. Returns the twin to answer this call, or null to compile.
 const COLD_CALLS = 64;
 const COLD_MIN = 16 * 1024;
+const MANY_SCHEMAS = 16;
+const SMALL_TWIN_OFF = typeof process !== 'undefined' && process.env !== undefined && process.env.ATA_NO_SMALL_TWIN === '1';
+let _firstCalls = 0;
+let _canGenerate = null;
+function canGenerate () {
+  if (_canGenerate === null) { try { _canGenerate = require('./compile-fn').compileFunction('return 1')() === 1; } catch { _canGenerate = false; } }
+  return _canGenerate;
+}
+let _core = null;
+let _keySelf = null; let _key = null;
+// The compile cache key compileCached just built for this validator, once.
+function keyFor (self) { if (_keySelf !== self) return null; const k = _key; _keySelf = null; _key = null; return k; }
+const core_ = () => _core || (_core = require('./validator-core')._internals);
+function compileCached (self) {
+  if (self._userFormats || self._usesKeywords) return false;
+  const { _compileCache, compileCacheKey } = core_();
+  const str = self._schemaStr || (self._schemaStr = JSON.stringify(self._schemaObj));
+  const key = compileCacheKey(str, self._schemaMap) + '\u0000' + (typeof jsCompiler.targetEngine === 'function' ? jsCompiler.targetEngine() : 'v8');
+  // Kept for the compile that follows in the same call (keyFor), which would
+  // build and hash the same key again.
+  _keySelf = self; _key = key;
+  const c = _compileCache.get(key);
+  return c !== undefined && c.jsFn !== undefined && c.jsFn !== null;
+}
+// A small schema's twin, once the process has met MANY_SCHEMAS schemas (an
+// agent's tools, a registry of thousands): the interpreted engine alone, which
+// answers a verdict and a valid document's validate(); a document that fails,
+// or a JSON-text call, compiles the validator, which answers as always. A new
+// five-property schema's first check took 72 us compiled and 13 on it, and
+// its memory is about the compiled validator's (8.37 against 8.57 KB). A
+// server with a few routes compiles them at their first call as before, and
+// neither a cached schema nor a realm without code generation takes it.
+// ATA_NO_SMALL_TWIN=1 turns it off, for tests of the generated code.
+class SmallTwin {
+  constructor (self, interp) { this.v = self; this.i = interp; }
+  // A document that fails, or a call the interpreted verdict does not answer,
+  // compiles the validator, which answers it as always.
+  compile () { this.v._coldCalls = COLD_CALLS; this.v._twin = null; return this.v; }
+  isValidObject (d) { return this.i.isValid(d); }
+  validate (d) { return this.i.isValid(d) ? { valid: true, data: d, errors: [] } : this.compile().validate(d); }
+  validateJSON (t) { return this.compile().validateJSON(t); }
+  isValidJSON (t) { return this.compile().isValidJSON(t); }
+}
+// The twin is made before the validator compiles, so it has none of what the
+// compile prepares: the vendored meta-schemas a reference to json-schema.org
+// resolves against, vocabularies, and the reading of an `$id` fragment as an
+// anchor where the dialect is not named. A schema that needs any of these
+// compiles at its first call as before: a reference other than a JSON pointer
+// into the document itself, an identifier or anchor, or a `$schema` outside
+// json-schema.org. With them the twin answered false where the compiled
+// validator answers true, so isValidObject and validate() disagreed after a
+// process had met sixteen schemas.
+const TWIN_DECLINES = /"\$(?:id|anchor|dynamicAnchor|recursiveAnchor|dynamicRef|recursiveRef|vocabulary)"|"\$ref":"(?!#\/|#")|"\$schema":"(?!https?:\/\/json-schema\.org\/)/;
+function smallTwin (self) {
+  const { _interpArgs } = core_();
+  return new SmallTwin(self, require('./interpreter').createInterpreter(self._schemaObj, _interpArgs(self, self._schemaObj)));
+}
 // Whether the schema may expand past `limit`, answered from its text where
 // that settles it. Without a `$ref` nothing expands, and expandedChars counts
 // at most 8 for each character of the text, so a short schema is decided
@@ -1208,11 +1268,16 @@ function mayExpandPast (self, limit) {
 
 function coldTwin (self, Validator) {
   const n = self._coldCalls === undefined ? 0 : self._coldCalls;
-  if (n >= COLD_CALLS || self._validateTail !== null || self._verdictTail !== null) return null;
+  // Past COLD_CALLS the validator compiles, and the twin is let go: it was
+  // kept for the life of the validator, an interpreted copy of every large
+  // schema in memory beside its generated code.
+  if (n >= COLD_CALLS || self._validateTail !== null || self._verdictTail !== null) { self._twin = null; return null; }
   let t = self._twin;
   if (t === undefined) {
     t = null;
-    if (!self._interpretOnly && !self._initialized && mayExpandPast(self, COLD_MIN)) {
+    if (!self._interpretOnly && !self._initialized && !SMALL_TWIN_OFF && ++_firstCalls > MANY_SCHEMAS && !self._usesKeywords && !self._userFormats && !self._verbose && !self._options.abortEarly && canGenerate() && !compileCached(self) && !self._needsPreprocess() && !mayExpandPast(self, COLD_MIN) && !TWIN_DECLINES.test(self._schemaStr)) {
+      try { t = smallTwin(self); } catch { t = null; }
+    } else if (!self._interpretOnly && !self._initialized && mayExpandPast(self, COLD_MIN)) {
       try {
         t = new Validator(self._rawSchema, Object.assign({}, self._options, { engine: 'interpreter' }));
         // The registry as it is now, not as the constructor options had it:
@@ -1226,6 +1291,9 @@ function coldTwin (self, Validator) {
       } catch { t = null; }
     }
     self._twin = t;
+    // A key kept for a compile that does not follow now would go stale (a
+    // registry changed before the validator compiles).
+    if (t !== null) { _keySelf = null; _key = null; }
   }
   if (t === null) return null;
   self._coldCalls = n + 1;
@@ -1234,6 +1302,7 @@ function coldTwin (self, Validator) {
 
 module.exports = {
   jsCompiler,
+  keyFor,
   coldTwin,
   // The native locator for error frames, loaded with the first frame.
   nativePositions: () => require('./native-positions').nativeTargeted,

package/lib/compiled-common.js

@@ -19,7 +19,8 @@ function carriesDefaults (mod) {
 }
 function defaultsFor (mod, schema) {
   if (carriesDefaults(mod)) return typeof mod.applyDefaults === 'function' ? mod.applyDefaults : null;
-  return require('./compiled-defaults')(schema);
+  const d = require('./compiled-defaults');
+  return (typeof d === 'function' ? d : d.default)(schema);
 }
 
 // The Validator options the wrapper answers the same way as the runtime.

package/lib/email-literal.js

@@ -24,6 +24,9 @@ const IPV6_RE = (() => {
 // function it is written into when the literal is not an address.
 let _src = null;
 module.exports = () => _src || (_src =
-  `if((_in.charCodeAt(0)|32)===105&&(_in.charCodeAt(1)|32)===112&&(_in.charCodeAt(2)|32)===118&&_in.charCodeAt(3)===54&&_in.charCodeAt(4)===58){const _i6=_in.slice(5);if(_i6.length>45||!${IPV6_RE}.test(_i6))return false}` +
+  // The tag is matched without regard to case; outside the unicode flag /i
+  // folds no character above 127 onto an ASCII one, so this is the same test
+  // as comparing each code unit with `|32`.
+  `if(/^ipv6:/i.test(_in)){const _i6=_in.slice(5);if(_i6.length>45||!${IPV6_RE}.test(_i6))return false}` +
   `else if(_in.length>15||!${require('./formats').IPV4}.test(_in))return false`);
 module.exports.IPV6_RE = IPV6_RE;

package/lib/error-runtime-features.js

@@ -0,0 +1,41 @@
+'use strict';
+
+// The parts of the shared error runtime a set of schemas needs, and the
+// table of error codes it carries. Pure functions over schemas, kept apart
+// from lib/error-runtime.js, which reads the library's files with fs, so a
+// browser bundle can use these without it (see lib/error-runtime.browser.js).
+
+// The parts a build can leave out when none of its schemas needs them. The
+// decision is made on the schemas the runtime walks (as embedded, see
+// runtimeFeatures) and errs toward keeping a part: a key with that name
+// anywhere, even inside an enum value, keeps it. A part left out is replaced
+// by a stub that throws, which a schema without that keyword cannot reach.
+const OPTIONAL = {
+  formats: { keys: ['format'], stub: 'module.exports = {};' },
+  'safe-regex': { keys: ['pattern', 'patternProperties'], stub: "module.exports = { compileSafe() { throw new Error('ata error runtime: built without the pattern engine'); } };" },
+  'unique-items': { keys: ['uniqueItems', 'enum', 'const'], stub: "function no() { throw new Error('ata error runtime: built without deep equality'); }\nmodule.exports = { allDistinct: no, duplicatePair: no, _deq: no };" },
+};
+
+// Which optional parts these schemas need: { formats, 'safe-regex',
+// 'unique-items' } as booleans.
+function runtimeFeatures(schemas) {
+  const keys = new Set();
+  const seen = new Set();
+  const walk = (n) => {
+    if (n === null || typeof n !== 'object' || seen.has(n)) return;
+    seen.add(n);
+    if (Array.isArray(n)) { for (const x of n) walk(x); return; }
+    for (const k of Object.keys(n)) { keys.add(k); walk(n[k]); }
+  };
+  for (const s of schemas) walk(s);
+  const out = {};
+  for (const [part, { keys: ks }] of Object.entries(OPTIONAL)) out[part] = ks.some((k) => keys.has(k));
+  return out;
+}
+
+function codeTable() {
+  const { byKw, byFmt } = require('./error-code-of');
+  return { byKw, byFmt };
+}
+
+module.exports = { OPTIONAL, runtimeFeatures, codeTable };

package/lib/error-runtime.browser.js

@@ -0,0 +1,15 @@
+'use strict';
+
+// Browser twin of lib/error-runtime.js, wired by the package.json `browser`
+// field. The shared error runtime is put together from the library's own
+// files with fs, which a build tool does and a page does not; the emitters a
+// page can call (bundleStandalone, toStandaloneModule) never need it. Pulling
+// fs into a browser bundle stopped esbuild outright and left Vite with an
+// empty stand-in.
+const { runtimeFeatures, codeTable } = require('./error-runtime-features');
+
+function errorRuntimeSource() {
+  throw new Error('errorRuntimeSource() reads the library files and runs at build time, not in a browser');
+}
+
+module.exports = { errorRuntimeSource, runtimeFeatures, codeTable };

package/lib/error-runtime.js

@@ -26,38 +26,7 @@ const FILES = [
   // The URI walk formats.js loads; left out with formats (see OPTIONAL).
   'uri-core',
 ];
-// The parts a build can leave out when none of its schemas needs them. The
-// decision is made on the schemas the runtime walks (as embedded, see
-// runtimeFeatures) and errs toward keeping a part: a key with that name
-// anywhere, even inside an enum value, keeps it. A part left out is replaced
-// by a stub that throws, which a schema without that keyword cannot reach.
-const OPTIONAL = {
-  formats: { keys: ['format'], stub: 'module.exports = {};' },
-  'safe-regex': { keys: ['pattern', 'patternProperties'], stub: "module.exports = { compileSafe() { throw new Error('ata error runtime: built without the pattern engine'); } };" },
-  'unique-items': { keys: ['uniqueItems', 'enum', 'const'], stub: "function no() { throw new Error('ata error runtime: built without deep equality'); }\nmodule.exports = { allDistinct: no, duplicatePair: no, _deq: no };" },
-};
-
-// Which optional parts these schemas need: { formats, 'safe-regex',
-// 'unique-items' } as booleans.
-function runtimeFeatures(schemas) {
-  const keys = new Set();
-  const seen = new Set();
-  const walk = (n) => {
-    if (n === null || typeof n !== 'object' || seen.has(n)) return;
-    seen.add(n);
-    if (Array.isArray(n)) { for (const x of n) walk(x); return; }
-    for (const k of Object.keys(n)) { keys.add(k); walk(n[k]); }
-  };
-  for (const s of schemas) walk(s);
-  const out = {};
-  for (const [part, { keys: ks }] of Object.entries(OPTIONAL)) out[part] = ks.some((k) => keys.has(k));
-  return out;
-}
-
-function codeTable() {
-  const { byKw, byFmt } = require('./error-code-of');
-  return { byKw, byFmt };
-}
+const { OPTIONAL, runtimeFeatures, codeTable } = require('./error-runtime-features');
 
 // Lines that hold nothing but a // comment are about half of these files.
 // They go, unless the line sits inside a template literal (tracked by