ata-validator 1.62.1 → 1.63.1

package/README.md

@@ -108,12 +108,7 @@ 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, 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
@@ -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) |

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/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/formats-source.js

@@ -96,14 +96,23 @@ function dateTimeSource (v, isStr) {
 // third parameter here would silently receive a context object and emit
 // `_st=[object Object]`. That declines the whole compile, which is how it was
 // found.
+// Membership in a set of ASCII characters as one shift: the 32-bit word for
+// c's quarter of the range is picked by comparison and `>>>` reads bit c&31.
+// Four numbers rather than a 128-entry table, so a module carries a few bytes,
+// and one test per character where a chain of comparisons ran up to twelve.
+// tests/test_format_char_masks.js checks every code point against the rule.
+const maskSource = (v, w) => `((${v}<64?${v}<32?${w[0]}:${w[1]}:${v}<96?${w[2]}:${v}<128?${w[3]}:0)>>>${v}&1)`;
+// A hostname label character: a letter, a digit or the hyphen.
+const HOST_CHAR_WORDS = [0, 67051520, 134217726, 134217726];
+const HOST_CHAR_SRC = (v) => maskSource(v, HOST_CHAR_WORDS);
+
 function hostnameRangeSource (v, st, en) {
-  return `const _st=${st},_en=${en},_n=_en-_st;if(_n===0||_n>253)return false;let _ll=0,_pv=46;` +
-    `for(let _i=_st;_i<_en;_i++){const _c=${v}.charCodeAt(_i);` +
-    `if(_c===46){if(_ll===0||_pv===45)return false;_ll=0;_pv=_c;continue}` +
-    `const _an=(_c>=48&&_c<=57)||(_c>=97&&_c<=122)||(_c>=65&&_c<=90);` +
-    `if(!_an&&_c!==45)return false;` +
-    `if(_c===45&&_pv===46)return false;` +
-    `if(++_ll>63)return false;_pv=_c}` +
+  // An empty name never counts a label, so the `_ll===0` test at the end
+  // refuses it without a length test of its own.
+  return `if(${en}-(${st})>253)return false;let _ll=0,_pv=46;` +
+    `for(let _i=${st};_i<${en};_i++){const _c=${v}.charCodeAt(_i);` +
+    `if(_c===46){if(_ll===0||_pv===45)return false;_ll=0}` +
+    `else if(!${HOST_CHAR_SRC('_c')}||_c===45&&_pv===46||++_ll>63)return false;_pv=_c}` +
     `if(_ll===0||_pv===45)return false`;
 }
 
@@ -257,19 +266,14 @@ function uriTemplateSource (v, isStr) {
 // trailing or doubled dot is not a mailbox. Domain is a hostname or a bracketed
 // address literal.
 // Local-part characters: alphanumerics, the RFC 5322 atext punctuation, and
-// the dot that separates atoms. Written as code ranges rather than a regular
-// expression because this lands inside every emitted module that validates an
-// email, and the expression cost more bytes there than the whole check.
-// The emitted form keeps the comparison chain: a standalone module pays for the
-// bytes of a 128-entry table in every file that validates an email, and the
-// runtime pays for the chain on every call. Different budgets, same answers,
-// which `tests/test_format_engine_parity.js` holds.
-// Stated as the complement: of the printable range, only twelve characters are
-// not atext or the dot, so excluding them is 54 source bytes shorter than listing
-// what is allowed, and a standalone module carries this expression. Checked
-// against the allowed-list form over every code point from 0 to 65536 in
-// tests/test_formats_single_pass.js.
-const EMAIL_LOCAL_SRC = (v) => `(${v}>32&&${v}<127&&${v}!==34&&${v}!==40&&${v}!==41&&${v}!==44&&${v}!==58&&${v}!==59&&${v}!==60&&${v}!==62&&${v}!==64&&${v}!==91&&${v}!==92&&${v}!==93)`;
+// the dot that separates atoms, as a mask (maskSource above): every printable
+// character except the twelve that are neither atext nor the dot. It replaced a
+// chain of twelve comparisons, which was more bytes in every module that checks
+// an email and up to twelve tests per character. Checked against the allowed-list
+// form over every code point from 0 to 65536 in tests/test_format_char_masks.js,
+// and against the runtime's check by `tests/test_format_engine_parity.js`.
+const EMAIL_LOCAL_WORDS = [0, 2751458554, 3355443198, 2147483647];
+const EMAIL_LOCAL_SRC = (v) => maskSource(v, EMAIL_LOCAL_WORDS);
 // Emitted rather than bound as a closure: a standalone module embeds format
 // functions by their source text, so anything reaching a free variable would
 // not survive the trip. The domain half reuses hostnameSource, which keeps
@@ -295,31 +299,26 @@ function emailSource (v, isStr) {
     // character, so in an unquoted address the first one is the separator and the
     // local part is checked on the way to it. A quoted local part may contain
     // '@' and keeps the backward scan, which is the rare shape.
-    // The bounds tests are merged into one condition per branch, and there is no
-    // separate length check: an empty local part fails `_at<=0` and an empty
-    // domain fails `_at===_n0-1`, so a short string is already refused. This
-    // lands in every emitted module that validates an email, and 25 bytes of it
-    // put the CLI smoke build over its --max-size once.
-    `const _n0=${v}.length;let _at;` +
+    // Both shapes share their variables and one bounds test after the local
+    // part: an empty local part fails `_at<1`, an empty domain `_at===_n0-1`,
+    // and `_pd` holds the character before the '@' (46 when it is a dot, which
+    // a quoted part sets aside). This lands in every emitted module that
+    // validates an email, so its bytes are counted (tests/test_email_bytes.js).
+    `const _n0=${v}.length;let _at=-1,_qi,_qc,_pd=46;` +
     `if(${v}.charCodeAt(0)===34){` +
-      `_at=${v}.lastIndexOf('@');` +
-      `if(_at<2||_at===_n0-1||_at>64||${v}.charCodeAt(_at-1)!==34)return false;` +
-      `for(let _qi=1;_qi<_at-1;_qi++){const _qc=${v}.charCodeAt(_qi);` +
-      `if(_qc===92){const _qp=${v}.charCodeAt(_qi+1);if(_qp<32||_qp>126||_qi+1>=_at-1)return false;_qi++;continue}` +
-      `if(_qc<32||_qc>126||_qc===34)return false}` +
-    `}else{` +
-      `if(${v}.charCodeAt(0)===46)return false;` +
-      `_at=-1;let _pd=false;` +
-      `for(let _i=0;_i<_n0;_i++){const _lc=${v}.charCodeAt(_i);if(_lc===64){_at=_i;break}if(!${EMAIL_LOCAL_SRC('_lc')})return false;if(_lc===46){if(_pd)return false;_pd=true}else _pd=false}` +
-      `if(_at<=0||_at===_n0-1||_at>64||${v}.charCodeAt(_at-1)===46)return false` +
-    `}` +
+      `_at=${v}.lastIndexOf('@');if(_at<2||${v}.charCodeAt(_at-1)!==34)return false;` +
+      `for(_qi=1;_qi<_at-1;_qi++){_qc=${v}.charCodeAt(_qi);` +
+      `if(_qc===92){_qc=${v}.charCodeAt(++_qi);if(_qc<32||_qc>126||_qi>=_at-1)return false}` +
+      `else if(_qc<32||_qc>126||_qc===34)return false}_pd=0` +
+    `}else for(_qi=0;_qi<_n0;_qi++){_qc=${v}.charCodeAt(_qi);if(_qc===64){_at=_qi;break}` +
+      `if(_qc===46?_pd===46:!${EMAIL_LOCAL_SRC('_qc')})return false;_pd=_qc}` +
+    `if(_at<1||_at>64||_at===_n0-1||_pd===46)return false;` +
     // An address literal is rare enough to pay for its own slice inside the
     // branch that needs it; the hostname path, which is every real address,
     // reads the domain in place.
     `if(${v}.charCodeAt(_at+1)===91){` +
-      `const _dm=${v}.slice(_at+1);` +
-      `if(_dm.charCodeAt(_dm.length-1)!==93||_dm.length<=2)return false;` +
-      `const _in=_dm.slice(1,-1);` +
+      `if(${v}.charCodeAt(_n0-1)!==93||_n0-_at<4)return false;` +
+      `const _in=${v}.slice(_at+2,-1);` +
       // The literal is rare, and checked by expression rather than by the
       // IPv6 and IPv4 parsers, which made it 72% of this check's source:
       // the same answers (tests/test_ipv6_expression.js), a fraction of the bytes.