ata-validator 1.61.2 → 1.62.0

package/lib/aot-impl.js

@@ -160,13 +160,19 @@ module.exports = { boolFn, hybridFactory, errFn };
 // 'inject' writes no function source. The module exports `setFormats(map)`
 // and each format is looked up from that registry when a value is checked,
 // so the caller supplies the functions at load time.
+// The format name a helper name was made from (js-compiler.js ufName):
+// `_uf_` and the name with every character outside [A-Za-z0-9_] written as
+// `$` and four hex digits.
+function formatFromName(name) {
+  return name.slice(4).replace(/\$([0-9a-f]{4})/g, (m, h) => String.fromCharCode(parseInt(h, 16)));
+}
 function emitFormatDecls(closures, mode, declKW) {
   if (!closures || closures.length === 0) return { decls: '', exportsSetFormats: false };
   if (mode === 'inject') {
     let out = `${declKW} __formats = Object.create(null);\n`;
     out += `function setFormats(map) { for (const k in map) __formats[k] = map[k]; }\n`;
     for (const { name, format } of closures) {
-      const key = JSON.stringify(format === null ? name.slice(4) : format);
+      const key = JSON.stringify(format === null ? formatFromName(name) : format);
       out += `${declKW} ${name} = function (v) { const f = __formats[${key}]; if (typeof f !== 'function') throw new Error('ata: format ' + ${key} + ' is not registered; call setFormats({ [' + ${key} + ']: fn }) before validating'); return f(v); };\n`;
     }
     return { decls: out, exportsSetFormats: true };
@@ -199,10 +205,15 @@ function sourceFrameDecls(frames, schemaFile) {
   const texts = [];
   const textIndex = new Map();
   const rows = [];
+  // The rows come from the caller's `sourceMap` option. A line or column that
+  // is not an integer is written as 0: written as given, a string in one ran
+  // as code when the module loaded.
+  const int = (n) => (Number.isInteger(n) ? n : 0);
   for (const f of frames.values()) {
-    let i = textIndex.get(f.text);
-    if (i === undefined) { i = texts.length; texts.push(f.text); textIndex.set(f.text, i); }
-    rows[f.index] = `[${f.line},${f.col},${i}]`;
+    const text = typeof f.text === 'string' ? f.text : '';
+    let i = textIndex.get(text);
+    if (i === undefined) { i = texts.length; texts.push(text); textIndex.set(text, i); }
+    rows[f.index] = `[${int(f.line)},${int(f.col)},${i}]`;
   }
   return `const __ataSF = ${JSON.stringify(schemaFile)};\n` +
     `const __ataSL = ${JSON.stringify(texts)};\n` +
@@ -367,7 +378,27 @@ function defaultsDecl(validator) {
   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${loadAotOrder().take('defaults.js', defaults.EMBED)}\nreturn buildDefaultsApplier;\n})();\n` +
+  // patternProperties keys are tested as validation tests them: on the
+  // linear engine where validation uses it, the platform RegExp otherwise.
+  // Called without a matcher, the embedded pass took the RegExp for every
+  // pattern, and a key that backtracks cost seconds there. A module whose
+  // declaration names __ataSafeRe carries the engine (callers check).
+  const { useSafeEngine } = require('./js-compiler')._internal;
+  const safe = new Set();
+  const seen = new Set();
+  const walk = (n) => {
+    if (n === null || typeof n !== 'object' || seen.has(n)) return;
+    seen.add(n);
+    if (!Array.isArray(n) && n.patternProperties && typeof n.patternProperties === 'object' && !Array.isArray(n.patternProperties)) {
+      for (const k of Object.keys(n.patternProperties)) if (useSafeEngine(k)) safe.add(k);
+    }
+    for (const k of Object.keys(n)) walk(n[k]);
+  };
+  walk(embedded);
+  const build = safe.size === 0
+    ? 'buildDefaultsApplier'
+    : `(function () { const SAFE = new Set(${JSON.stringify([...safe])}); return (s) => buildDefaultsApplier(s, (p) => SAFE.has(p) ? __ataSafeRe(p) : keyPattern(p)); })()`;
+  return `const _ataDefaults = (function () {\nconst MAX_DEPTH = ${defaults.MAX_DEPTH};\n${loadAotOrder().take('defaults.js', defaults.EMBED)}\nreturn ${build};\n})();\n` +
     `let _ataFill;\nfunction applyDefaults(d) { (_ataFill || (_ataFill = _ataDefaults(JSON.parse(${text}))))(d); }\n`;
 }
 
@@ -577,7 +608,7 @@ function toStandaloneModule(validator, opts) {
   // which carries it anyway, instead of embedding a copy (2.9 KB gzipped,
   // minified) in every module that has a pattern the platform RegExp does not
   // run.
-  const usesSafeRe = errorRuntime !== null && ((jsFn && jsFn._usesSafeRe) || (jsErrFn && jsErrFn._usesSafeRe));
+  let usesSafeRe = errorRuntime !== null && ((jsFn && jsFn._usesSafeRe) || (jsErrFn && jsErrFn._usesSafeRe));
   let compactCore = '';
   if (errorRuntime !== null) {
     const { stripAnnotations } = require('./schema-strip');
@@ -649,9 +680,33 @@ function toStandaloneModule(validator, opts) {
   // safe-regex prelude, which has a module-scope parse() of its own for
   // reading patterns. A second declaration of that name shadowed it and the
   // prelude called this one instead, reaching _fn before its initialiser ran.
-  const parseCore = cloneExpr
-    ? `function _ataParse(data) {\n  ${pre.call}if (!_fn(data)) { const e = new Error('validation failed'); e.name = 'AtaValidationError'; throw e; }\n  return ${cloneExpr};\n}\n`
-    : '';
+  // With a pass before the check (the validator's coerceTypes or
+  // removeAdditional, and its defaults unless useDefaults is off), the
+  // runtime's parse() takes its verdict on a filled copy of the input and
+  // checks the copy it hands back too (buildParse in lib/codegen-engine.js).
+  // Checked on the raw input, a default that makes a conditional apply was
+  // missed and parse() returned what validate() refuses after the fill.
+  const fillDecl = defaultsDecl(validator);
+  const fills = !!fillDecl && vopts.useDefaults !== false;
+  // The defaults pass tests patternProperties keys on the linear engine
+  // where validation does; the module then carries the engine.
+  const fillSafeRe = fillDecl.includes('__ataSafeRe(');
+  if (fillSafeRe && errorRuntime !== null) usesSafeRe = true;
+  const parseCore = !cloneExpr
+    ? ''
+    : !fills && pre.decl === ''
+      ? `function _ataParse(data) {\n  if (!_fn(data)) { const e = new Error('validation failed'); e.name = 'AtaValidationError'; throw e; }\n  return ${cloneExpr};\n}\n`
+      : `function _ataParse(data) {
+  let doc;
+  try { doc = structuredClone(data); } catch (_) { doc = undefined; }
+  if (doc === undefined && data !== undefined) throw new TypeError('parse() is not available for this value: it cannot be copied to fill its defaults before the check. Use validate() instead.');
+  if (doc !== null && typeof doc === 'object') { ${pre.decl !== '' ? '_ataPre(doc); ' : ''}${fills ? 'applyDefaults(doc); ' : ''}}
+  if (!_fn(doc)) { const e = new Error('validation failed'); e.name = 'AtaValidationError'; throw e; }
+  const out = ${cloneExpr};
+  if (!_fn(out)) throw new TypeError('parse() is not available for this value: the copy that keeps the declared properties is not one the schema accepts. Use validate() instead.');
+  return out;
+}
+`;
 
   // validateJSON(): parse the text, validate, and on failure attach a
   // dataFrame (byte offset, line, col, source line) to every error by
@@ -666,7 +721,7 @@ function toStandaloneModule(validator, opts) {
   // the worst case of a pointer at the very end. It is also 125 characters
   // smaller than the full-map builder it replaces.
   const positionsCore = !(opts && opts.positions) ? '' : `const _ataPosMap = ${buildTargetedPositionMap.toString()};
-function _ataFrame(p) { return { byteOffset: p.byteOffset, length: p.length, line: p.line, col: p.col, text: p.text }; }
+function _ataFrame(p) { const f = { byteOffset: p.byteOffset, length: p.length, line: p.line, col: p.col, text: p.text }; if (p.textCol !== undefined) f.textCol = p.textCol; return f; }
 function validateJSON(text) {
   const s = String(text);
   let data;
@@ -705,7 +760,6 @@ 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';
@@ -726,7 +780,7 @@ ${errorRuntime === null ? '// Schema is embedded; runtime has zero dependency on
 // Re-run the build after upgrading ata: the version above is what wrote this.
 ${degradedNote}'use strict';
 ${errorRuntime === null ? '' : format === 'esm' ? `import { createErrors as _ataCreateErrors${usesSafeRe ? ', compileSafe as _ataCompileSafe' : ''}${usesUriWalk ? ', uriWalk as _ataUriWalk' : ''} } from ${JSON.stringify(errorRuntime)};\n` : `const { createErrors: _ataCreateErrors${usesSafeRe ? ', compileSafe: _ataCompileSafe' : ''}${usesUriWalk ? ', uriWalk: _ataUriWalk' : ''} } = require(${JSON.stringify(errorRuntime)});\n`}${_CP_LEN_SOURCE}
-${errorRuntime !== null ? (usesSafeRe ? 'const __ataSafeRe = _ataCompileSafe;\n' : '') : safeRePrelude(jsFn, jsErrFn, onePass !== null && onePass.usesSafeRe ? { _usesSafeRe: true } : null)}${schemaSourceConst}const VALID = Object.freeze({ valid: true, errors: Object.freeze([]) });
+${errorRuntime !== null ? (usesSafeRe ? 'const __ataSafeRe = _ataCompileSafe;\n' : '') : safeRePrelude(jsFn, jsErrFn, (onePass !== null && onePass.usesSafeRe) || fillSafeRe ? { _usesSafeRe: true } : null)}${schemaSourceConst}const VALID = Object.freeze({ valid: true, errors: Object.freeze([]) });
 const ABORT = Object.freeze({
   valid: false,
   errors: Object.freeze([Object.freeze({
@@ -885,7 +939,10 @@ 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);
+  let fillDecl = defaultsDecl(validator);
+  // No verdict code here to carry the linear engine; the defaults pass
+  // brings its own when it tests keys on it.
+  if (fillDecl.includes('__ataSafeRe(')) fillDecl = getSafeRegexEmbed() + '\n' + fillDecl;
   const expNames = 'validate, isValid' + (fillDecl ? ', applyDefaults' : '') + ', schemaHash, ataVersion';
   const exp = format === 'esm'
     ? `export { ${expNames} };\nexport default { ${expNames} };\n`
@@ -1035,6 +1092,7 @@ function bundleStandalone(Validator, schemas, opts) {
     // The runtime's passes over the data, for the options asked for, and its
     // defaults pass as the validator's applyDefaults.
     const fillDecl = defaultsDecl(v);
+    if (fillDecl.includes('__ataSafeRe(')) bundleUsesSafeRe = true;
     const pre = bundlePreprocess(v, opts, fillDecl, 'bundleStandalone');
     preamble = preamble ? `${preamble}\n${fillDecl}${pre.decl}` : fillDecl + pre.decl;
     const ret = (body) => fillDecl
@@ -1188,13 +1246,21 @@ function bundleCompact(Validator, schemas, opts) {
   // User format functions are referenced as _uf_<name> by the hybrid and error
   // bodies. Collect them across all schemas (deduped by name) and embed via
   // Function#toString so the bundle stays self-contained.
-  const fmtSeen = new Set();
+  // One declaration per helper name. The name is one to one with the
+  // format name, so two entries under one name are the same format; were
+  // they bound to different functions the bundle could not serve both, so
+  // that is refused rather than letting one schema run another's checker.
+  const fmtSeen = new Map();
   const fmtAll = [];
   for (const e of entries) {
     if (!e || !e.fmt) continue;
     for (const entry of e.fmt) {
-      if (fmtSeen.has(entry.name)) continue;
-      fmtSeen.add(entry.name);
+      const prev = fmtSeen.get(entry.name);
+      if (prev !== undefined) {
+        if (prev !== entry.fn) throw new Error(`ata: custom format "${entry.format === null ? formatFromName(entry.name) : entry.format}" is bound to two different functions in this bundle`);
+        continue;
+      }
+      fmtSeen.set(entry.name, entry.fn);
       fmtAll.push(entry);
     }
   }
@@ -1255,9 +1321,24 @@ function loadBundle(Validator, mods, schemas, opts) {
 // do not write but a pattern could carry, has its backslash dropped, since
 // `\x3C` already is the escape. A module with neither sequence, which is
 // nearly every one, comes back as the same string.
+// The match is the `<` and what follows; the backslashes before it are
+// counted from the match offset. Matching them as part of the pattern made
+// the scan re-read a run of backslashes at every `<` after it, so an enum
+// value of 40000 backslashes and `<a` took 6.5 s. One pass, whatever the run.
 function htmlSafe(src) {
   if (typeof src !== 'string' || src.indexOf('<') === -1) return src;
-  return src.replace(/(\\*)<(\/script|!--)/gi, (m, bs, rest) => (bs.length % 2 ? bs.slice(0, -1) : bs) + '\\x3C' + rest);
+  let out = '';
+  let last = 0;
+  const re = /<(\/script|!--)/gi;
+  let m;
+  while ((m = re.exec(src)) !== null) {
+    const at = m.index;
+    let bs = 0;
+    while (at - bs - 1 >= last && src.charCodeAt(at - bs - 1) === 92) bs++;
+    out += src.slice(last, at - (bs % 2)) + '\\x3C' + m[1];
+    last = at + m[0].length;
+  }
+  return last === 0 ? src : out + src.slice(last);
 }
 const htmlSafeResult = (fn) => function () { return htmlSafe(fn.apply(this, arguments)); };
 
@@ -1278,6 +1359,16 @@ module.exports = {
     if (!Array.isArray(schemas)) return er.errorRuntimeSource(format, ATA_VERSION, undefined, !!schemaMode);
     const { stripAnnotations } = require('./schema-strip');
     const embedded = schemas.map((x) => stripAnnotations(x && typeof x === 'object' && x._schemaObj !== undefined ? x._schemaObj : x));
+    // A module reaches the registered schemas (`schemas` option) through
+    // $ref, so what they use the runtime must carry too. Read from the
+    // validator's map, since the validator may not have compiled yet: a
+    // pattern that lived only in a registered schema was missed, the runtime
+    // went out without the pattern engine, and the module matched on the
+    // platform RegExp.
+    for (const x of schemas) {
+      if (!x || typeof x !== 'object' || !(x._schemaMap instanceof Map)) continue;
+      for (const ext of x._schemaMap.values()) if (ext && typeof ext === 'object') embedded.push(stripAnnotations(ext));
+    }
     const features = er.runtimeFeatures(embedded);
     for (const x of schemas) if (x && x._jsFn && x._jsFn._usesSafeRe) features['safe-regex'] = true;
     return er.errorRuntimeSource(format, ATA_VERSION, features, !!schemaMode);

package/lib/buffer-gate.js

@@ -24,11 +24,16 @@ const UNSUPPORTED_KEYWORDS = new Set([
   'contains', 'minContains', 'maxContains',
   'unevaluatedProperties', 'unevaluatedItems',
   'dependencies', 'dependentSchemas', 'dependentRequired',
-  'propertyNames', 'patternProperties',
+  'propertyNames', 'patternProperties', 'propertyDependencies',
 ]);
 
-// Formats the native checkers answer differently from the JS ones.
-const DIVERGENT_FORMATS = new Set(['hostname', 'date-time', 'time', 'uri-reference', 'duration']);
+// Formats the native engine checks by the same rules as lib/formats.js,
+// held to the same answers by tests/test_native_formats.js. Every other
+// format name goes through validate(): the native engine has no check for
+// it and would let any string pass. This was a list of the divergent ones,
+// which missed every format the engine does not know (json-pointer, iri,
+// uri-template, regex and the rest) and a caller's own formats.
+const NATIVE_FORMATS = new Set(['email', 'date', 'uri', 'uuid', 'ipv4', 'ipv6', 'hostname']);
 
 const SUBSCHEMA_MAPS = ['properties', 'patternProperties', '$defs', 'definitions', 'dependentSchemas', 'dependencies'];
 const SUBSCHEMA_NODES = [
@@ -92,7 +97,7 @@ function refersBack(root) {
   return visit(root);
 }
 
-function walk(schema, depth) {
+function walk(schema, depth, userFormats) {
   if (depth > NATIVE_DEPTH) return true;
   if (schema === true || schema === false) {
     // A boolean root is answered wrong by the walker; nested booleans are
@@ -101,7 +106,7 @@ function walk(schema, depth) {
   }
   if (schema === null || typeof schema !== 'object') return false;
   if (Array.isArray(schema)) {
-    for (const s of schema) if (walk(s, depth + 1)) return true;
+    for (const s of schema) if (walk(s, depth + 1, userFormats)) return true;
     return false;
   }
   for (const key of Object.keys(schema)) {
@@ -114,7 +119,7 @@ function walk(schema, depth) {
     if (key === '$id' && depth > 0) return true;
     // An empty enum rejects everything; the walker accepts everything.
     if (key === 'enum' && Array.isArray(v) && v.length === 0) return true;
-    if (key === 'format' && DIVERGENT_FORMATS.has(v)) return true;
+    if (key === 'format' && (!NATIVE_FORMATS.has(v) || (userFormats && Object.prototype.hasOwnProperty.call(userFormats, v)))) return true;
     // Unicode property escapes: RE2 cannot parse them and the walker then
     // skips the pattern instead of failing.
     if (key === 'pattern' && typeof v === 'string' && /\\[pP]\{/.test(v)) return true;
@@ -126,10 +131,10 @@ function walk(schema, depth) {
 
     if (SUBSCHEMA_MAPS.includes(key)) {
       if (v && typeof v === 'object' && !Array.isArray(v)) {
-        for (const k of Object.keys(v)) if (walk(v[k], depth + 1)) return true;
+        for (const k of Object.keys(v)) if (walk(v[k], depth + 1, userFormats)) return true;
       }
     } else if (SUBSCHEMA_NODES.includes(key)) {
-      if (walk(v, depth + 1)) return true;
+      if (walk(v, depth + 1, userFormats)) return true;
     }
   }
   return false;
@@ -138,13 +143,15 @@ function walk(schema, depth) {
 // True when the buffer APIs must answer through validate() for this schema.
 // `keywords` is the validator's normalized custom keyword map, if any: the
 // native walker knows nothing about those, so a schema using one is routed
-// through validate() like the other shapes here.
-function bufferNeedsSlowPath(schema, schemaMap, keywords) {
+// through validate() like the other shapes here. `userFormats` is the
+// validator's `formats` option: a format it defines, even under a built-in
+// name, is a check only the JS engines run.
+function bufferNeedsSlowPath(schema, schemaMap, keywords, userFormats) {
   if (keywords && schemaUsesKeywords(schema, keywords)) return true;
-  if (walk(schema, 0)) return true;
+  if (walk(schema, 0, userFormats)) return true;
   if (refersBack(schema)) return true;
   if (schemaMap && schemaMap.size > 0) {
-    for (const s of schemaMap.values()) if (walk(s, 1)) return true;
+    for (const s of schemaMap.values()) if (walk(s, 1, userFormats)) return true;
   }
   return false;
 }
@@ -163,8 +170,12 @@ function toText(input, name) {
 function installSlowBufferApis(validator) {
   const isValidText = (text) => validator.isValidJSON(text);
   validator.isValid = (input) => isValidText(toText(input, 'isValid'));
-  validator.isValidPrepadded = (paddedBuffer, jsonLength) =>
-    isValidText(Buffer.from(paddedBuffer.buffer, paddedBuffer.byteOffset, jsonLength).toString('utf8'));
+  // The length is the caller's, so it is held to the buffer: a view past its
+  // end read the bytes of whatever shared the pool, and answered on them.
+  validator.isValidPrepadded = (paddedBuffer, jsonLength) => {
+    if (!(paddedBuffer instanceof Uint8Array) || !Number.isInteger(jsonLength) || jsonLength < 0 || jsonLength > paddedBuffer.byteLength) return false;
+    return isValidText(Buffer.from(paddedBuffer.buffer, paddedBuffer.byteOffset, jsonLength).toString('utf8'));
+  };
   const ndjson = (input, name) => {
     const lines = toText(input, name).split('\n');
     const out = [];

package/lib/bun-target.js

@@ -79,15 +79,20 @@ function empty () { return { string: [], number: [], boolean: [], null: [], obje
 function universal () { const t = empty(); for (const k of KINDS) t[k].push(UNIVERSAL[k]); return t }
 function single (kind, alt) { const t = empty(); t[kind].push(alt); return t }
 function union (a, b) { const t = empty(); for (const k of [...KINDS, 'alias']) t[k] = dedupe([...a[k], ...b[k]]); return t }
-function dedupe (xs) { return xs.filter((x, i) => xs.indexOf(x) === i) }
+function dedupe (xs) { return xs.length < 2 ? xs : [...new Set(xs)] }
 function isUniversal (t) { return t.alias.length === 0 && KINDS.every((k) => t[k].length === 1 && t[k][0] === UNIVERSAL[k]) }
 
 // Intersection, or null where the two cannot be written as one type; the
-// caller then keeps one side in the residual.
+// caller then keeps one side in the residual. The product of two unions
+// distributes, so allOf over n branches of two shapes each is 2^n
+// alternatives: 14 branches took 2.3 s and 16 did not finish. Past this many
+// alternatives for one kind the branch stays in the residual.
+const MAX_ALTERNATIVES = 256
 function intersect (a, b) {
   if (a.alias.length || b.alias.length) return null
   const t = empty()
   for (const k of KINDS) {
+    if (a[k].length * b[k].length > MAX_ALTERNATIVES) return null
     for (const x of a[k]) {
       for (const y of b[k]) {
         const z = meet(k, x, y)
@@ -548,17 +553,28 @@ function schemaToBunType (root, opts = {}) {
 // the type, and the module's functions with the type on them. `parse`
 // declares the type where it parses, which is what the compiler reads to make
 // the objects with that layout; the module then checks the content.
+// A string as a JavaScript literal with every line terminator escaped.
+// JSON.stringify leaves U+2028 and U+2029 as they are, and inside a `//`
+// comment those end the comment the way a line feed does.
+function jsString (s) {
+  return JSON.stringify(String(s)).replace(/[\u2028\u2029]/g, (c) => '\\u' + c.charCodeAt(0).toString(16))
+}
+// The same without the quotes, for text that goes into a // comment: a file
+// name holding a line break ended the comment and the rest of the name was
+// source.
+function commentText (s) { return jsString(s).slice(1, -1) }
+
 function toBunModule ({ schemaFile, moduleImport, typeName: tn, typeSource, aliases }) {
   const lines = []
-  lines.push(`// Generated by ata build --target bun from ${schemaFile}. Do not edit.`)
+  lines.push(`// Generated by ata build --target bun from ${commentText(schemaFile)}. Do not edit.`)
   lines.push('//')
   lines.push('// For executables built with `bun build --compile --aot`: the schema as a type')
-  lines.push(`// for the program, with the plain module (${moduleImport}) answering every`)
+  lines.push(`// for the program, with the plain module (${commentText(moduleImport)}) answering every`)
   lines.push('// check, so the answers and the errors are the module\'s. `parse(text)` declares')
   lines.push('// the type where it parses and the module checks the content; it is not faster')
   lines.push('// than a plain parse and the module. Everywhere else, including plain `bun run`,')
   lines.push('// the plain module does the same without this file.')
-  lines.push(`import * as _m from ${JSON.stringify(moduleImport)}`)
+  lines.push(`import * as _m from ${jsString(moduleImport)}`)
   lines.push('')
   for (const [n, src] of aliases) lines.push(`type ${n} = ${src}`)
   lines.push(`export type ${tn} = ${typeSource}`)

package/lib/clone-emit.js

@@ -50,6 +50,12 @@ 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 };
+  // A schema that embeds another resource (a subschema with its own `$id`)
+  // reads a fragment `$ref` inside it against that resource, not against
+  // this root, so the pointer resolved here could name a different schema
+  // from the one validation applies. No $ref is inlined there; emitClone
+  // then declines the $ref as it stands.
+  if (embedsResource(root, root, new Set())) return root;
   // 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
@@ -90,11 +96,83 @@ function inlineRefsForClone(root) {
   return walk(root, new Set(), false);
 }
 
+function embedsResource(node, root, seen) {
+  if (!node || typeof node !== 'object' || seen.has(node)) return false;
+  seen.add(node);
+  if (Array.isArray(node)) return node.some((n) => embedsResource(n, root, seen));
+  if (node !== root && typeof node.$id === 'string' && !node.$id.startsWith('#')) return true;
+  for (const k of Object.keys(node)) {
+    if (_INLINE_DATA_KEYS.has(k)) continue;
+    if (embedsResource(node[k], root, seen)) return true;
+  }
+  return false;
+}
+
+// The names a node requires through itself and the in-place applicators
+// below it (allOf, anyOf, oneOf, if, then, else, dependentRequired and the
+// array form of dependencies). Every one has to be a declared property, or
+// the copy, which keeps only declared keys, drops a key the schema demands
+// and hands back a value validate() refuses. `not` is left out: a name
+// required under it is one the value must not carry. Returns false where
+// the walk cannot tell: dependentSchemas, the schema form of dependencies,
+// or a $ref inside an applicator.
+function requiredNames(node, out, depth) {
+  if (!node || typeof node !== 'object' || Array.isArray(node)) return true;
+  if (depth > 16) return false;
+  if (depth > 0 && node.$ref !== undefined) return false;
+  if (node.dependentSchemas !== undefined) return false;
+  if (Array.isArray(node.required)) for (const n of node.required) out.add(n);
+  if (node.dependentRequired && typeof node.dependentRequired === 'object') {
+    for (const k of Object.keys(node.dependentRequired)) {
+      out.add(k);
+      const list = node.dependentRequired[k];
+      if (Array.isArray(list)) for (const n of list) out.add(n);
+    }
+  }
+  if (node.dependencies !== undefined) {
+    if (!node.dependencies || typeof node.dependencies !== 'object') return false;
+    for (const k of Object.keys(node.dependencies)) {
+      const v = node.dependencies[k];
+      if (!Array.isArray(v)) return false;
+      out.add(k);
+      for (const n of v) out.add(n);
+    }
+  }
+  for (const k of ['allOf', 'anyOf', 'oneOf']) {
+    if (node[k] === undefined) continue;
+    if (!Array.isArray(node[k])) return false;
+    for (const b of node[k]) if (!requiredNames(b, out, depth + 1)) return false;
+  }
+  for (const k of ['if', 'then', 'else']) {
+    if (node[k] !== undefined && !requiredNames(node[k], out, depth + 1)) return false;
+  }
+  return true;
+}
+
+// The source budget for default values written into one copy. A shared
+// definition is inlined at every $ref to it, and its default with it: 200
+// references to a 50 KB default made 10 MB of source. Past the budget the
+// copy declines, as it does for anything else it cannot do well.
+const DEFAULT_SOURCE_BUDGET = 256 * 1024;
+
+// A default as source that builds it fresh on every parse. An object literal
+// reads a "__proto__" key as the prototype slot, so a default holding one (an
+// own key, as JSON.parse writes it) is rebuilt by JSON.parse from its text:
+// as a literal, the filled value had no such key and inherited from the
+// default's inner object. Null past the source budget.
+function defaultSource(v, budget) {
+  const text = JSON.stringify(v);
+  const src = v !== null && typeof v === 'object' && text.includes('"__proto__"') ? `JSON.parse(${JSON.stringify(text)})` : text;
+  budget.left -= src.length;
+  return budget.left < 0 ? null : src;
+}
+
 const PROTO_KEY_NAMES = new Set([...Object.getOwnPropertyNames(Object.prototype), '__proto__']);
 
-function emitClone(node, access, depth) {
+function emitClone(node, access, depth, budget) {
   if (!node || typeof node !== 'object') return null;
   if (depth > 12) return null;
+  if (budget === undefined) budget = { left: DEFAULT_SOURCE_BUDGET };
   // Only plain object nodes are cloneable, and only when the schema names
   // every property it keeps. A $ref means the set of allowed keys is not
   // this node's to decide. In-place applicators (allOf, anyOf, oneOf,
@@ -151,6 +229,13 @@ function emitClone(node, access, depth) {
     for (const n of names) if (!Object.prototype.hasOwnProperty.call(node.properties, n)) return null;
   }
   const required = new Set(Array.isArray(node.required) ? node.required : []);
+  // Outside the record shape, where every key is kept, every name the
+  // schema requires must be one the copy keeps.
+  if (!apSchema) {
+    const demanded = new Set();
+    if (!requiredNames(node, demanded, 0)) return null;
+    for (const n of demanded) if (!node.properties || !Object.prototype.hasOwnProperty.call(node.properties, n)) return null;
+  }
 
   const fixed = [];
   const conditional = [];
@@ -174,7 +259,7 @@ function emitClone(node, access, depth) {
       if (!probe || !probe(prop.default)) return null;
     }
     const read = `${access}[${JSON.stringify(key)}]`;
-    const value = emitValueExpr(prop, read, depth);
+    const value = emitValueExpr(prop, read, depth, budget);
     if (value === null) return null;
     // A plain `"__proto__":` in an object literal is the prototype slot, not
     // a property; `["__proto__"]:` is a property. Only that key is written as
@@ -197,7 +282,7 @@ function emitClone(node, access, depth) {
   if (apSchema) {
     const kVar = `_k${depth}`;
     const vVar = `_v${depth}`;
-    const valueExpr = emitValueExpr(apSchema, vVar, depth);
+    const valueExpr = emitValueExpr(apSchema, vVar, depth, budget);
     if (valueExpr === null) return null;
     let skip = '';
     let declSet = '';
@@ -217,8 +302,15 @@ function emitClone(node, access, depth) {
   if (conditional.length === 0 && !recordLoop) return literal;
   // Optional properties are added only when present, so the result never
   // gains a key the input did not have.
+  const dfltSrc = [];
+  for (const c of conditional) {
+    if (c.dflt === undefined) { dfltSrc.push(null); continue; }
+    const src = defaultSource(c.dflt, budget);
+    if (src === null) return null;
+    dfltSrc.push(src);
+  }
   const adds = conditional
-    .map(({ key, value, dflt }) => {
+    .map(({ key, value, dflt }, i) => {
       // Object.hasOwn, not `in`: `in` also answers for what the instance
       // inherits, so a property named `constructor` would copy the inherited
       // function into the output that validate().data does not carry. And a
@@ -235,12 +327,12 @@ function emitClone(node, access, depth) {
         ? `Object.prototype.hasOwnProperty.call(${access}, ${k})`
         : `(${k} in ${access} && (${access}.__proto__ === Object.prototype || Object.prototype.hasOwnProperty.call(${access}, ${k})))`;
       const set = `if (${own}) ${assign}`;
-      // The default is emitted as a literal inside the call, so an object or
+      // The default is emitted as source inside the call, so an object or
       // array default is a fresh value on every parse, never shared state.
       if (dflt === undefined) return set;
       const setDflt = key === '__proto__'
-        ? `Object.defineProperty(${tmp}, ${JSON.stringify(key)}, { value: ${JSON.stringify(dflt)}, writable: true, enumerable: true, configurable: true });`
-        : `${tmp}[${JSON.stringify(key)}] = ${JSON.stringify(dflt)};`;
+        ? `Object.defineProperty(${tmp}, ${JSON.stringify(key)}, { value: ${dfltSrc[i]}, writable: true, enumerable: true, configurable: true });`
+        : `${tmp}[${JSON.stringify(key)}] = ${dfltSrc[i]};`;
       return `${set} else ${setDflt}`;
     })
     .join(' ');
@@ -278,9 +370,22 @@ function isPrimitiveOnly(s) {
   return false;
 }
 
-function emitValueExpr(prop, read, depth) {
+function emitValueExpr(prop, read, depth, budget) {
   if (!prop || typeof prop !== 'object') return null;
   if (prop.$ref) return null;
+  // Positions named by prefixItems (or the array form of items, which
+  // normalization turns into prefixItems) each have their own schema, and
+  // copying them all with the strategy for `items` handed back an object in
+  // a prefix slot as the input's own reference, its undeclared keys kept.
+  // A tuple of primitives, with nothing or primitives after it, has nowhere
+  // to hide a key, and is copied as a fresh array like any other.
+  if (prop.prefixItems !== undefined || Array.isArray(prop.items)) {
+    const tuple = Array.isArray(prop.prefixItems) ? prop.prefixItems : prop.items;
+    const rest = Array.isArray(prop.items) ? prop.additionalItems : prop.items;
+    if (prop.type === 'array' && Array.isArray(tuple) && tuple.every(isPrimitiveOnly) &&
+        (rest === false || (rest !== undefined && isPrimitiveOnly(rest)))) return `${read}.slice()`;
+    return null;
+  }
   if (isPrimitiveOnly(prop)) return read;
   // A value checked with `instanceof` (the keyword @ata-project/keywords adds)
   // is an instance of a class, such as a Date, not a JSON object whose keys
@@ -290,7 +395,7 @@ function emitValueExpr(prop, read, depth) {
   const isRecordable = (s) => s.properties ||
     (s.additionalProperties && typeof s.additionalProperties === 'object');
   if (prop.type === 'object' && isRecordable(prop)) {
-    return emitClone(prop, read, depth + 1);
+    return emitClone(prop, read, depth + 1, budget);
   }
   if (prop.type === 'array' && prop.items && typeof prop.items === 'object' &&
       !Array.isArray(prop.items)) {
@@ -300,7 +405,7 @@ function emitValueExpr(prop, read, depth) {
     if (isPrimitiveOnly(it)) return `${read}.slice()`;
     if (it.type === 'object' && isRecordable(it)) {
       const el = '_e' + depth;
-      const inner = emitClone(it, el, depth + 1);
+      const inner = emitClone(it, el, depth + 1, budget);
       if (!inner) return null;
       return `${read}.map((${el}) => (${inner}))`;
     }