ata-validator 1.61.0 → 1.61.2

package/README.md

@@ -54,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
@@ -649,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:
 
@@ -693,7 +717,8 @@ 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),
+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
@@ -723,10 +748,12 @@ So, in order of preference:
    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.
+   It does so by itself under `bun build --compile --aot` and `bun run --aot`,
+   where Bun resolves the package's `"aot"` export condition to an entry that
+   says so; also 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:
+   78 ns against 487 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,

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/index.aot.js

@@ -0,0 +1,8 @@
+'use strict';
+
+// ata-validator under Bun's ahead-of-time compiler, where Bun resolves the
+// `"aot"` export condition: the same package, with validators on the
+// interpreted engine by default, which is compiled with the program, rather
+// than on code made at run time, which is not (lib/aot-mark.js).
+require('./lib/aot-mark.js');
+module.exports = require('./index.js');

package/index.aot.mjs

@@ -0,0 +1,5 @@
+// ata-validator under Bun's ahead-of-time compiler; see index.aot.js. The mark
+// is imported first, so it runs before the package and before any caller.
+import './lib/aot-mark.js';
+export * from './index.mjs';
+export { default } from './index.mjs';

package/lib/aot-build.js

@@ -692,7 +692,15 @@ function compiledModuleFor(schema, opts) {
       // The one-pass error function where the caller asks (a plugin writing
       // for a Bun executable): 3.6x cheaper on a rejection, 20% larger gzipped.
       onePass: opts && opts.onePass === true ? true : undefined,
-      source: opts && opts.onePass === true ? false : undefined,
+      source: opts && (opts.onePass === true || opts.plainErrors === true) ? false : undefined,
+      // Errors in the runtime's `richErrors: false` shape, for
+      // ata-validator/compiled-plain, which hands them out as they are.
+      plainErrors: !!(opts && opts.plainErrors === true),
+      // `verdictOnly`: the module for a reader that only ever calls isValid
+      // (a bundler plugin's verdict wrappers). Its validate() hands out the
+      // abort-early stub, so the error collector, never called there, is not
+      // written: 954 to 539 bytes gzipped on a one-field object.
+      abortEarly: !!(opts && opts.verdictOnly === true),
       // Errors in the runtime's order, for a reader that does not sort them
       // itself (a form resolver); fromCompiled sorts, so a plugin putting
       // that wrapper around the module leaves it off.

package/lib/aot-impl.js

@@ -430,7 +430,12 @@ function toStandaloneModule(validator, opts) {
   // documents against large schemas asks for it.
   let onePass = null;
   let ordered = false;
-  const wantOnePass = opts && opts.onePass === true ? 'always' : (opts && (opts.onePass === false || opts.noOnePass)) ? 'never' : 'auto';
+  // `plainErrors`: the errors in the runtime's `richErrors: false` shape, as
+  // the one-pass program writes them before codes and links are stamped on.
+  // A wrapper that hands them out as they are (ata-validator/compiled-plain)
+  // then carries no error pipeline of its own.
+  const plainErrors = !!(opts && opts.plainErrors === true);
+  const wantOnePass = plainErrors || (opts && opts.onePass === true) ? 'always' : (opts && (opts.onePass === false || opts.noOnePass)) ? 'never' : 'auto';
   // Asked for explicitly, the one-pass function wins over schema-source
   // frames, which `ata compile` writes by default outside production; the
   // caller is told, since it asked for both.
@@ -445,7 +450,10 @@ function toStandaloneModule(validator, opts) {
     }
     if (wantOnePass === 'always' || errLen === 0) onePass = onePassCore(validator, opts);
   }
-  if (onePass !== null) {
+  if (onePass !== null && plainErrors) {
+    errCore = `const _ER = function(e) { this.valid = false; this.errors = e; };\n` +
+      `const _vC = (function() {\n${onePass.core}\n})();\n`;
+  } else if (onePass !== null) {
     errCore = `function _ataStamp(e) { for (let i = 0; i < e.length; i++) { const x = e[i]; if (x.code === undefined) { const c = x.keyword === 'required' && typeof x.schemaPath === 'string' && x.schemaPath.endsWith('/dependentRequired') ? 'ATA7005' : _ataCode(x.keyword, x.params && x.params.format); if (c !== null) { x.code = c; x.docUrl = 'https://ata-validator.com/e/' + c; } } else if (x.docUrl === undefined) x.docUrl = 'https://ata-validator.com/e/' + x.code; if (x.branchErrors !== undefined) _ataStamp(x.branchErrors); } }\n` +
       `const _ER = function(e) { _ataStamp(e); this.valid = false; this.errors = e; };\n` +
       `${codeTableSource(onePass.keywords, onePass.formats)}const _vC = (function() {\n${onePass.core}\n})();\n`;

package/lib/aot-mark.js

@@ -0,0 +1,7 @@
+'use strict';
+
+// Loaded first by index.aot.js and index.aot.mjs, the entries Bun resolves
+// through the `"aot"` export condition when it compiles a program ahead of
+// time: every Validator made after this takes the interpreted engine by
+// default (see aotHost in lib/validator-core.js).
+require('./validator-core')._markAotHost();

package/lib/compiled-bare-rich.js

@@ -0,0 +1,54 @@
+'use strict';
+
+// bareRich: the compiled-bare wrapper for a validator that reads ata's own
+// errors (`richErrors` left on) and is only ever called, never handed to other
+// code: validate() and isValidObject() as lib/compiled-object.js answers them,
+// down to the error objects, without the Standard Schema member and the
+// extension hook nothing can reach there, and without the option checks the
+// bundler plugin already made. A separate entry from lib/compiled-bare.js so
+// a bundle with only plain or verdict validators carries no error pipeline.
+// tests/test_compiled_bare.js holds it to the runtime.
+
+const { LazyRejection, RichRejection, _enrichLazy } = require('./rejections');
+
+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' })]),
+});
+
+// The fields of a Validator the rejection classes read.
+class CompiledState {
+  constructor(schema, fill) {
+    this._schemaObj = schema;
+    this._schemaPositions = undefined;
+    this._source = undefined;
+    this._mutatesInput = fill !== null;
+    this._preprocess = fill;
+  }
+}
+
+function bareRich(mod, schema, useDefaults) {
+  const fill = useDefaults !== false && typeof mod.applyDefaults === 'function' ? mod.applyDefaults : null;
+  const verdict = mod.isValid;
+  const isValid = fill ? (d) => { fill(d); return verdict(d); } : verdict;
+  const self = new CompiledState(schema, fill);
+  const errFn = mod.validate;
+  const rich = (data) => {
+    const r = errFn(data);
+    return new RichRejection(r && r.valid === false ? r : VERDICT_DISAGREES, data, null, self, schema, _enrichLazy);
+  };
+  const buildErrors = (data) => rich(data).errors;
+  const buildRawErrors = (data) => rich(data)._ataRaw();
+  return {
+    validate(data) {
+      if (isValid(data)) return { valid: true, data, errors: EMPTY_ERRORS };
+      // The runtime returns the rich rejection directly when it rewrites input.
+      if (fill) return rich(data);
+      return new LazyRejection(buildErrors, data, buildRawErrors);
+    },
+    isValidObject: isValid,
+  };
+}
+
+module.exports = { bareRich };

package/lib/compiled-bare.js

@@ -0,0 +1,44 @@
+'use strict';
+
+// The smallest wrappers around a compiled module, for a validator the bundler
+// plugin sees used only through direct calls of its methods: never handed to
+// other code, so nothing reads `~standard` or registers a check on it with
+// `_extendChecks`, and its options were read at build time. What is left is
+// what those calls answer: defaults filled with the module's own pass, the
+// verdict, and for `richErrors: false` the module's plain errors as they are.
+// The same answers as fromCompiledVerdict and fromCompiledPlain
+// (tests/test_compiled_bare.js), without their API surface: 0.3 KB gzipped
+// against 1.6 and 2.6.
+
+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;
+}
+
+// isValidObject() only.
+function bareVerdict(mod, useDefaults) {
+  return { isValidObject: verdictOf(mod, useDefaults) };
+}
+
+// validate() and isValidObject() for `richErrors: false`, around a module
+// written with `plainErrors: true`.
+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,
+  };
+}
+
+module.exports = { bareVerdict, barePlain };

package/lib/compiled-common.js

@@ -5,7 +5,22 @@
 // points; lib/compiled-verdict.js answers only the two that return a boolean,
 // so a bundle that never reads errors does not carry the error pipeline.
 
-const { buildDefaultsApplier } = require('./defaults');
+// A module from 1.58.0 on fills its own defaults (`applyDefaults`, exported
+// when the schema has one, the same pass as the runtime's: tests hold the two
+// equal), so the wrapper takes that and the defaults engine stays out of a
+// bundle that wraps current modules. An older module, or one without the
+// version stamp, takes the runtime's pass as before (lib/compiled-defaults.js).
+const MODULE_DEFAULTS_SINCE = [1, 58, 0];
+function carriesDefaults (mod) {
+  const v = typeof mod.ataVersion === 'string' ? mod.ataVersion.split(/[.-]/).slice(0, 3).map(Number) : null;
+  if (!v || v.some((n) => !Number.isInteger(n))) return false;
+  for (let i = 0; i < 3; i++) if (v[i] !== MODULE_DEFAULTS_SINCE[i]) return v[i] > MODULE_DEFAULTS_SINCE[i];
+  return true;
+}
+function defaultsFor (mod, schema) {
+  if (carriesDefaults(mod)) return typeof mod.applyDefaults === 'function' ? mod.applyDefaults : null;
+  return require('./compiled-defaults')(schema);
+}
 
 // The Validator options the wrapper answers the same way as the runtime.
 // Anything else changes what the runtime does in a way the wrapper does not
@@ -23,7 +38,7 @@ function prepare(mod, schema, options, name) {
       throw new TypeError(`${name} does not support the ${key} option; a Validator with it has to stay on the runtime`);
     }
   }
-  const fill = options && options.useDefaults === false ? null : buildDefaultsApplier(schema);
+  const fill = options && options.useDefaults === false ? null : defaultsFor(mod, schema);
   const isValid = fill ? (d) => { fill(d); return mod.isValid(d); } : mod.isValid;
   return { fill, isValid };
 }

package/lib/compiled-defaults.browser.js

@@ -0,0 +1,9 @@
+'use strict';
+
+// Browser build of lib/compiled-defaults.js. A module from ata-validator 1.58.0
+// on carries `applyDefaults` when its schema has a default, and the wrapper
+// uses it; only an older module needs the runtime's pass, which this build
+// leaves out. Such a module is refused rather than run without its defaults.
+module.exports = function () {
+  throw new TypeError('This compiled module was built before ata-validator 1.58.0 and its schema has defaults; rebuild it to use it in a browser bundle.');
+};

package/lib/compiled-defaults.js

@@ -0,0 +1,8 @@
+'use strict';
+
+// The runtime's defaults pass, for a module built before modules carried their
+// own (ata-validator 1.58.0, when the pass reached behind `$ref`, `allOf` and
+// array elements). The browser build maps this file to
+// lib/compiled-defaults.browser.js, so a page that wraps a current module does
+// not carry the defaults engine twice.
+module.exports = require('./defaults').buildDefaultsApplier;

package/lib/compiled-object.js

@@ -0,0 +1,123 @@
+'use strict';
+
+// lib/compiled.js without the JSON entry points: validate(), isValidObject()
+// and Standard Schema, answered as a Validator with default options answers
+// them, down to the error objects. A bundler plugin puts this in place of
+// `new Validator(schema)` when the code reads errors but never calls
+// validateJSON() or isValidJSON(), so the position map those use to frame an
+// error in the JSON text (lib/data-position-cache.js and the walk behind it)
+// stays out of the bundle: 14.1 to 12.3 KB gzipped for the wrapper.
+// tests/test_compiled_parity.js holds it to the full wrapper.
+//
+// Only for a schema compiledEligible() accepts, and with the schema
+// compiledSchemaFor() returns: the one the runtime reads, after normalization.
+// Custom error messages stay on the runtime, and so does every option except
+// the ones COMPILED_OPTIONS lists. Defaults are applied as a default Validator
+// applies them, before any check, with the same code; `useDefaults: false`
+// leaves the input as it is, as the runtime then does.
+
+const { LazyRejection, RichRejection, _enrichLazy } = require('./rejections');
+const { prepare, installExtension, EXT_FALLBACK } = require('./compiled-common');
+const { installStandard } = require('./standard-schema');
+
+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' })]),
+});
+
+// The fields of a Validator the rejection classes read.
+class CompiledState {
+  constructor(schema) {
+    this._schemaObj = schema;
+    this._schemaPositions = undefined;
+    this._source = undefined;
+    this._mutatesInput = false;
+    this._preprocess = null;
+  }
+}
+
+function fromCompiledObject(mod, schema, options) {
+  const { fill, isValid } = prepare(mod, schema, options, 'fromCompiledObject');
+  const self = new CompiledState(schema);
+  if (fill) {
+    self._mutatesInput = true;
+    self._preprocess = fill;
+  }
+  const errFn = mod.validate;
+  // The generated function's own result, rejected: if it says valid where the
+  // verdict said no, the disagreement is reported rather than turned into an
+  // acceptance, as the core does.
+  const raw = (data) => {
+    const r = errFn(data);
+    return r && r.valid === false ? r : VERDICT_DISAGREES;
+  };
+  const rich = (data) => new RichRejection(raw(data), data, null, self, schema, _enrichLazy);
+  const buildErrors = (data) => rich(data).errors;
+  const buildRawErrors = (data) => rich(data)._ataRaw();
+  const api = {
+    validate(data) {
+      if (isValid(data)) return { valid: true, data, errors: EMPTY_ERRORS };
+      // The runtime returns the rich rejection directly when it rewrites input.
+      if (fill) return rich(data);
+      return new LazyRejection(buildErrors, data, buildRawErrors);
+    },
+    isValidObject(data) {
+      return isValid(data);
+    },
+  };
+  installExtension(api, schema, (base, ext) => {
+    return {
+      // The verdict is the schema's and the check's. A failure lists the
+      // schema's errors, then the check's, read when somebody asks.
+      validate(data) {
+        const r = base.validate(data);
+        if (r.valid && ext.check(data)) return r;
+        return new ExtendedRejection(r, data, ext.errors);
+      },
+      isValidObject: (d) => base.isValidObject(d) && ext.check(d),
+    };
+  });
+  // Standard Schema V1, as the runtime Validator hands it out, so a validator
+  // the build compiled away still works where the runtime one did (a form
+  // library, a router, an RPC layer). The schema it publishes is the one the
+  // module was built from, as the runtime reads it.
+  installStandard(api, () => schema, (self, value) => self.validate(value));
+  return api;
+}
+
+// validate() under a check, as the runtime reports it (ExtendedRejection in
+// validator-core.js): the inner result's errors, then the check's.
+class ExtendedRejection {
+  constructor(inner, data, collect) {
+    this.valid = false;
+    this._inner = inner;
+    this._data = data;
+    this._collect = collect;
+    this._errors = null;
+  }
+  toJSON() {
+    return { valid: false, errors: this.errors };
+  }
+  _ataRaw() {
+    const inner = this._inner;
+    const more = this._collect(this._data) || [];
+    const raw = inner.valid ? more : (typeof inner._ataRaw === 'function' ? inner._ataRaw() : inner.errors).concat(more);
+    return raw.length ? raw : [EXT_FALLBACK];
+  }
+}
+Object.defineProperty(ExtendedRejection.prototype, 'errors', {
+  enumerable: true,
+  configurable: true,
+  get() {
+    if (this._errors === null) {
+      const inner = this._inner;
+      const more = this._collect(this._data) || [];
+      const all = inner.valid ? more : inner.errors.concat(more);
+      this._errors = all.length ? all : [EXT_FALLBACK];
+    }
+    return this._errors;
+  },
+});
+
+module.exports = { fromCompiledObject };

package/lib/compiled-plain.js

@@ -0,0 +1,57 @@
+'use strict';
+
+// The compiled-module wrapper for `new Validator(schema, { richErrors: false })`:
+// validate(), isValidObject() and Standard Schema, answered as such a
+// Validator answers them, errors in its plain shape (keyword, instancePath,
+// schemaPath, params, message). The module is written with `plainErrors: true`
+// (compiledModuleFor in ata-validator/build), so its errors are already that
+// shape and in that order, and this wrapper hands them out as they are: no
+// rejection classes, no enrichment, no suggestions. 2.6 KB gzipped against
+// 10.9 for the rich wrapper without JSON entry points.
+// tests/test_compiled_plain.js holds it to the runtime over the suite.
+
+const { prepare, installExtension, EXT_FALLBACK } = require('./compiled-common');
+const { installStandard } = require('./standard-schema');
+
+const EMPTY_ERRORS = Object.freeze([]);
+// The module's own verdict and its error function disagree (the data changed
+// between them): reported, never turned into an acceptance, as the core does.
+const VERDICT_DISAGREES = Object.freeze({
+  valid: false,
+  errors: Object.freeze([Object.freeze({ keyword: 'validation', instancePath: '', schemaPath: '#', params: Object.freeze({}), message: 'schema validation failed' })]),
+});
+
+function fromCompiledPlain(mod, schema, options) {
+  const opts = options ? { ...options } : undefined;
+  // `richErrors: false` is what this wrapper is; anything else it is not.
+  if (opts) {
+    if (opts.richErrors !== false) throw new TypeError('fromCompiledPlain answers `richErrors: false`; a Validator with rich errors takes fromCompiled');
+    delete opts.richErrors;
+  }
+  const { isValid } = prepare(mod, schema, opts, 'fromCompiledPlain');
+  const errFn = mod.validate;
+  const api = {
+    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(data) {
+      return isValid(data);
+    },
+  };
+  installExtension(api, schema, (base, ext) => ({
+    validate(data) {
+      const r = base.validate(data);
+      if (r.valid && ext.check(data)) return r;
+      const more = ext.errors(data) || [];
+      const all = r.valid ? more : r.errors.concat(more);
+      return { valid: false, errors: all.length ? all : [EXT_FALLBACK] };
+    },
+    isValidObject: (d) => base.isValidObject(d) && ext.check(d),
+  }));
+  installStandard(api, () => schema, (self, value) => self.validate(value));
+  return api;
+}
+
+module.exports = { fromCompiledPlain };

package/lib/compiled.js

@@ -15,7 +15,8 @@
 // applies them, before any check, with the same code; `useDefaults: false`
 // leaves the input as it is, as the runtime then does.
 
-const { LazyRejection, RichRejection, LazyJsonRejection, _enrichLazy } = require('./rejections');
+const { LazyRejection, RichRejection, _enrichLazy } = require('./rejections');
+const { LazyJsonRejection } = require('./json-rejections');
 const { COMPILED_OPTIONS, prepare, parse, installExtension, extendJSON, EXT_FALLBACK } = require('./compiled-common');
 const { installStandard } = require('./standard-schema');
 

package/lib/email-literal.js

@@ -0,0 +1,29 @@
+'use strict';
+
+// Every RFC 4291 text form of an IPv6 address as one expression: eight groups,
+// or a "::" standing for one or more groups of zeros with up to seven groups
+// around it, the last 32 bits optionally a dotted quad. ipv6() in lib/formats.js
+// is the fast check; this is the short one, which an email address literal in a
+// compiled module carries instead of the parser (2.2 KB of every module that
+// checks an email). tests/test_ipv6_expression.js holds the two to the same
+// answer.
+const IPV6_RE = (() => {
+  // A dotted quad, as lib/formats.js reads one.
+  const v4 = require('./formats').IPV4.source.slice(1, -1);
+  const h = '[0-9A-Fa-f]{1,4}';
+  const alts = [`(?:${h}:){7}${h}`, `(?:${h}:){6}${v4}`];
+  for (let k = 0; k <= 7; k++) {
+    const left = k === 0 ? '' : `(?:${h}:){${k - 1}}${h}`;
+    alts.push(k === 7 ? `${left}::` : `${left}::(?:(?:${h}:){0,${6 - k}}${h})?`);
+    if (k <= 5) alts.push(`${left}::(?:(?:${h}:){0,${5 - k}})?${v4}`);
+  }
+  return new RegExp(`^(?:${alts.join('|')})$`);
+})();
+
+// `_in` is the text between the brackets; the check returns false from the
+// 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}` +
+  `else if(_in.length>15||!${require('./formats').IPV4}.test(_in))return false`);
+module.exports.IPV6_RE = IPV6_RE;