ata-validator 1.56.0 → 1.58.0

package/README.md

@@ -53,8 +53,9 @@ interpreted engine, which gives the same answers, and a validator called a thous
 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
 form, checked as the user types, never loads it. On a react-jsonschema-form page this takes the validator's
-share of the first load from 134.7 KB to about 57 KB gzipped; the generator chunk is about 78 KB
-more when it does load. Where `unsafe-eval` is blocked, on a page with a strict
+share of the first load from 134.7 KB to about 55 KB gzipped; the generator chunk is about 78 KB
+more when it does load, and the plan compiler, which speeds up a schema the interpreted engine checks
+often, comes in a 6 KB chunk once the page is idle. Where `unsafe-eval` is blocked, on a page with a strict
 Content-Security-Policy or in a Manifest V3 extension, it is never fetched and every schema
 stays on the interpreted engine. To have generated code from the first call, import
 `ata-validator/codegen` once; it also makes `parse()` available in the browser, which otherwise
@@ -584,8 +585,11 @@ CLI options:
 | `-f, --format <fmt>` | `esm` | `esm` or `cjs` |
 | `--name <TypeName>` | from filename | Root type name in the `.d.ts` |
 | `--abort-early` | off | Generate the stub-error variant, about a third of the source |
+| `--order` | off | Hand errors out in the runtime's order (schema declaration order), not the order the collector found them in |
 | `--no-types` | off | Skip the `.d.mts` / `.d.cts` output |
 
+A module answers `validate()` as the runtime does, with two differences a caller reading the module directly should know. The runtime fills in `default` values before it checks (`useDefaults` is on unless turned off), and the module does not: where the schema declares a default the module exports `applyDefaults(data)`, the runtime's own pass, to call first. And the module returns its errors in the order its collector found them, which can put a field's `format` error before its `pattern` error, or behind a `$ref` a definition's `required` before its `properties`; `--order` sorts them as the runtime does. It is off by default because it costs bytes: 225 more gzipped for an eight-field form, about 1 KB for a small schema with references, whose key skeleton the module then carries, and 12.6% over 267 SchemaStore schemas. With both, a module matched the runtime's verdict, filled data and error list, in order, on every case of the official suites it compiles (1,500 groups, 5,324 cases across six dialects) and on 1,952 of SchemaStore's sample documents. `fromCompiled()` and modules that share the error runtime sort already and need neither.
+
 For a project with many schemas, `ata build <glob>` compiles them all in one command:
 
 ```bash

package/bin/ata.js

@@ -30,6 +30,9 @@ Compile options:
   --abort-early           Use stub errors (smallest bundle)
   --one-pass              Report errors with the runtime's one-pass function: faster on
                           rejected documents, a module 1.3 to 1.7x the size
+  --order                 Hand errors out in the runtime's order (schema declaration
+                          order) rather than the order they were found in; adds a sort,
+                          and for a schema with $ref its key skeleton
   --source                Embed schema source map (default in development)
   --no-source             Omit source map (default in production, NODE_ENV=production)
 
@@ -45,6 +48,10 @@ Build options:
   --abort-early           Use stub errors (smallest bundle)
   --one-pass              Report errors with the runtime's one-pass function: faster on
                           rejected documents, a module 1.3 to 1.7x the size
+  --order                 Hand errors out in the runtime's order (schema declaration
+                          order) rather than the order they were found in; adds a sort,
+                          and for a schema with $ref its key skeleton (modules that share
+                          the error runtime are in that order already)
   --errors <mode>         Where error detail comes from: auto | inline | shared. auto
                           (default) has modules share one error runtime file when that
                           makes the output smaller; production builds only (--no-source)
@@ -103,6 +110,7 @@ function parseArgs(argv) {
     if (a === '--no-types') { out.opts.types = false; continue; }
     if (a === '--abort-early') { out.opts.abortEarly = true; continue; }
     if (a === '--one-pass') { out.opts.onePass = true; continue; }
+    if (a === '--order') { out.opts.order = true; continue; }
     if (a === '--errors') { out.opts.errors = argv[++i]; continue; }
     if (a === '--mode') { out.opts.mode = argv[++i]; continue; }
     if (a === '--base-uri') { out.opts.baseUri = argv[++i]; continue; }
@@ -250,7 +258,7 @@ function cmdCompile(args) {
   }
   const schemaFile = path.relative(process.cwd(), input) || input;
   const compileWarnings = [];
-  const src = aot.toStandaloneModule(v, { format, abortEarly, source, sourceMap, schemaFile, onePass: args.opts.onePass === true ? true : undefined, onWarning: (w) => compileWarnings.push(w) });
+  const src = aot.toStandaloneModule(v, { format, abortEarly, source, sourceMap, schemaFile, onePass: args.opts.onePass === true ? true : undefined, order: args.opts.order === true ? true : undefined, onWarning: (w) => compileWarnings.push(w) });
   if (compileWarnings.length > 0) {
     if (args.opts.strict) {
       for (const w of compileWarnings) reportCompileError(input, w);
@@ -277,7 +285,7 @@ function cmdCompile(args) {
     const typeName = args.opts.name || path.basename(input, path.extname(input))
       .replace(/[^A-Za-z0-9_]/g, '_')
       .replace(/^([a-z])/, (m) => m.toUpperCase()) || 'Data';
-    const dts = toTypeScript(schema, { name: typeName });
+    const dts = toTypeScript(schema, { name: typeName, applyDefaults: /\nfunction applyDefaults\(/.test(src) });
     const ext = path.extname(output);
     const dtsExt = ext === '.mjs' ? '.d.mts'
       : ext === '.cjs' ? '.d.cts'
@@ -308,6 +316,7 @@ function cmdBuild(args) {
     suffix: args.opts.suffix,
     abortEarly: !!args.opts.abortEarly,
     onePass: args.opts.onePass === true ? true : undefined,
+    order: args.opts.order === true ? true : undefined,
     errors: args.opts.errors,
     mode: args.opts.mode,
     baseUri: args.opts.baseUri,

package/build.d.ts

@@ -116,6 +116,12 @@ export interface ToStandaloneModuleOptions {
    * older collector either way.
    */
   onePass?: boolean;
+  /**
+   * Hand errors out in the runtime's order, schema declaration order, rather
+   * than the order the collector found them in (`ata compile --order`). Adds a
+   * sort, and for a schema with `$ref` its key skeleton; off by default.
+   */
+  order?: boolean;
   source?: boolean;
   sourceMap?: unknown;
   schemaFile?: string;
@@ -190,7 +196,7 @@ export function compiledSchemaFor(schema: unknown): object;
  * {@link compiledEligible} declines, one the emitter cannot compile, and one
  * whose detailed errors the generator cannot produce.
  */
-export function compiledModuleFor(schema: unknown, opts?: { format?: 'esm' | 'cjs'; errorRuntime?: string }): string | null;
+export function compiledModuleFor(schema: unknown, opts?: { format?: 'esm' | 'cjs'; errorRuntime?: string; order?: boolean }): string | null;
 
 /**
  * The Validator options `fromCompiled()` reproduces, so a plugin can tell

package/lib/aot-build.js

@@ -288,6 +288,7 @@ async function build(opts) {
       format,
       abortEarly: !!opts.abortEarly,
       onePass: opts.onePass === true ? true : undefined,
+      order: opts.order === true ? true : undefined,
       source,
       sourceMap,
       schemaFile,
@@ -465,7 +466,7 @@ async function build(opts) {
         const typeName = stem
           .replace(/[^A-Za-z0-9_]/g, '_')
           .replace(/^([a-z])/, (m) => m.toUpperCase()) || 'Data';
-        const dts = toTypeScript(e.schema, { name: typeName });
+        const dts = toTypeScript(e.schema, { name: typeName, applyDefaults: /\nfunction applyDefaults\(/.test(src) });
         const ext = path.extname(output);
         const dtsExt = ext === '.mjs' ? '.d.mts'
           : ext === '.cjs' ? '.d.cts'
@@ -646,6 +647,10 @@ function compiledModuleFor(schema, opts) {
   try {
     src = aot.toStandaloneModule(validatorFor(schema), {
       format: (opts && opts.format) || 'esm',
+      // 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.
+      order: !!(opts && opts.order === true),
       onWarning: (msg, info) => { if (info && info.kind === 'error-detail') degraded = true; },
     });
   } catch {

package/lib/aot-impl.js

@@ -346,6 +346,31 @@ function codeTableSource(keywords, formats) {
 
 const ABORT_SHAPE = Object.freeze({ valid: false, errors: Object.freeze([Object.freeze({ code: 'ATA9000', message: 'validation failed', keyword: '__abort_early__', path: '' })]) });
 
+// The runtime's defaults pass (preprocessSource in lib/codegen-engine.js),
+// over the schema the runtime builds it from, as a function the module
+// exports as applyDefaults. Not called by validate(): the runtime fills
+// defaults before checking because useDefaults is on unless turned off, and
+// a module cannot see that option, so the caller who wants the runtime's
+// answer calls applyDefaults(data) first. Empty where the schema has no
+// default, or where the pass declines it (a schema object containing itself).
+function defaultsDecl(validator) {
+  const { resolveSchemaForPreprocess } = require('./validator-core')._internals;
+  const schema = resolveSchemaForPreprocess(validator._schemaObj, validator._schemaMap);
+  let src = null;
+  try { src = require('./codegen-engine').preprocessSource(schema, { useDefaults: true }); } catch {}
+  if (src !== null) return `function applyDefaults(d) {\n${src}\n}\n`;
+  // The generated pass declines a recursive reference and keys matched by
+  // patterns; the runtime fills those with the closure pass, so the module
+  // carries it, as its own text (lib/defaults.js), with its schema less the
+  // descriptive keywords, `default` kept. Built on the first call.
+  const defaults = require('./defaults');
+  if (defaults.buildDefaultsApplier(schema) === null) return '';
+  const embedded = require('./schema-strip').stripAnnotationsKeepingDefaults(schema);
+  const text = JSON.stringify(JSON.stringify(embedded)).replace(/</g, '\\u003c');
+  return `const _ataDefaults = (function () {\nconst MAX_DEPTH = ${defaults.MAX_DEPTH};\n${require(AOT_ORDER_MODULE).take('defaults.js', defaults.EMBED)}\nreturn buildDefaultsApplier;\n})();\n` +
+    `let _ataFill;\nfunction applyDefaults(d) { (_ataFill || (_ataFill = _ataDefaults(JSON.parse(${text}))))(d); }\n`;
+}
+
 function toStandaloneModule(validator, opts) {
   assertEmittable(validator, 'toStandaloneModule');
   validator._ensureCompiled();
@@ -374,6 +399,7 @@ function toStandaloneModule(validator, opts) {
   // notices a rejected document's cost. A build that validates large
   // 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';
   // Asked for explicitly, the one-pass function wins over schema-source
   // frames, which `ata compile` writes by default outside production; the
@@ -394,14 +420,20 @@ function toStandaloneModule(validator, opts) {
       `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`;
   } else if (!abortEarly) {
-    // A module returns the collector's errors as they are and never sorts
-    // them, so the ordinal the runtime sorts by (`_o`) has no reader there;
-    // it leaked into every error object a module reported.
+    // With `order: true` the module hands its errors out in the runtime's
+    // order (lib/aot-order.js); without it, in the collector's, as it always
+    // did, since the sort costs every module bytes (12.6% over SchemaStore's,
+    // gzipped, most of it the key skeleton of schemas with references) and a
+    // reader that sorts (fromCompiled) does not need it. Where the module
+    // sorts by each error site's ordinal, the collector writes it (`_o`).
+    const schemaForErrors = typeof validator._schemaObj === 'object' ? validator._schemaObj : {};
+    ordered = !!(opts && opts.order === true);
+    const noOrdinal = !ordered || !require(AOT_ORDER_MODULE).wantsOrdinals(schemaForErrors);
     jsErrFn = compileToJSCodegenWithErrors(
-      typeof validator._schemaObj === 'object' ? validator._schemaObj : {},
+      schemaForErrors,
       null,
       validator._userFormats,
-      (source && sourceMap && schemaFile) ? { sourceMap, schemaFile, frames: sourceFrames, noOrdinal: true } : { noOrdinal: true },
+      (source && sourceMap && schemaFile) ? { sourceMap, schemaFile, frames: sourceFrames, noOrdinal } : { noOrdinal },
     );
     const errSrc = jsErrFn && jsErrFn._errSource ? jsErrFn._errSource : '';
     if (errSrc && jsErrFn._errFactory) {
@@ -537,12 +569,22 @@ function toStandaloneModule(validator, opts) {
     // module that only accepts costs no more to load than its verdict.
     compactCore = `let _ataErrs = null;\nfunction _ataErrors(d) { if (_ataErrs === null) _ataErrs = _ataCreateErrors(JSON.parse(${text})${rtOpts ? ', { ' + rtOpts + ' }' : ''}); return _ataErrs(d); }\n`;
   }
+  const orderDecl = errCore && ordered && errorRuntime === null && onePass === null
+    ? require(AOT_ORDER_MODULE).orderDecl(validator._schemaObj)
+    : '';
+  // Asked for and not given: stub errors, the one-pass function, or no error
+  // code generated. The caller is told rather than handed the collector's
+  // order as if it were the runtime's. Errors from the shared runtime come in
+  // the runtime's order already (errorsOf in lib/error-runtime-entry.js).
+  if (opts && opts.order === true && orderDecl === '' && errorRuntime === null && typeof opts.onWarning === 'function') {
+    opts.onWarning('errors are not in the runtime order: order applies to modules with generated error code, not to stub errors or the one-pass function', { kind: 'order' });
+  }
   const validBody = errorRuntime !== null
     ? 'if (_fn(data)) return VALID; const e = _ataErrors(data); return e === null ? ABORT : { valid: false, errors: e }'
     : onePass !== null
     ? 'return _vC(data)'
     : errCore
-      ? 'return _fn(data) ? VALID : { valid: false, errors: errFn(data, true).errors }'
+      ? (orderDecl !== '' ? 'return _fn(data) ? VALID : { valid: false, errors: _ataOrder(errFn(data, true).errors) }' : 'return _fn(data) ? VALID : { valid: false, errors: errFn(data, true).errors }')
       : 'return _fn(data) ? VALID : ABORT';
 
   // parse(): validate, then hand back a copy holding only the properties the
@@ -625,6 +667,8 @@ function validateJSON(text) {
   const hashDecl = `const schemaHash = ${JSON.stringify(hashSrc)};\nconst ataVersion = ${JSON.stringify(ATA_VERSION)};\n`;
 
   let names = fmt.exportsSetFormats ? baseNames + ', setFormats' : baseNames;
+  const fillDecl = defaultsDecl(validator);
+  if (fillDecl) names += ', applyDefaults';
   names += ', schemaHash, ataVersion';
   if (positionsCore) names += ', validateJSON';
   const parseAlias = cloneExpr ? ', _ataParse as parse' : '';
@@ -657,9 +701,9 @@ const ABORT = Object.freeze({
 ${closureDecls}${sharedBlock}${preambleDecls}${formatDecls}const _fn = function(d) {
   ${src}
 };
-${errCore}${compactCore}function isValid(data) { return _fn(data); }
+${errCore}${orderDecl}${compactCore}function isValid(data) { return _fn(data); }
 function validate(data) { ${validBody}; }
-${parseCore}${positionsCore}${hashDecl}${exports}`;
+${parseCore}${positionsCore}${fillDecl}${hashDecl}${exports}`;
 }
 
 // Why a validator cannot be written as a compact module, or null when it can.
@@ -673,6 +717,8 @@ ${parseCore}${positionsCore}${hashDecl}${exports}`;
 // along: 1.49.0 bundled for such runtimes, and the generator must not break
 // that.
 const ERROR_RUNTIME_MODULE = './error-runtime';
+// Reads the library's files too, at build time (see lib/aot-order.js).
+const AOT_ORDER_MODULE = './aot-order';
 function loadErrorRuntime() { return require(ERROR_RUNTIME_MODULE); }
 
 // The schema hash a module stamps, once per validator: a plugin writes both
@@ -806,9 +852,11 @@ function toSchemaModule(validator, opts) {
     ? `import { createValidator as _ataCreateValidator } from ${spec};\n`
     : `const { createValidator: _ataCreateValidator } = require(${spec});\n`)
     + (regSpec === null ? '' : format === 'esm' ? `import _ataRegistry from ${regSpec};\n` : `const _ataRegistry = require(${regSpec});\n`);
+  const fillDecl = defaultsDecl(validator);
+  const expNames = 'validate, isValid' + (fillDecl ? ', applyDefaults' : '') + ', schemaHash, ataVersion';
   const exp = format === 'esm'
-    ? 'export { validate, isValid, schemaHash, ataVersion };\nexport default { validate, isValid, schemaHash, ataVersion };\n'
-    : 'module.exports = { validate, isValid, schemaHash, ataVersion };\nmodule.exports.default = module.exports;\n';
+    ? `export { ${expNames} };\nexport default { ${expNames} };\n`
+    : `module.exports = { ${expNames} };\nmodule.exports.default = module.exports;\n`;
   return `// Auto-generated by ata-validator ${ATA_VERSION}, do not edit.
 // Schema module: the schema; the verdict and the errors come from the runtime it imports.
 // Re-run the build after upgrading ata: the version above is what wrote this.
@@ -819,7 +867,7 @@ let _ataV = null;
 function _ataGet() { return _ataV !== null ? _ataV : (_ataV = _ataCreateValidator(${ownId !== null ? 'null' : 'JSON.parse(' + text + ')'}${rtOpts ? ', { ' + rtOpts + ' }' : ''})); }
 function isValid(data) { return _ataGet().isValid(data); }
 function validate(data) { const v = _ataGet(); if (v.isValid(data)) return VALID; const e = v.errors(data); return e === null ? ABORT : { valid: false, errors: e }; }
-const schemaHash = ${JSON.stringify(hashSrc)};
+${fillDecl}const schemaHash = ${JSON.stringify(hashSrc)};
 const ataVersion = ${JSON.stringify(ATA_VERSION)};
 ${exp}`;
 }

package/lib/aot-order.js

@@ -0,0 +1,115 @@
+'use strict';
+
+// How a module written ahead of time hands out its errors in the order the
+// runtime does: schema declaration order (sortErrorsBySchemaOrder in
+// lib/rejections.js). A module used to return them in the order its collector
+// found them, which put `additionalProperties` before `properties` and
+// `format` before `pattern`, and behind a reference a definition's `required`
+// before its `properties`; the first error of a field could differ from the
+// runtime's.
+//
+// The runtime orders by the ordinal of each error's schema path and breaks
+// ties by the path's rank, and comparing ranks alone gives the same order
+// (lib/schema-order.js). Two ways to know them in a module:
+//
+// - Without a reference, the collector writes each error site's ordinal into
+//   the error (`_o`, noteOrdinal in lib/js-compiler-errors.js) and no two
+//   paths share one, so a stable sort by it is the runtime's order.
+// - With one, an error behind a shared definition has its path built when the
+//   definition runs and carries no ordinal, and paths through a `$ref` share
+//   the ordinal of the `$ref`. The module ranks each path itself with
+//   lib/schema-order.js's own functions, embedded as their text so module and
+//   runtime rank with one source, over the schema's skeleton: its schema
+//   objects with every key, subschemas kept, every other value 0, which ranks
+//   every path an error can name exactly as the schema does.
+//
+// Node only, at build time: it reads the library's own files.
+const fs = require('fs');
+const path = require('path');
+
+const _files = new Map();
+function take(file, names) {
+  let src = _files.get(file);
+  if (src === undefined) { src = fs.readFileSync(path.join(__dirname, file), 'utf8'); _files.set(file, src); }
+  return names.map((n) => {
+    const m = new RegExp('^function ' + n + ' ?\\([^]*?^}$', 'm').exec(src);
+    if (m === null) throw new Error('aot-order: lib/' + file + ' has no top-level function ' + n);
+    return m[0].replace(/^\s*\/\/.*\n/gm, '');
+  }).join('\n');
+}
+
+// Keywords whose value is a schema, an array of schemas, or an object of them:
+// the only places an error's schema path goes below a schema object.
+const ONE = new Set(['additionalProperties', 'additionalItems', 'items', 'contains', 'propertyNames', 'if', 'then', 'else', 'not', 'unevaluatedItems', 'unevaluatedProperties']);
+const LIST = new Set(['allOf', 'anyOf', 'oneOf', 'prefixItems', 'items']);
+const MAP = new Set(['properties', 'patternProperties', '$defs', 'definitions', 'dependentSchemas', 'dependencies']);
+
+function skeleton(node) {
+  if (node === null || typeof node !== 'object' || Array.isArray(node)) return 0;
+  const out = {};
+  for (const k of Object.keys(node)) {
+    const v = node[k];
+    let s = 0;
+    if (k === '$ref' && typeof v === 'string') s = v;
+    else if (Array.isArray(v) && LIST.has(k)) s = v.map(skeleton);
+    else if (MAP.has(k) && v !== null && typeof v === 'object' && !Array.isArray(v)) {
+      s = {};
+      for (const name of Object.keys(v)) Object.defineProperty(s, name, { value: Array.isArray(v[name]) ? 0 : skeleton(v[name]), enumerable: true, writable: true, configurable: true });
+    } else if (ONE.has(k) && v !== null && typeof v === 'object') s = skeleton(v);
+    Object.defineProperty(out, k, { value: s, enumerable: true, writable: true, configurable: true });
+  }
+  return out;
+}
+
+function hasReference(schemaObj) {
+  const text = JSON.stringify(schemaObj);
+  return text.includes('"$ref"') || text.includes('"$dynamicRef"') || text.includes('"$recursiveRef"');
+}
+
+// Whether the collector should write ordinals into the errors: only where the
+// module sorts by them.
+function wantsOrdinals(schemaObj) { return !hasReference(schemaObj); }
+
+// The sort, by a key per error, stable as the runtime's insertion sort is, and
+// the copies the caller gets, without the ordinal; a collapsed error's branch
+// errors are ordered and copied the same way.
+const ORDER = (key, cmp) => `function _ataOrder(list) {
+  const n = list.length, out = new Array(n), keys = new Array(n);
+  let prev = ${key === '_o' ? '0' : 'null'};
+  for (let i = 0; i < n; i++) {
+    const src = list[i];
+    const { _o, ...e } = src;
+    if (Array.isArray(e.branchErrors)) e.branchErrors = _ataOrder(e.branchErrors);
+    let k = ${key === '_o' ? "typeof src._o === 'number' ? src._o : prev" : '_ataRank(src.schemaPath)'};
+    prev = k;
+    let j = i - 1;
+    while (j >= 0 && ${cmp}) { keys[j + 1] = keys[j]; out[j + 1] = out[j]; j--; }
+    keys[j + 1] = k;
+    out[j + 1] = e;
+  }
+  return out;
+}
+`;
+
+// Source declaring `_ataOrder(errors)`: the errors sorted as the runtime sorts
+// them, without their ordinals.
+function orderDecl(schemaObj) {
+  if (!hasReference(schemaObj)) return ORDER('_o', 'keys[j] > k');
+  const sk = JSON.stringify(skeleton(schemaObj));
+  return `const _ataSkeleton = JSON.parse(${JSON.stringify(sk).replace(/</g, '\\u003c')});
+const _keyIndexCache = new WeakMap();
+const _rankCache = new WeakMap();
+const _documents = new WeakMap();
+const CONFLICT = null;
+${take('schema-order.js', ['keyIndex', 'unescapePointerSegment', 'rankFor', 'computeRank', 'localTarget'])}
+function _ataRank(p) { return rankFor(_ataSkeleton, p); }
+function _ataAfter(a, b) {
+  if (a === null || b === null) return false;
+  const m = Math.min(a.length, b.length);
+  for (let i = 0; i < m; i++) if (a[i] !== b[i]) return a[i] > b[i];
+  return a.length > b.length;
+}
+${ORDER('rank', '_ataAfter(keys[j], k)')}`;
+}
+
+module.exports = { orderDecl, wantsOrdinals, take };

package/lib/buffer-gate.js

@@ -61,7 +61,39 @@ function re2Diverges(pattern) {
   return false;
 }
 
+// The walker gives up past a depth of its own (100 schema frames, about 50
+// levels of data under a recursive schema) and rejects the document there. A
+// schema that refers back into itself, or that is nested that deep, can reach
+// it with a document validate() accepts, so it is answered through validate(),
+// which has no such limit.
+const NATIVE_DEPTH = 40;
+
+// Whether a `$ref` into this document leads back to a schema it is inside.
+function refersBack(root) {
+  const { localRef } = require('./defaults.js');
+  const done = new Set();
+  const onPath = new Set();
+  const visit = (node) => {
+    if (node === null || typeof node !== 'object') return false;
+    if (onPath.has(node)) return true;
+    if (done.has(node)) return false;
+    onPath.add(node);
+    let back = false;
+    for (const key of Object.keys(node)) {
+      const v = node[key];
+      if (key === '$ref' && typeof v === 'string' && v.startsWith('#')) back = visit(localRef(root, v));
+      else if (key !== 'enum' && key !== 'const' && key !== 'default' && key !== 'examples' && v !== null && typeof v === 'object') back = visit(v);
+      if (back) break;
+    }
+    onPath.delete(node);
+    done.add(node);
+    return back;
+  };
+  return visit(root);
+}
+
 function walk(schema, depth) {
+  if (depth > NATIVE_DEPTH) return true;
   if (schema === true || schema === false) {
     // A boolean root is answered wrong by the walker; nested booleans are
     // handled where they appear (items and prefixItems below).
@@ -110,6 +142,7 @@ function walk(schema, depth) {
 function bufferNeedsSlowPath(schema, schemaMap, keywords) {
   if (keywords && schemaUsesKeywords(schema, keywords)) return true;
   if (walk(schema, 0)) return true;
+  if (refersBack(schema)) return true;
   if (schemaMap && schemaMap.size > 0) {
     for (const s of schemaMap.values()) if (walk(s, 1)) return true;
   }

package/lib/clone-emit.js

@@ -50,12 +50,13 @@ const _INLINE_ANNOTATIONS = new Set(['$ref', 'title', 'description', '$comment',
 const _INLINE_DATA_KEYS = new Set(['default', 'const', 'enum', 'examples']);
 function inlineRefsForClone(root) {
   const state = { budget: 512 };
-  // `inRef` marks content brought in from behind a reference. The runtime's
-  // useDefaults fills a default written next to the $ref, and does not fill
-  // defaults written inside the referenced definition, so the inlined copy
-  // keeps the first and drops the second. parse() must stay exactly as
-  // generous as validate(); a parse that fills more is a disagreement, not a
-  // feature.
+  // The runtime's useDefaults fills a property's default from the schema
+  // written under the property, the $ref node with any default next to it,
+  // and then the defaults inside the referenced definition, as it fills them
+  // inline. The definition's own top-level default is not the property's, so
+  // the inlined copy drops that one and keeps everything below it. parse()
+  // must stay exactly as generous as validate(); a parse that fills more, or
+  // less, is a disagreement.
   const walk = (node, active, inRef) => {
     if (!node || typeof node !== 'object') return node;
     if (Array.isArray(node)) return node.map((n) => walk(n, active, inRef));
@@ -73,14 +74,13 @@ function inlineRefsForClone(root) {
       cur = target;
       entered = true;
     }
-    const strip = inRef || entered;
     const out = {};
     for (const k of Object.keys(cur)) {
-      if (strip && k === 'default') continue;
+      if (entered && k === 'default') continue;
       const v = cur[k];
       // A property named "__proto__" is an own key of the copy: assigned, it
       // set the copy's prototype and the property was gone from parse().
-      const w = (_INLINE_DATA_KEYS.has(k) || k === '$defs' || k === 'definitions') ? v : walk(v, active, strip);
+      const w = (_INLINE_DATA_KEYS.has(k) || k === '$defs' || k === 'definitions') ? v : walk(v, active, false);
       if (k === '__proto__') Object.defineProperty(out, k, { value: w, writable: true, enumerable: true, configurable: true });
       else out[k] = w;
     }
@@ -197,7 +197,7 @@ function emitClone(node, access, depth) {
   if (apSchema) {
     const kVar = `_k${depth}`;
     const vVar = `_v${depth}`;
-    const valueExpr = emitValueExpr(stripDefaultsDeep(apSchema), vVar, depth);
+    const valueExpr = emitValueExpr(apSchema, vVar, depth);
     if (valueExpr === null) return null;
     let skip = '';
     let declSet = '';
@@ -255,20 +255,6 @@ function emitClone(node, access, depth) {
 // carry keys this code cannot see, and copying the reference would smuggle
 // them into a value that claims to be sanitised, so the caller declines the
 // whole clone instead.
-// Drop every schema-position `default` in a subtree, leaving data positions
-// (const, enum, examples) untouched. Used on a record's value schema, where
-// the runtime's useDefaults fills nothing.
-function stripDefaultsDeep(node) {
-  if (!node || typeof node !== 'object') return node;
-  if (Array.isArray(node)) return node.map(stripDefaultsDeep);
-  const out = {};
-  for (const k of Object.keys(node)) {
-    if (k === 'default') continue;
-    out[k] = _INLINE_DATA_KEYS.has(k) ? node[k] : stripDefaultsDeep(node[k]);
-  }
-  return out;
-}
-
 const _CLONE_PRIMITIVE = new Set(['string', 'number', 'integer', 'boolean', 'null']);
 // Whether every value this schema accepts is a primitive, so a copy has
 // nothing inside it to strip and takes the value as it is. A primitive type
@@ -329,4 +315,4 @@ function cloneExprFor(schema) {
   return emitClone(inlineRefsForClone(schema), 'data', 0);
 }
 
-module.exports = { cloneExprFor, emitClone, inlineRefsForClone, stripDefaultsDeep, resolveLocalPointer };
+module.exports = { cloneExprFor, emitClone, inlineRefsForClone, resolveLocalPointer };