ata-validator 1.36.1 → 1.37.1

package/build.d.ts

@@ -178,3 +178,10 @@ export function compiledSchemaFor(schema: unknown): object;
  * whose detailed errors the generator cannot produce.
  */
 export function compiledModuleFor(schema: unknown, opts?: { format?: 'esm' | 'cjs' }): string | null;
+
+/**
+ * The Validator options `fromCompiled()` reproduces, so a plugin can tell
+ * whether `new Validator(schema, options)` can be replaced. Absent before
+ * ata-validator 1.37.0, where only calls without options can be.
+ */
+export const compiledOptions: readonly string[];

package/build.mjs

@@ -12,4 +12,5 @@ export const schemaHash = mod.schemaHash;
 export const compiledEligible = mod.compiledEligible;
 export const compiledSchemaFor = mod.compiledSchemaFor;
 export const compiledModuleFor = mod.compiledModuleFor;
+export const compiledOptions = mod.compiledOptions;
 export default mod;

package/compiled.d.ts

@@ -14,4 +14,12 @@ export interface CompiledValidator<T = unknown> {
   isValidJSON(json: string): boolean;
 }
 
-export function fromCompiled<T = unknown>(mod: CompiledModule, schema: object): CompiledValidator<T>;
+/** The Validator options `fromCompiled` reproduces. Any other option throws. */
+export const COMPILED_OPTIONS: readonly ['useDefaults'];
+
+export interface CompiledOptions {
+  /** `false` leaves the input unchanged, as `new Validator(schema, { useDefaults: false })` does. */
+  useDefaults?: boolean;
+}
+
+export function fromCompiled<T = unknown>(mod: CompiledModule, schema: object, options?: CompiledOptions): CompiledValidator<T>;

package/compiled.mjs

@@ -1,3 +1,3 @@
 import mod from './compiled.js';
-export const { fromCompiled } = mod;
+export const { fromCompiled, COMPILED_OPTIONS } = mod;
 export default mod;

package/index.d.ts

@@ -452,6 +452,17 @@ export interface BundleStandaloneOptions extends ValidatorOptions {
 export interface StandardSchemaV1Props<Output = unknown, Input = unknown> {
   version: 1;
   vendor: "ata-validator";
+  /**
+   * Standard JSON Schema: the schema this validator checks, as a copy, for a
+   * consumer that publishes it (the MCP SDK's `inputSchema`, for one). The
+   * target must be the dialect the schema declares, and a schema without
+   * `$schema` is 2020-12. Any other target throws; ata does not convert
+   * between dialects.
+   */
+  jsonSchema: {
+    input(options: { target: "draft-2020-12" | "draft-07" | (string & {}); libraryOptions?: Record<string, unknown> }): Record<string, unknown>;
+    output(options: { target: "draft-2020-12" | "draft-07" | (string & {}); libraryOptions?: Record<string, unknown> }): Record<string, unknown>;
+  };
   validate(
     value: unknown
   ):

package/lib/aot-build.js

@@ -295,8 +295,8 @@ const { schemaHash } = require('./schema-hash');
 // tests/test_compiled_parity.js holds that. Declined: custom error messages,
 // which the core applies in a layer the wrapper does not carry. A caller must also get a
 // module back from toStandaloneModule, which returns null for a schema it
-// cannot compile. The text checks are deliberately coarse: a property named
-// `default` declines too, and declining costs only the saving.
+// cannot compile. The text check is deliberately coarse: a property named
+// `errorMessage` declines too, and declining costs only the saving.
 function compiledEligible(schema) {
   if (typeof schema !== 'object' || schema === null || Array.isArray(schema)) return false;
   return !JSON.stringify(schema).includes('"errorMessage"');
@@ -331,7 +331,13 @@ function compiledModuleFor(schema, opts) {
   return src && !degraded ? src : null;
 }
 
+// The Validator options fromCompiled() reproduces, for a plugin deciding whether
+// `new Validator(schema, options)` can be replaced. An older ata-validator does
+// not export this, and a plugin should then replace only calls without options.
+const { COMPILED_OPTIONS: compiledOptions } = require('./compiled');
+
 module.exports = {
+  compiledOptions,
   compiledEligible,
   compiledSchemaFor,
   compiledModuleFor,

package/lib/buffer-gate.js

@@ -37,6 +37,30 @@ const SUBSCHEMA_NODES = [
   'allOf', 'anyOf', 'oneOf', 'prefixItems',
 ];
 
+// Where RE2 and ECMA-262 give different answers for the same pattern. RE2's
+// `\s` is the ASCII whitespace alone, so it misses U+00A0, U+2028, U+3000 and
+// U+FEFF, which ECMA-262 counts, and its `.` matches a carriage return and the
+// line and paragraph separators, which ECMA-262's does not. `^\S+$` accepted
+// "a\u2028b" on the native text path while validate() rejected it. Any `\s`
+// or `\S`, and any `.` outside a class that is not escaped, sends the schema to
+// the JS path.
+function re2Diverges(pattern) {
+  let inClass = false;
+  for (let i = 0; i < pattern.length; i++) {
+    const c = pattern[i];
+    if (c === '\\') {
+      const e = pattern[i + 1];
+      if (e === 's' || e === 'S') return true;
+      i++;
+      continue;
+    }
+    if (inClass) { if (c === ']') inClass = false; continue; }
+    if (c === '[') { inClass = true; continue; }
+    if (c === '.') return true;
+  }
+  return false;
+}
+
 function walk(schema, depth) {
   if (schema === true || schema === false) {
     // A boolean root is answered wrong by the walker; nested booleans are
@@ -62,6 +86,7 @@ function walk(schema, depth) {
     // 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;
+    if (key === 'pattern' && typeof v === 'string' && re2Diverges(v)) return true;
     // Tuple forms: prefixItems and the draft-07 array form of items are
     // checked against the wrong positions by the walker.
     if (key === 'prefixItems') return true;

package/lib/compiled.js

@@ -10,14 +10,20 @@
 //
 // Only for a schema compiledEligible() accepts, and with the schema
 // compiledSchemaFor() returns: the one the runtime reads, after normalization.
-// Custom error messages and every option other than the defaults stay on the
-// runtime. Defaults are applied as a default Validator applies them, before
-// any check, with the same code.
+// 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, LazyJsonRejection, _enrichLazy } = require('./rejections');
 const { buildDefaultsApplier } = require('./defaults');
 
 const VALID_RESULT = Object.freeze({ valid: true, errors: Object.freeze([]) });
+
+// 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
+// reproduce, so it is refused rather than ignored.
+const COMPILED_OPTIONS = Object.freeze(['useDefaults']);
 const EMPTY_ERRORS = Object.freeze([]);
 const VERDICT_DISAGREES = Object.freeze({
   valid: false,
@@ -43,9 +49,17 @@ class CompiledState {
   }
 }
 
-function fromCompiled(mod, schema) {
+function fromCompiled(mod, schema, options) {
+  if (options !== undefined && (options === null || typeof options !== 'object')) {
+    throw new TypeError('fromCompiled options must be an object');
+  }
+  for (const key of Object.keys(options || {})) {
+    if (!COMPILED_OPTIONS.includes(key)) {
+      throw new TypeError(`fromCompiled does not support the ${key} option; a Validator with it has to stay on the runtime`);
+    }
+  }
   const self = new CompiledState(schema);
-  const fill = buildDefaultsApplier(schema);
+  const fill = options && options.useDefaults === false ? null : buildDefaultsApplier(schema);
   if (fill) {
     self._mutatesInput = true;
     self._preprocess = fill;
@@ -93,4 +107,4 @@ function fromCompiled(mod, schema) {
   };
 }
 
-module.exports = { fromCompiled };
+module.exports = { fromCompiled, COMPILED_OPTIONS };

package/lib/js-compiler.js

@@ -1237,6 +1237,30 @@ const REF_NEUTRAL_SIBLINGS = new Set([
   'markdownEnumDescriptions', 'defaultSnippets', 'doNotSuggest', 'suggestSortText',
 ])
 
+// Stands for the schema path of a call to a recursive definition's error
+// helper while its body is generated; see genCodeENode. Not a pointer, so no
+// ordinal or source frame is looked up for it at compile time.
+const SP_PLACEHOLDER = '@@ata-sp@@'
+
+// Follows a definition that is a local $ref to another definition until it
+// reaches one that is not. False for a chain that loops, and for one whose
+// next hop is not a definition in this document; codegenSafe decides whether
+// a non-local reference resolves.
+function aliasChainEnds(def, defs) {
+  const seen = new Set()
+  let node = def
+  while (node && typeof node === 'object' && typeof node.$ref === 'string') {
+    const m = node.$ref.match(/^#\/(?:\$defs|definitions)\/([^/]+)$/)
+    if (!m) return !node.$ref.startsWith('#/')
+    const name = m[1].replace(/~1/g, '/').replace(/~0/g, '~')
+    if (seen.has(name)) return false
+    seen.add(name)
+    node = defs[name]
+    if (node === undefined) return false
+  }
+  return true
+}
+
 function codegenSafe(schema, schemaMap) {
   if (typeof schema === 'boolean') return true
   if (typeof schema !== 'object' || schema === null) return true
@@ -1381,7 +1405,11 @@ function codegenSafe(schema, schemaMap) {
         // codegen anchor maps register it (see "Build anchors map"), so anchor
         // refs (`$ref: '#name'`) resolve to it on all paths.
         if (def.$id && !def.$id.startsWith('#')) return false
-        if (def.$ref) return false // nested ref chain — bail
+        // A definition that is only a reference to another one is an alias,
+        // the shape TypeScript-to-schema generators emit for a named union.
+        // The generators resolve it like any other $ref; a chain of aliases
+        // that loops back on itself has no schema at its end and declines.
+        if (def.$ref && !aliasChainEnds(def, defs)) return false
         if (!codegenSafe(def, schemaMap)) return false
       }
     }
@@ -1697,7 +1725,103 @@ function sharedCodegenGate(schema, schemaMap) {
 
 // --- Codegen mode: generates a single Function (NOT CSP-safe) ---
 // This matches ajv's approach: one monolithic function, V8 JIT fully inlines it
+// `propertyNames` as the generators read it. They express maxLength,
+// minLength, pattern, const and enum, and the gate declines anything else, so
+// a schema that writes `propertyNames: { $ref: '#/definitions/Key' }` or adds
+// `type: 'string'` went to the interpreted engine. Both are rewritten here, on
+// a copy of the nodes that change: a local reference, through aliases, is
+// replaced by what it names, `type: 'string'` is dropped since every property
+// name is a string, and annotations go. Where what is left is still not all
+// supported keys, the node is left as written and the gate declines as before.
+// Errors keep the path the interpreted engine reports, which runs through the
+// reference without naming it.
+const PN_SUPPORTED = new Set(['maxLength', 'minLength', 'pattern', 'const', 'enum'])
+const PN_ANNOTATIONS = new Set(['$schema', '$comment', 'title', 'description', 'examples', 'default', 'deprecated', 'readOnly', 'writeOnly'])
+function simplePropertyNames(pn, defs) {
+  const seen = new Set()
+  while (pn && typeof pn === 'object' && typeof pn.$ref === 'string') {
+    if (Object.keys(pn).some((k) => k !== '$ref' && !PN_ANNOTATIONS.has(k) && !k.startsWith('x-'))) return null
+    const m = pn.$ref.match(/^#\/(?:\$defs|definitions)\/([^/]+)$/)
+    if (!m || !defs) return null
+    const name = m[1].replace(/~1/g, '/').replace(/~0/g, '~')
+    if (seen.has(name)) return null
+    seen.add(name)
+    pn = defs[name]
+  }
+  if (!pn || typeof pn !== 'object' || Array.isArray(pn)) return null
+  const out = {}
+  for (const [k, val] of Object.entries(pn)) {
+    if (PN_ANNOTATIONS.has(k) || k.startsWith('x-')) continue
+    if (k === 'type') {
+      if (val === 'string' || (Array.isArray(val) && val.includes('string'))) continue
+      return null
+    }
+    if (!PN_SUPPORTED.has(k)) return null
+    out[k] = val
+  }
+  return out
+}
+// The three generators are handed the same schema object for one validator,
+// so the rewrite is kept per object and done once. It walks the schema rather
+// than serializing it to look for the keyword: on a 7.6 MB schema the
+// serialization, three times over, was 3% of the first answer.
+const _pnNormalized = new WeakMap()
+function normalizePropertyNames(root) {
+  if (!root || typeof root !== 'object') return root
+  const hit = _pnNormalized.get(root)
+  if (hit !== undefined) return hit
+  const out = normalizePropertyNamesWalk(root)
+  _pnNormalized.set(root, out)
+  return out
+}
+function normalizePropertyNamesWalk(root) {
+  const defs = root.$defs || root.definitions || null
+  const seen = new Map()
+  const walk = (node) => {
+    if (node === null || typeof node !== 'object') return node
+    if (seen.has(node)) return seen.get(node)
+    seen.set(node, node)
+    if (Array.isArray(node)) {
+      let out = node
+      node.forEach((n, i) => { const w = walk(n); if (w !== n) { if (out === node) out = node.slice(); out[i] = w } })
+      seen.set(node, out)
+      return out
+    }
+    let out = node
+    const set = (k, v) => { if (out === node) out = { ...node }; out[k] = v }
+    for (const k of SUBSCHEMA_MAPS) {
+      const map = node[k]
+      if (!map || typeof map !== 'object') continue
+      let copy = map
+      for (const [name, sub] of Object.entries(map)) {
+        const w = walk(sub)
+        if (w !== sub) { if (copy === map) copy = { ...map }; copy[name] = w }
+      }
+      if (copy !== map) set(k, copy)
+    }
+    for (const k of SUBSCHEMA_LISTS) {
+      if (!Array.isArray(node[k])) continue
+      const w = walk(node[k])
+      if (w !== node[k]) set(k, w)
+    }
+    for (const k of SUBSCHEMA_SINGLES) {
+      if (k === 'propertyNames' || node[k] === null || typeof node[k] !== 'object') continue
+      const w = walk(node[k])
+      if (w !== node[k]) set(k, w)
+    }
+    if (node.propertyNames && typeof node.propertyNames === 'object') {
+      const simple = simplePropertyNames(node.propertyNames, defs)
+      if (simple && JSON.stringify(simple) !== JSON.stringify(node.propertyNames)) set('propertyNames', simple)
+    }
+    seen.set(node, out)
+    return out
+  }
+  return walk(root)
+}
+
 function compileToJSCodegen(schema, schemaMap, userFormats, opts) {
+  const inputSchema = schema
+  schema = normalizePropertyNames(schema)
   if (typeof schema === 'boolean') return schema ? () => true : () => false
   if (typeof schema !== 'object' || schema === null) return null
   // removeAdditional: a verdict function that deletes the keys the remover
@@ -1768,7 +1892,7 @@ function compileToJSCodegen(schema, schemaMap, userFormats, opts) {
   if (hasUnresolvableRef(schema, rootDefs, anchors, schemaMap, new Set())) return null
   if (needsBaseTracking(schema, schemaMap, new Set())) return null
 
-  const ctx = { varCounter: 0, helpers: [], helperCode: [], preamble: [], shared: [], closureVars: ['_cpLen'], closureVals: [_cpLen], rootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors, rootSchema: schema, userFormats: userFormats || null, removeNodes }
+  const ctx = { varCounter: 0, helpers: [], helperCode: [], preamble: [], shared: [], closureVars: ['_cpLen'], closureVals: [_cpLen], rootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors, rootSchema: inputSchema, userFormats: userFormats || null, removeNodes }
   const lines = []
   try {
     genCode(schema, 'd', lines, ctx)
@@ -3912,6 +4036,8 @@ function genCharCodeSwitch(keys, v) {
 // Returns a function: (data, allErrors) => { valid, errors }
 // Valid path is still fast — only error path does extra work.
 function compileToJSCodegenWithErrors(schema, schemaMap, userFormats, sourceOpts) {
+  const inputSchema = schema
+  schema = normalizePropertyNames(schema)
   // unevaluated* is generated only where it is provably its plain counterpart
   // (see unevalLocalOk); any occurrence that is not keeps the whole schema on
   // the interpreted engine's error path, exactly as before.
@@ -3974,7 +4100,7 @@ function compileToJSCodegenWithErrors(schema, schemaMap, userFormats, sourceOpts
   if (hasUnresolvableRef(schema, eRootDefs, eAnchors, schemaMap, new Set())) return null
   if (needsBaseTracking(schema, schemaMap, new Set())) return null
 
-  const ctx = { varCounter: 0, helperCode: [], rootDefs: eRootDefs, shared: [], refStack: new Set(), schemaMap: schemaMap || null, anchors: eAnchors, rootSchema: schema, userFormats: userFormats || null,
+  const ctx = { varCounter: 0, helperCode: [], rootDefs: eRootDefs, shared: [], refStack: new Set(), schemaMap: schemaMap || null, anchors: eAnchors, rootSchema: inputSchema, userFormats: userFormats || null,
                 // Custom format checkers referenced by the body, bound as
                 // closure parameters below the way the other entry points do.
                 closureVars: [], closureVals: [],
@@ -4159,16 +4285,26 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         if (!fnName) {
           fnName = '_defE' + ctx.defFns.size + '_' + defName.replace(/[^A-Za-z0-9_]/g, '_')
           ctx.defFns.set(defName, fnName)
+          // The schema path comes in as an argument too, `_sp`, so an error
+          // names the path it was reached by, as it does when the definition
+          // is inlined and as the interpreted engine reports it; a fixed
+          // `#/$defs/<name>` named the definition instead. The body is
+          // generated against a placeholder prefix that becomes `_sp` in every
+          // string it starts. One left anywhere else declines, rather than
+          // emitting a path the placeholder stands in for.
           const bodyLines = []
-          genCodeE(ctx.rootDefs[defName], 'd', '_p', bodyLines, ctx, '#/$defs/' + defName)
+          genCodeE(ctx.rootDefs[defName], 'd', '_p', bodyLines, ctx, SP_PLACEHOLDER)
+          let body = bodyLines.join('\n  ')
+          body = body.split(`'${SP_PLACEHOLDER}`).join(`_sp+'`).split(`"${SP_PLACEHOLDER}`).join(`_sp+"`)
+          if (body.includes(SP_PLACEHOLDER)) throw DECLINE
           ctx.helperCode.push(
-            `const ${fnName}_s=new Set()\n  function ${fnName}(d,_p,_all,_e){\n  ` +
-              `if(_sg){if(typeof d!=='object'||d===null)return ${fnName}_b(d,_p,_all,_e);if(${fnName}_s.has(d))return;${fnName}_s.add(d);try{return ${fnName}_b(d,_p,_all,_e)}finally{${fnName}_s.delete(d)}}\n  ` +
-              `if(++_sd>${CYCLE_DEPTH})throw _CYC\n  const _r=${fnName}_b(d,_p,_all,_e)\n  _sd--\n  return _r\n  }\n  ` +
-              `function ${fnName}_b(d,_p,_all,_e){${bodyLines.join('\n  ')}}`,
+            `const ${fnName}_s=new Set()\n  function ${fnName}(d,_p,_all,_e,_sp){\n  ` +
+              `if(_sg){if(typeof d!=='object'||d===null)return ${fnName}_b(d,_p,_all,_e,_sp);if(${fnName}_s.has(d))return;${fnName}_s.add(d);try{return ${fnName}_b(d,_p,_all,_e,_sp)}finally{${fnName}_s.delete(d)}}\n  ` +
+              `if(++_sd>${CYCLE_DEPTH})throw _CYC\n  const _r=${fnName}_b(d,_p,_all,_e,_sp)\n  _sd--\n  return _r\n  }\n  ` +
+              `function ${fnName}_b(d,_p,_all,_e,_sp){${body}}`,
           )
         }
-        lines.push(`${fnName}(${v},${pathExpr || '""'},_all,_e);if(!_all&&_e.length)return{valid:false,errors:_e}`)
+        lines.push(`${fnName}(${v},${pathExpr || '""'},_all,_e,'${schemaPrefix}');if(!_all&&_e.length)return{valid:false,errors:_e}`)
         return
       }
       if (ctx.refStack.has(schema.$ref)) return
@@ -4760,6 +4896,8 @@ function genIfE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
 // Avoids double-pass (jsFn → false → errFn runs same checks again).
 // Uses type-aware optimizations: after type check passes, skip guards.
 function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats) {
+  const inputSchema = schema
+  schema = normalizePropertyNames(schema)
   // Same provably-local rule as the error generator above.
   if (typeof schema === 'object' && schema !== null) {
     const s = JSON.stringify(schema)
@@ -4838,7 +4976,7 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats) {
   if (needsBaseTracking(schema, schemaMap, new Set())) return null
 
   const ctx = { varCounter: 0, helperCode: [], shared: [], closureVars: ['_cpLen'], closureVals: [_cpLen],
-                rootDefs: cRootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors: cAnchors, rootSchema: schema, userFormats: userFormats || null }
+                rootDefs: cRootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors: cAnchors, rootSchema: inputSchema, userFormats: userFormats || null }
   const lines = []
   try {
     genCodeC(schema, 'd', '', lines, ctx, '#')

package/lib/safe-regex-source.js

@@ -5,4 +5,4 @@
 // into standalone output without a runtime `fs` read. Kept in sync by
 // `tests/test_safe_regex_source_sync.js`.
 
-module.exports = "'use strict'\n\n// Linear-time regex engine for JSON Schema `pattern`, used in place of JS RegExp\n// so an adversarial input cannot trigger catastrophic backtracking (ReDoS).\n//\n// It is a Pike VM: the pattern compiles to a small instruction program, and the\n// VM simulates all NFA threads in lockstep over the input, deduping by program\n// counter. Runtime is O(input * program), with no backtracking.\n//\n// Supported (the RE2 subset, which is what ata's native path also accepts):\n// literals, ., character classes, \\d \\w \\s \\D \\W \\S, anchors ^ $, quantifiers\n// * + ? {n} {n,} {n,m} (greedy or lazy, same language for a boolean test),\n// groups ( ) (?: ), alternation |. Backreferences and lookaround are not\n// supported by linear engines; compileSafe throws on them so the caller can\n// decide (ata's codegen rejects such schemas rather than risk a hang).\n\nconst WS = [[9, 13], [32, 32], [160, 160]]\nconst DIGIT = [[48, 57]]\nconst WORD = [[48, 57], [65, 90], [97, 122], [95, 95]]\n\nfunction parse (src) {\n  let i = 0\n  const len = src.length\n  const peek = () => src[i]\n  const eof = () => i >= len\n\n  function parseAlt () {\n    const opts = [parseConcat()]\n    while (!eof() && peek() === '|') { i++; opts.push(parseConcat()) }\n    return opts.length === 1 ? opts[0] : { t: 'alt', opts }\n  }\n\n  function parseConcat () {\n    const parts = []\n    while (!eof() && peek() !== '|' && peek() !== ')') parts.push(parseRepeat())\n    if (parts.length === 0) return { t: 'empty' }\n    return parts.length === 1 ? parts[0] : { t: 'concat', parts }\n  }\n\n  function parseRepeat () {\n    let node = parseAtom()\n    while (!eof()) {\n      const ch = peek()\n      if (ch === '*') { i++; node = { t: 'star', child: node } }\n      else if (ch === '+') { i++; node = { t: 'plus', child: node } }\n      else if (ch === '?') { i++; node = { t: 'quest', child: node } }\n      else if (ch === '{') {\n        const saved = i\n        const q = tryQuantifier()\n        if (!q) { i = saved; break }\n        node = { t: 'repeat', child: node, min: q.min, max: q.max }\n      } else break\n      // a trailing ? makes the quantifier lazy; same language for a boolean test\n      if (!eof() && peek() === '?') i++\n    }\n    return node\n  }\n\n  function tryQuantifier () {\n    // assumes current char is '{'\n    i++\n    let min = ''\n    while (!eof() && /[0-9]/.test(peek())) { min += peek(); i++ }\n    if (min === '') return null\n    let max\n    if (peek() === '}') { i++; return { min: +min, max: +min } }\n    if (peek() === ',') {\n      i++\n      let m = ''\n      while (!eof() && /[0-9]/.test(peek())) { m += peek(); i++ }\n      if (peek() !== '}') return null\n      i++\n      max = m === '' ? Infinity : +m\n      return { min: +min, max }\n    }\n    return null\n  }\n\n  function parseAtom () {\n    const ch = peek()\n    if (ch === '(') {\n      i++\n      if (src[i] === '?') {\n        if (src[i + 1] === ':') { i += 2 }\n        else throw new Error('unsupported group (lookaround/named) in pattern')\n      }\n      const child = parseAlt()\n      if (peek() !== ')') throw new Error('unbalanced ( in pattern')\n      i++\n      return { t: 'group', child }\n    }\n    if (ch === '[') return parseClass()\n    if (ch === '.') { i++; return { t: 'any' } }\n    if (ch === '^') { i++; return { t: 'bol' } }\n    if (ch === '$') { i++; return { t: 'eol' } }\n    if (ch === '\\\\') return parseEscape(false)\n    if (ch === ')' || ch === '|') return { t: 'empty' }\n    i++\n    return { t: 'char', c: ch.charCodeAt(0) }\n  }\n\n  function parseClass () {\n    i++ // [\n    let neg = false\n    if (peek() === '^') { neg = true; i++ }\n    const ranges = []\n    while (!eof() && peek() !== ']') {\n      let lo\n      if (peek() === '\\\\') {\n        const esc = parseEscape(true)\n        if (esc.t === 'classpart') { for (const r of esc.ranges) ranges.push(r); continue }\n        lo = esc.c\n      } else { lo = peek().charCodeAt(0); i++ }\n      if (peek() === '-' && src[i + 1] !== ']' && i + 1 < len) {\n        i++ // -\n        let hi\n        if (peek() === '\\\\') { const e = parseEscape(true); hi = e.c } else { hi = peek().charCodeAt(0); i++ }\n        ranges.push([lo, hi])\n      } else {\n        ranges.push([lo, lo])\n      }\n    }\n    if (peek() !== ']') throw new Error('unbalanced [ in pattern')\n    i++\n    return { t: 'class', neg, ranges }\n  }\n\n  function parseEscape (inClass) {\n    i++ // backslash\n    if (eof()) throw new Error('trailing backslash in pattern')\n    const ch = peek(); i++\n    switch (ch) {\n      case 'd': return inClass ? { t: 'classpart', ranges: DIGIT } : { t: 'class', neg: false, ranges: DIGIT }\n      case 'w': return inClass ? { t: 'classpart', ranges: WORD } : { t: 'class', neg: false, ranges: WORD }\n      case 's': return inClass ? { t: 'classpart', ranges: WS } : { t: 'class', neg: false, ranges: WS }\n      case 'D': if (inClass) throw new Error('\\\\D inside a class is not supported'); return { t: 'class', neg: true, ranges: DIGIT }\n      case 'W': if (inClass) throw new Error('\\\\W inside a class is not supported'); return { t: 'class', neg: true, ranges: WORD }\n      case 'S': if (inClass) throw new Error('\\\\S inside a class is not supported'); return { t: 'class', neg: true, ranges: WS }\n      case 'n': return { t: 'char', c: 10 }\n      case 'r': return { t: 'char', c: 13 }\n      case 't': return { t: 'char', c: 9 }\n      case 'f': return { t: 'char', c: 12 }\n      case 'v': return { t: 'char', c: 11 }\n      case '0': return { t: 'char', c: 0 }\n      case 'x': { const h = src.slice(i, i + 2); i += 2; return { t: 'char', c: parseInt(h, 16) } }\n      case 'u': { const h = src.slice(i, i + 4); i += 4; return { t: 'char', c: parseInt(h, 16) } }\n      case 'b': if (inClass) return { t: 'char', c: 8 }; throw new Error('\\\\b word boundary is not supported')\n      default:\n        if (/[1-9]/.test(ch)) throw new Error('backreferences are not supported in pattern')\n        return { t: 'char', c: ch.charCodeAt(0) }\n    }\n  }\n\n  const ast = parseAlt()\n  if (!eof()) throw new Error('unexpected \"' + peek() + '\" in pattern')\n  return ast\n}\n\nfunction compileProg (ast) {\n  const prog = []\n  const emit = (op, extra) => { const idx = prog.length; prog.push(Object.assign({ op }, extra)); return idx }\n\n  function rec (n) {\n    switch (n.t) {\n      case 'empty': break\n      case 'char': emit('char', { c: n.c }); break\n      case 'any': emit('any'); break\n      case 'class': emit('class', { neg: n.neg, ranges: n.ranges }); break\n      case 'bol': emit('bol'); break\n      case 'eol': emit('eol'); break\n      case 'group': rec(n.child); break\n      case 'concat': for (const p of n.parts) rec(p); break\n      case 'alt': {\n        const jmps = []\n        for (let k = 0; k < n.opts.length; k++) {\n          if (k < n.opts.length - 1) {\n            const sp = emit('split', { x: 0, y: 0 })\n            prog[sp].x = prog.length\n            rec(n.opts[k])\n            jmps.push(emit('jmp', { x: 0 }))\n            prog[sp].y = prog.length\n          } else {\n            rec(n.opts[k])\n          }\n        }\n        for (const j of jmps) prog[j].x = prog.length\n        break\n      }\n      case 'star': {\n        const sp = emit('split', { x: 0, y: 0 })\n        prog[sp].x = prog.length\n        rec(n.child)\n        emit('jmp', { x: sp })\n        prog[sp].y = prog.length\n        break\n      }\n      case 'plus': {\n        const start = prog.length\n        rec(n.child)\n        const sp = emit('split', { x: start, y: 0 })\n        prog[sp].y = prog.length\n        break\n      }\n      case 'quest': {\n        const sp = emit('split', { x: 0, y: 0 })\n        prog[sp].x = prog.length\n        rec(n.child)\n        prog[sp].y = prog.length\n        break\n      }\n      case 'repeat': {\n        for (let k = 0; k < n.min; k++) rec(n.child)\n        if (n.max === Infinity) {\n          if (n.min === 0) rec({ t: 'star', child: n.child })\n          else rec({ t: 'star', child: n.child })\n        } else {\n          for (let k = 0; k < n.max - n.min; k++) rec({ t: 'quest', child: n.child })\n        }\n        break\n      }\n    }\n  }\n\n  rec(ast)\n  emit('match')\n  return prog\n}\n\n// Numeric opcodes for the runner. The program is compiled once into flat\n// typed arrays so the inner loop does no property lookups or string compares.\nconst OP_CHAR = 0\nconst OP_ANY = 1\nconst OP_CLASS = 2\nconst OP_SPLIT = 3\nconst OP_JMP = 4\nconst OP_BOL = 5\nconst OP_EOL = 6\nconst OP_MATCH = 7\n\nfunction classMatcher (instr) {\n  // ASCII is answered from a bitmap; anything above 0x7f walks the ranges.\n  const bits = new Uint8Array(128)\n  const r = instr.ranges\n  for (let k = 0; k < r.length; k++) {\n    const hi = Math.min(r[k][1], 127)\n    for (let c = r[k][0]; c <= hi; c++) bits[c] = 1\n  }\n  return { bits, ranges: r, neg: instr.neg }\n}\n\nfunction matchClass (cls, c) {\n  let inside\n  if (c < 128) {\n    inside = cls.bits[c] === 1\n  } else {\n    inside = false\n    const r = cls.ranges\n    for (let k = 0; k < r.length; k++) { if (c >= r[k][0] && c <= r[k][1]) { inside = true; break } }\n  }\n  return cls.neg ? !inside : inside\n}\n\nfunction makeRunner (prog) {\n  const n = prog.length\n  const ops = new Uint8Array(n)\n  const xs = new Int32Array(n)\n  const ys = new Int32Array(n)\n  const cs = new Int32Array(n)\n  const classes = new Array(n)\n  for (let i = 0; i < n; i++) {\n    const I = prog[i]\n    switch (I.op) {\n      case 'char': ops[i] = OP_CHAR; cs[i] = I.c; break\n      case 'any': ops[i] = OP_ANY; break\n      case 'class': ops[i] = OP_CLASS; classes[i] = classMatcher(I); break\n      case 'split': ops[i] = OP_SPLIT; xs[i] = I.x; ys[i] = I.y; break\n      case 'jmp': ops[i] = OP_JMP; xs[i] = I.x; break\n      case 'bol': ops[i] = OP_BOL; break\n      case 'eol': ops[i] = OP_EOL; break\n      case 'match': ops[i] = OP_MATCH; break\n    }\n  }\n\n  const lastGen = new Int32Array(n).fill(-1)\n  let gen = 0\n  // Each unvisited instruction is popped once and pushes at most two, so the\n  // stack never holds more than 2n + 1 entries.\n  const stack = new Int32Array(2 * n + 2)\n  // Thread lists hold at most one entry per instruction per step.\n  let clist = new Int32Array(n)\n  let nlist = new Int32Array(n)\n  let clen = 0\n  let nlen = 0\n\n  // Follows epsilon edges from `pc` and records every consuming instruction\n  // (or match) reached in `list`. `lastGen` dedupes per step.\n  function addThread (list, len0, pc, pos, len) {\n    // Most transitions land directly on a consuming instruction; skip the\n    // stack walk for those.\n    if (ops[pc] <= OP_CLASS || ops[pc] === OP_MATCH) {\n      if (lastGen[pc] === gen) return len0\n      lastGen[pc] = gen\n      list[len0] = pc\n      return len0 + 1\n    }\n    let sp = 0\n    stack[sp++] = pc\n    let count = len0\n    while (sp > 0) {\n      const p = stack[--sp]\n      if (lastGen[p] === gen) continue\n      lastGen[p] = gen\n      switch (ops[p]) {\n        case OP_JMP: stack[sp++] = xs[p]; break\n        case OP_SPLIT: stack[sp++] = ys[p]; stack[sp++] = xs[p]; break\n        case OP_BOL: if (pos === 0) stack[sp++] = p + 1; break\n        case OP_EOL: if (pos === len) stack[sp++] = p + 1; break\n        default: list[count++] = p\n      }\n    }\n    return count\n  }\n\n  // A pattern is anchored when starting it anywhere but position 0 yields no\n  // thread, which is the case for `^...` and its alternations. The probe sits\n  // at position 1 of a length-1 string so that only `^` can fail. For anchored\n  // patterns the per-position restart below is skipped, and an empty thread\n  // list means the match has already failed.\n  gen++\n  const anchored = addThread(nlist, 0, 0, 1, 1) === 0\n\n  function testNFA (s) {\n    const len = s.length\n    gen++\n    clen = addThread(clist, 0, 0, 0, len)\n    for (let pos = 0; pos <= len; pos++) {\n      const c = pos < len ? s.charCodeAt(pos) : -1\n      gen++\n      nlen = 0\n      for (let k = 0; k < clen; k++) {\n        const pc = clist[k]\n        switch (ops[pc]) {\n          case OP_MATCH: return true\n          case OP_CHAR: if (c === cs[pc]) nlen = addThread(nlist, nlen, pc + 1, pos + 1, len); break\n          case OP_ANY: if (c !== -1 && c !== 10) nlen = addThread(nlist, nlen, pc + 1, pos + 1, len); break\n          case OP_CLASS: if (c !== -1 && matchClass(classes[pc], c)) nlen = addThread(nlist, nlen, pc + 1, pos + 1, len); break\n        }\n      }\n      if (pos < len) {\n        if (!anchored) nlen = addThread(nlist, nlen, 0, pos + 1, len)\n        else if (nlen === 0) return false\n      }\n      const tmp = clist; clist = nlist; nlist = tmp\n      clen = nlen\n    }\n    return false\n  }\n\n  // Lazy DFA on top of the NFA. A DFA state is the set of consuming\n  // instructions live at a position; transitions are computed on first use\n  // and cached per ASCII character. `^` and `$` depend on position, so the\n  // closure is taken with flags for \"at start\" and \"at end\", which gives two\n  // start states and two transition tables per state. The state count is\n  // capped; past the cap the matcher falls back to the NFA walk above, so the\n  // time bound stays linear either way.\n  const MAX_STATES = 256\n  const states = []\n  const stateIds = new Map()\n  let overflow = false\n\n  function closure (list, count, pc, atStart, atEnd) {\n    // Same walk as addThread, with the position replaced by the two flags.\n    let sp = 0\n    stack[sp++] = pc\n    while (sp > 0) {\n      const p = stack[--sp]\n      if (lastGen[p] === gen) continue\n      lastGen[p] = gen\n      switch (ops[p]) {\n        case OP_JMP: stack[sp++] = xs[p]; break\n        case OP_SPLIT: stack[sp++] = ys[p]; stack[sp++] = xs[p]; break\n        case OP_BOL: if (atStart) stack[sp++] = p + 1; break\n        case OP_EOL: if (atEnd) stack[sp++] = p + 1; break\n        default: list[count++] = p\n      }\n    }\n    return count\n  }\n\n  function internState (list, count) {\n    const pcs = Array.from(list.subarray(0, count)).sort((a, b) => a - b)\n    const key = pcs.join(',')\n    let id = stateIds.get(key)\n    if (id !== undefined) return id\n    if (states.length >= MAX_STATES) { overflow = true; return -1 }\n    id = states.length\n    let isMatch = false\n    for (let k = 0; k < pcs.length; k++) if (ops[pcs[k]] === OP_MATCH) { isMatch = true; break }\n    states.push({ pcs: Int32Array.from(pcs), isMatch, next: new Int32Array(128).fill(-2), nextEnd: new Int32Array(128).fill(-2) })\n    stateIds.set(key, id)\n    return id\n  }\n\n  function step (state, c, atEnd) {\n    gen++\n    let count = 0\n    const pcs = state.pcs\n    for (let k = 0; k < pcs.length; k++) {\n      const pc = pcs[k]\n      switch (ops[pc]) {\n        case OP_CHAR: if (c === cs[pc]) count = closure(nlist, count, pc + 1, false, atEnd); break\n        case OP_ANY: if (c !== 10) count = closure(nlist, count, pc + 1, false, atEnd); break\n        case OP_CLASS: if (matchClass(classes[pc], c)) count = closure(nlist, count, pc + 1, false, atEnd); break\n      }\n    }\n    if (!anchored) count = closure(nlist, count, 0, false, atEnd)\n    return internState(nlist, count)\n  }\n\n  let startEmpty = -2\n  let startNonEmpty = -2\n\n  function startState (atEnd) {\n    gen++\n    const count = closure(nlist, 0, 0, true, atEnd)\n    return internState(nlist, count)\n  }\n\n  function testDFA (s) {\n    const len = s.length\n    let id\n    if (len === 0) {\n      if (startEmpty === -2) startEmpty = startState(true)\n      id = startEmpty\n    } else {\n      if (startNonEmpty === -2) startNonEmpty = startState(false)\n      id = startNonEmpty\n    }\n    if (id < 0) return testNFA(s)\n    let state = states[id]\n    for (let pos = 0; pos < len; pos++) {\n      if (state.isMatch) return true\n      const c = s.charCodeAt(pos)\n      const atEnd = pos + 1 === len\n      let nid\n      if (c < 128) {\n        const table = atEnd ? state.nextEnd : state.next\n        nid = table[c]\n        if (nid === -2) { nid = step(state, c, atEnd); table[c] = nid }\n      } else {\n        nid = step(state, c, atEnd)\n      }\n      if (nid < 0) return testNFA(s)\n      state = states[nid]\n      if (anchored && state.pcs.length === 0) return false\n    }\n    return state.isMatch\n  }\n\n  return function test (s) {\n    return overflow ? testNFA(s) : testDFA(s)\n  }\n}\n\nfunction compileSafe (pattern) {\n  const prog = compileProg(parse(pattern))\n  const runner = makeRunner(prog)\n  // `__ataSafe` brands the result so the standalone serializer can tell a safe\n  // matcher apart from a RegExp and emit `__ataSafeRe(source)` instead.\n  return { test: runner, source: pattern, __ataSafe: true }\n}\n\n// True when the linear engine can represent `src`. Used by the codegen to decide\n// between the safe matcher and a JS RegExp fallback for patterns outside the\n// supported (RE2) subset (backreferences, lookaround, etc.).\nfunction patternIsSafe (src) {\n  try { compileSafe(src); return true } catch { return false }\n}\n\nmodule.exports = { compileSafe, patternIsSafe }\n";
+module.exports = "'use strict'\n\n// Linear-time regex engine for JSON Schema `pattern`, used in place of JS RegExp\n// so an adversarial input cannot trigger catastrophic backtracking (ReDoS).\n//\n// It is a Pike VM: the pattern compiles to a small instruction program, and the\n// VM simulates all NFA threads in lockstep over the input, deduping by program\n// counter. Runtime is O(input * program), with no backtracking.\n//\n// Supported (the RE2 subset, which is what ata's native path also accepts):\n// literals, ., character classes, \\d \\w \\s \\D \\W \\S, anchors ^ $, quantifiers\n// * + ? {n} {n,} {n,m} (greedy or lazy, same language for a boolean test),\n// groups ( ) (?: ), alternation |. Backreferences and lookaround are not\n// supported by linear engines; compileSafe throws on them so the caller can\n// decide (ata's codegen rejects such schemas rather than risk a hang).\n\n// ECMA-262 WhiteSpace and LineTerminator, what `\\s` matches: tab, line feed,\n// vertical tab, form feed, carriage return, space, no-break space, the\n// Unicode space separators, the line and paragraph separators, and the byte\n// order mark. The set used to stop at U+00A0, so `^\\S+$` accepted a string\n// holding U+2028 or U+3000.\nconst WS = [[9, 13], [32, 32], [160, 160], [0x1680, 0x1680], [0x2000, 0x200a], [0x2028, 0x2029], [0x202f, 0x202f], [0x205f, 0x205f], [0x3000, 0x3000], [0xfeff, 0xfeff]]\n// `.` matches anything but a line terminator: LF, CR and U+2028/U+2029. It\n// excluded only LF, so `^.$` accepted \"\\r\".\nconst isLineTerminator = (c) => c === 10 || c === 13 || c === 0x2028 || c === 0x2029\nconst DIGIT = [[48, 57]]\nconst WORD = [[48, 57], [65, 90], [97, 122], [95, 95]]\n\nfunction parse (src) {\n  let i = 0\n  const len = src.length\n  const peek = () => src[i]\n  const eof = () => i >= len\n\n  function parseAlt () {\n    const opts = [parseConcat()]\n    while (!eof() && peek() === '|') { i++; opts.push(parseConcat()) }\n    return opts.length === 1 ? opts[0] : { t: 'alt', opts }\n  }\n\n  function parseConcat () {\n    const parts = []\n    while (!eof() && peek() !== '|' && peek() !== ')') parts.push(parseRepeat())\n    if (parts.length === 0) return { t: 'empty' }\n    return parts.length === 1 ? parts[0] : { t: 'concat', parts }\n  }\n\n  function parseRepeat () {\n    let node = parseAtom()\n    while (!eof()) {\n      const ch = peek()\n      if (ch === '*') { i++; node = { t: 'star', child: node } }\n      else if (ch === '+') { i++; node = { t: 'plus', child: node } }\n      else if (ch === '?') { i++; node = { t: 'quest', child: node } }\n      else if (ch === '{') {\n        const saved = i\n        const q = tryQuantifier()\n        if (!q) { i = saved; break }\n        node = { t: 'repeat', child: node, min: q.min, max: q.max }\n      } else break\n      // a trailing ? makes the quantifier lazy; same language for a boolean test\n      if (!eof() && peek() === '?') i++\n    }\n    return node\n  }\n\n  function tryQuantifier () {\n    // assumes current char is '{'\n    i++\n    let min = ''\n    while (!eof() && /[0-9]/.test(peek())) { min += peek(); i++ }\n    if (min === '') return null\n    let max\n    if (peek() === '}') { i++; return { min: +min, max: +min } }\n    if (peek() === ',') {\n      i++\n      let m = ''\n      while (!eof() && /[0-9]/.test(peek())) { m += peek(); i++ }\n      if (peek() !== '}') return null\n      i++\n      max = m === '' ? Infinity : +m\n      return { min: +min, max }\n    }\n    return null\n  }\n\n  function parseAtom () {\n    const ch = peek()\n    if (ch === '(') {\n      i++\n      if (src[i] === '?') {\n        if (src[i + 1] === ':') { i += 2 }\n        else throw new Error('unsupported group (lookaround/named) in pattern')\n      }\n      const child = parseAlt()\n      if (peek() !== ')') throw new Error('unbalanced ( in pattern')\n      i++\n      return { t: 'group', child }\n    }\n    if (ch === '[') return parseClass()\n    if (ch === '.') { i++; return { t: 'any' } }\n    if (ch === '^') { i++; return { t: 'bol' } }\n    if (ch === '$') { i++; return { t: 'eol' } }\n    if (ch === '\\\\') return parseEscape(false)\n    if (ch === ')' || ch === '|') return { t: 'empty' }\n    i++\n    return { t: 'char', c: ch.charCodeAt(0) }\n  }\n\n  function parseClass () {\n    i++ // [\n    let neg = false\n    if (peek() === '^') { neg = true; i++ }\n    const ranges = []\n    while (!eof() && peek() !== ']') {\n      let lo\n      if (peek() === '\\\\') {\n        const esc = parseEscape(true)\n        if (esc.t === 'classpart') { for (const r of esc.ranges) ranges.push(r); continue }\n        lo = esc.c\n      } else { lo = peek().charCodeAt(0); i++ }\n      if (peek() === '-' && src[i + 1] !== ']' && i + 1 < len) {\n        i++ // -\n        let hi\n        if (peek() === '\\\\') { const e = parseEscape(true); hi = e.c } else { hi = peek().charCodeAt(0); i++ }\n        ranges.push([lo, hi])\n      } else {\n        ranges.push([lo, lo])\n      }\n    }\n    if (peek() !== ']') throw new Error('unbalanced [ in pattern')\n    i++\n    return { t: 'class', neg, ranges }\n  }\n\n  function parseEscape (inClass) {\n    i++ // backslash\n    if (eof()) throw new Error('trailing backslash in pattern')\n    const ch = peek(); i++\n    switch (ch) {\n      case 'd': return inClass ? { t: 'classpart', ranges: DIGIT } : { t: 'class', neg: false, ranges: DIGIT }\n      case 'w': return inClass ? { t: 'classpart', ranges: WORD } : { t: 'class', neg: false, ranges: WORD }\n      case 's': return inClass ? { t: 'classpart', ranges: WS } : { t: 'class', neg: false, ranges: WS }\n      case 'D': if (inClass) throw new Error('\\\\D inside a class is not supported'); return { t: 'class', neg: true, ranges: DIGIT }\n      case 'W': if (inClass) throw new Error('\\\\W inside a class is not supported'); return { t: 'class', neg: true, ranges: WORD }\n      case 'S': if (inClass) throw new Error('\\\\S inside a class is not supported'); return { t: 'class', neg: true, ranges: WS }\n      case 'n': return { t: 'char', c: 10 }\n      case 'r': return { t: 'char', c: 13 }\n      case 't': return { t: 'char', c: 9 }\n      case 'f': return { t: 'char', c: 12 }\n      case 'v': return { t: 'char', c: 11 }\n      case '0': return { t: 'char', c: 0 }\n      case 'x': { const h = src.slice(i, i + 2); i += 2; return { t: 'char', c: parseInt(h, 16) } }\n      case 'u': { const h = src.slice(i, i + 4); i += 4; return { t: 'char', c: parseInt(h, 16) } }\n      case 'b': if (inClass) return { t: 'char', c: 8 }; throw new Error('\\\\b word boundary is not supported')\n      default:\n        if (/[1-9]/.test(ch)) throw new Error('backreferences are not supported in pattern')\n        return { t: 'char', c: ch.charCodeAt(0) }\n    }\n  }\n\n  const ast = parseAlt()\n  if (!eof()) throw new Error('unexpected \"' + peek() + '\" in pattern')\n  return ast\n}\n\nfunction compileProg (ast) {\n  const prog = []\n  const emit = (op, extra) => { const idx = prog.length; prog.push(Object.assign({ op }, extra)); return idx }\n\n  function rec (n) {\n    switch (n.t) {\n      case 'empty': break\n      case 'char': emit('char', { c: n.c }); break\n      case 'any': emit('any'); break\n      case 'class': emit('class', { neg: n.neg, ranges: n.ranges }); break\n      case 'bol': emit('bol'); break\n      case 'eol': emit('eol'); break\n      case 'group': rec(n.child); break\n      case 'concat': for (const p of n.parts) rec(p); break\n      case 'alt': {\n        const jmps = []\n        for (let k = 0; k < n.opts.length; k++) {\n          if (k < n.opts.length - 1) {\n            const sp = emit('split', { x: 0, y: 0 })\n            prog[sp].x = prog.length\n            rec(n.opts[k])\n            jmps.push(emit('jmp', { x: 0 }))\n            prog[sp].y = prog.length\n          } else {\n            rec(n.opts[k])\n          }\n        }\n        for (const j of jmps) prog[j].x = prog.length\n        break\n      }\n      case 'star': {\n        const sp = emit('split', { x: 0, y: 0 })\n        prog[sp].x = prog.length\n        rec(n.child)\n        emit('jmp', { x: sp })\n        prog[sp].y = prog.length\n        break\n      }\n      case 'plus': {\n        const start = prog.length\n        rec(n.child)\n        const sp = emit('split', { x: start, y: 0 })\n        prog[sp].y = prog.length\n        break\n      }\n      case 'quest': {\n        const sp = emit('split', { x: 0, y: 0 })\n        prog[sp].x = prog.length\n        rec(n.child)\n        prog[sp].y = prog.length\n        break\n      }\n      case 'repeat': {\n        for (let k = 0; k < n.min; k++) rec(n.child)\n        if (n.max === Infinity) {\n          if (n.min === 0) rec({ t: 'star', child: n.child })\n          else rec({ t: 'star', child: n.child })\n        } else {\n          for (let k = 0; k < n.max - n.min; k++) rec({ t: 'quest', child: n.child })\n        }\n        break\n      }\n    }\n  }\n\n  rec(ast)\n  emit('match')\n  return prog\n}\n\n// Numeric opcodes for the runner. The program is compiled once into flat\n// typed arrays so the inner loop does no property lookups or string compares.\nconst OP_CHAR = 0\nconst OP_ANY = 1\nconst OP_CLASS = 2\nconst OP_SPLIT = 3\nconst OP_JMP = 4\nconst OP_BOL = 5\nconst OP_EOL = 6\nconst OP_MATCH = 7\n\nfunction classMatcher (instr) {\n  // ASCII is answered from a bitmap; anything above 0x7f walks the ranges.\n  const bits = new Uint8Array(128)\n  const r = instr.ranges\n  for (let k = 0; k < r.length; k++) {\n    const hi = Math.min(r[k][1], 127)\n    for (let c = r[k][0]; c <= hi; c++) bits[c] = 1\n  }\n  return { bits, ranges: r, neg: instr.neg }\n}\n\nfunction matchClass (cls, c) {\n  let inside\n  if (c < 128) {\n    inside = cls.bits[c] === 1\n  } else {\n    inside = false\n    const r = cls.ranges\n    for (let k = 0; k < r.length; k++) { if (c >= r[k][0] && c <= r[k][1]) { inside = true; break } }\n  }\n  return cls.neg ? !inside : inside\n}\n\nfunction makeRunner (prog) {\n  const n = prog.length\n  const ops = new Uint8Array(n)\n  const xs = new Int32Array(n)\n  const ys = new Int32Array(n)\n  const cs = new Int32Array(n)\n  const classes = new Array(n)\n  for (let i = 0; i < n; i++) {\n    const I = prog[i]\n    switch (I.op) {\n      case 'char': ops[i] = OP_CHAR; cs[i] = I.c; break\n      case 'any': ops[i] = OP_ANY; break\n      case 'class': ops[i] = OP_CLASS; classes[i] = classMatcher(I); break\n      case 'split': ops[i] = OP_SPLIT; xs[i] = I.x; ys[i] = I.y; break\n      case 'jmp': ops[i] = OP_JMP; xs[i] = I.x; break\n      case 'bol': ops[i] = OP_BOL; break\n      case 'eol': ops[i] = OP_EOL; break\n      case 'match': ops[i] = OP_MATCH; break\n    }\n  }\n\n  const lastGen = new Int32Array(n).fill(-1)\n  let gen = 0\n  // Each unvisited instruction is popped once and pushes at most two, so the\n  // stack never holds more than 2n + 1 entries.\n  const stack = new Int32Array(2 * n + 2)\n  // Thread lists hold at most one entry per instruction per step.\n  let clist = new Int32Array(n)\n  let nlist = new Int32Array(n)\n  let clen = 0\n  let nlen = 0\n\n  // Follows epsilon edges from `pc` and records every consuming instruction\n  // (or match) reached in `list`. `lastGen` dedupes per step.\n  function addThread (list, len0, pc, pos, len) {\n    // Most transitions land directly on a consuming instruction; skip the\n    // stack walk for those.\n    if (ops[pc] <= OP_CLASS || ops[pc] === OP_MATCH) {\n      if (lastGen[pc] === gen) return len0\n      lastGen[pc] = gen\n      list[len0] = pc\n      return len0 + 1\n    }\n    let sp = 0\n    stack[sp++] = pc\n    let count = len0\n    while (sp > 0) {\n      const p = stack[--sp]\n      if (lastGen[p] === gen) continue\n      lastGen[p] = gen\n      switch (ops[p]) {\n        case OP_JMP: stack[sp++] = xs[p]; break\n        case OP_SPLIT: stack[sp++] = ys[p]; stack[sp++] = xs[p]; break\n        case OP_BOL: if (pos === 0) stack[sp++] = p + 1; break\n        case OP_EOL: if (pos === len) stack[sp++] = p + 1; break\n        default: list[count++] = p\n      }\n    }\n    return count\n  }\n\n  // A pattern is anchored when starting it anywhere but position 0 yields no\n  // thread, which is the case for `^...` and its alternations. The probe sits\n  // at position 1 of a length-1 string so that only `^` can fail. For anchored\n  // patterns the per-position restart below is skipped, and an empty thread\n  // list means the match has already failed.\n  gen++\n  const anchored = addThread(nlist, 0, 0, 1, 1) === 0\n\n  function testNFA (s) {\n    const len = s.length\n    gen++\n    clen = addThread(clist, 0, 0, 0, len)\n    for (let pos = 0; pos <= len; pos++) {\n      const c = pos < len ? s.charCodeAt(pos) : -1\n      gen++\n      nlen = 0\n      for (let k = 0; k < clen; k++) {\n        const pc = clist[k]\n        switch (ops[pc]) {\n          case OP_MATCH: return true\n          case OP_CHAR: if (c === cs[pc]) nlen = addThread(nlist, nlen, pc + 1, pos + 1, len); break\n          case OP_ANY: if (c !== -1 && !isLineTerminator(c)) nlen = addThread(nlist, nlen, pc + 1, pos + 1, len); break\n          case OP_CLASS: if (c !== -1 && matchClass(classes[pc], c)) nlen = addThread(nlist, nlen, pc + 1, pos + 1, len); break\n        }\n      }\n      if (pos < len) {\n        if (!anchored) nlen = addThread(nlist, nlen, 0, pos + 1, len)\n        else if (nlen === 0) return false\n      }\n      const tmp = clist; clist = nlist; nlist = tmp\n      clen = nlen\n    }\n    return false\n  }\n\n  // Lazy DFA on top of the NFA. A DFA state is the set of consuming\n  // instructions live at a position; transitions are computed on first use\n  // and cached per ASCII character. `^` and `$` depend on position, so the\n  // closure is taken with flags for \"at start\" and \"at end\", which gives two\n  // start states and two transition tables per state. The state count is\n  // capped; past the cap the matcher falls back to the NFA walk above, so the\n  // time bound stays linear either way.\n  const MAX_STATES = 256\n  const states = []\n  const stateIds = new Map()\n  let overflow = false\n\n  function closure (list, count, pc, atStart, atEnd) {\n    // Same walk as addThread, with the position replaced by the two flags.\n    let sp = 0\n    stack[sp++] = pc\n    while (sp > 0) {\n      const p = stack[--sp]\n      if (lastGen[p] === gen) continue\n      lastGen[p] = gen\n      switch (ops[p]) {\n        case OP_JMP: stack[sp++] = xs[p]; break\n        case OP_SPLIT: stack[sp++] = ys[p]; stack[sp++] = xs[p]; break\n        case OP_BOL: if (atStart) stack[sp++] = p + 1; break\n        case OP_EOL: if (atEnd) stack[sp++] = p + 1; break\n        default: list[count++] = p\n      }\n    }\n    return count\n  }\n\n  function internState (list, count) {\n    const pcs = Array.from(list.subarray(0, count)).sort((a, b) => a - b)\n    const key = pcs.join(',')\n    let id = stateIds.get(key)\n    if (id !== undefined) return id\n    if (states.length >= MAX_STATES) { overflow = true; return -1 }\n    id = states.length\n    let isMatch = false\n    for (let k = 0; k < pcs.length; k++) if (ops[pcs[k]] === OP_MATCH) { isMatch = true; break }\n    states.push({ pcs: Int32Array.from(pcs), isMatch, next: new Int32Array(128).fill(-2), nextEnd: new Int32Array(128).fill(-2) })\n    stateIds.set(key, id)\n    return id\n  }\n\n  function step (state, c, atEnd) {\n    gen++\n    let count = 0\n    const pcs = state.pcs\n    for (let k = 0; k < pcs.length; k++) {\n      const pc = pcs[k]\n      switch (ops[pc]) {\n        case OP_CHAR: if (c === cs[pc]) count = closure(nlist, count, pc + 1, false, atEnd); break\n        case OP_ANY: if (!isLineTerminator(c)) count = closure(nlist, count, pc + 1, false, atEnd); break\n        case OP_CLASS: if (matchClass(classes[pc], c)) count = closure(nlist, count, pc + 1, false, atEnd); break\n      }\n    }\n    if (!anchored) count = closure(nlist, count, 0, false, atEnd)\n    return internState(nlist, count)\n  }\n\n  let startEmpty = -2\n  let startNonEmpty = -2\n\n  function startState (atEnd) {\n    gen++\n    const count = closure(nlist, 0, 0, true, atEnd)\n    return internState(nlist, count)\n  }\n\n  function testDFA (s) {\n    const len = s.length\n    let id\n    if (len === 0) {\n      if (startEmpty === -2) startEmpty = startState(true)\n      id = startEmpty\n    } else {\n      if (startNonEmpty === -2) startNonEmpty = startState(false)\n      id = startNonEmpty\n    }\n    if (id < 0) return testNFA(s)\n    let state = states[id]\n    for (let pos = 0; pos < len; pos++) {\n      if (state.isMatch) return true\n      const c = s.charCodeAt(pos)\n      const atEnd = pos + 1 === len\n      let nid\n      if (c < 128) {\n        const table = atEnd ? state.nextEnd : state.next\n        nid = table[c]\n        if (nid === -2) { nid = step(state, c, atEnd); table[c] = nid }\n      } else {\n        nid = step(state, c, atEnd)\n      }\n      if (nid < 0) return testNFA(s)\n      state = states[nid]\n      if (anchored && state.pcs.length === 0) return false\n    }\n    return state.isMatch\n  }\n\n  return function test (s) {\n    return overflow ? testNFA(s) : testDFA(s)\n  }\n}\n\nfunction compileSafe (pattern) {\n  const prog = compileProg(parse(pattern))\n  const runner = makeRunner(prog)\n  // `__ataSafe` brands the result so the standalone serializer can tell a safe\n  // matcher apart from a RegExp and emit `__ataSafeRe(source)` instead.\n  return { test: runner, source: pattern, __ataSafe: true }\n}\n\n// True when the linear engine can represent `src`. Used by the codegen to decide\n// between the safe matcher and a JS RegExp fallback for patterns outside the\n// supported (RE2) subset (backreferences, lookaround, etc.).\nfunction patternIsSafe (src) {\n  try { compileSafe(src); return true } catch { return false }\n}\n\nmodule.exports = { compileSafe, patternIsSafe }\n";

package/lib/safe-regex.js

@@ -14,7 +14,15 @@
 // supported by linear engines; compileSafe throws on them so the caller can
 // decide (ata's codegen rejects such schemas rather than risk a hang).
 
-const WS = [[9, 13], [32, 32], [160, 160]]
+// ECMA-262 WhiteSpace and LineTerminator, what `\s` matches: tab, line feed,
+// vertical tab, form feed, carriage return, space, no-break space, the
+// Unicode space separators, the line and paragraph separators, and the byte
+// order mark. The set used to stop at U+00A0, so `^\S+$` accepted a string
+// holding U+2028 or U+3000.
+const WS = [[9, 13], [32, 32], [160, 160], [0x1680, 0x1680], [0x2000, 0x200a], [0x2028, 0x2029], [0x202f, 0x202f], [0x205f, 0x205f], [0x3000, 0x3000], [0xfeff, 0xfeff]]
+// `.` matches anything but a line terminator: LF, CR and U+2028/U+2029. It
+// excluded only LF, so `^.$` accepted "\r".
+const isLineTerminator = (c) => c === 10 || c === 13 || c === 0x2028 || c === 0x2029
 const DIGIT = [[48, 57]]
 const WORD = [[48, 57], [65, 90], [97, 122], [95, 95]]
 
@@ -342,7 +350,7 @@ function makeRunner (prog) {
         switch (ops[pc]) {
           case OP_MATCH: return true
           case OP_CHAR: if (c === cs[pc]) nlen = addThread(nlist, nlen, pc + 1, pos + 1, len); break
-          case OP_ANY: if (c !== -1 && c !== 10) nlen = addThread(nlist, nlen, pc + 1, pos + 1, len); break
+          case OP_ANY: if (c !== -1 && !isLineTerminator(c)) nlen = addThread(nlist, nlen, pc + 1, pos + 1, len); break
           case OP_CLASS: if (c !== -1 && matchClass(classes[pc], c)) nlen = addThread(nlist, nlen, pc + 1, pos + 1, len); break
         }
       }
@@ -409,7 +417,7 @@ function makeRunner (prog) {
       const pc = pcs[k]
       switch (ops[pc]) {
         case OP_CHAR: if (c === cs[pc]) count = closure(nlist, count, pc + 1, false, atEnd); break
-        case OP_ANY: if (c !== 10) count = closure(nlist, count, pc + 1, false, atEnd); break
+        case OP_ANY: if (!isLineTerminator(c)) count = closure(nlist, count, pc + 1, false, atEnd); break
         case OP_CLASS: if (matchClass(classes[pc], c)) count = closure(nlist, count, pc + 1, false, atEnd); break
       }
     }

package/lib/validator-core.js

@@ -1471,6 +1471,7 @@ class Validator {
       value: Object.freeze({
         version: 1,
         vendor: "ata-validator",
+        jsonSchema: standardJsonSchema(() => schemaObj),
         validate(value) {
           const result = v.validate(value);
           if (result.valid) return { value };
@@ -1612,6 +1613,31 @@ function defineSchema (schema) {
 // bound closure, stores it on the instance as an ordinary writable property
 // and returns it. The setter keeps the compile step's plain assignments
 // (`this.validate = fn`) working before the getter has ever run. Detached
+// Standard JSON Schema, the `jsonSchema` member of `~standard`: what a consumer
+// such as the MCP SDK reads to publish a schema, from `input({ target })`.
+// ata validates the JSON Schema it was given and does not transform values, so
+// input and output are the same document, handed back as a copy when the
+// target is the schema's dialect: draft-07 when it declares draft-07, 2020-12
+// when it declares 2020-12 or nothing, as ata reads it. Any other target
+// throws, as the specification asks, rather than returning a document that
+// would mean something else there.
+function standardJsonSchema(getSchema) {
+  const convert = (options) => {
+    const target = options && options.target;
+    const schema = getSchema();
+    if (schema === true) return {};
+    if (schema === false) return { not: {} };
+    const declared = typeof schema.$schema === 'string' ? schema.$schema : '';
+    const dialect = declared === '' || declared.includes('draft/2020-12/schema') ? 'draft-2020-12'
+      : declared.includes('draft-07/schema') ? 'draft-07' : declared;
+    if (target !== dialect) {
+      throw new TypeError(`ata-validator cannot provide a ${dialect} schema as ${String(target)}; it does not convert between dialects`);
+    }
+    return JSON.parse(JSON.stringify(schema));
+  };
+  return Object.freeze({ input: convert, output: convert });
+}
+
 // use (`const f = v.validate`) keeps working because the closure binds the
 // instance.
 // Standard Schema V1. Built on first read, then pinned to the instance with
@@ -1623,6 +1649,7 @@ Object.defineProperty(Validator.prototype, "~standard", {
     const std = Object.freeze({
       version: 1,
       vendor: "ata-validator",
+      jsonSchema: standardJsonSchema(() => self._rawSchema),
       validate(value) {
         const result = self.validate(value);
         if (result.valid) {

package/lib/version.js

@@ -7,4 +7,4 @@
 //
 // Kept in lockstep with package.json by `tests/test_version_sync.js`.
 
-module.exports = '1.36.1';
+module.exports = '1.37.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.36.1",
+  "version": "1.37.1",
   "description": "JSON Schema validation that compiles for speed and still runs where code generation is blocked. Compiled and interpreted engines answer identically at 100% of the official suite. TypeScript inference, Standard Schema V1, and a build step that emits dependency-free modules.",
   "main": "index.js",
   "module": "index.mjs",
@@ -59,7 +59,7 @@
     "release:check": "node scripts/regen-safe-regex-source.js && node tests/test_pack_purity.js && node scripts/check-doc-coverage.js && node tests/test_error_codes_lock.js && node tests/test_safe_regex_source_sync.js && node tests/test_version_sync.js",
     "build": "cmake-js build --target ata",
     "rebuild": "cmake-js rebuild --target ata",
-    "test": "node test.js && node tests/test_removed_aot_methods.js && node tests/test_no_native.js && node tests/test_no_eval.js && node tests/test_property_dependencies.js && node tests/test_v1_dialect.js && node tests/test_buffer_path_parity.js && node tests/test_text_path_errors.js && node tests/test_compiled_parity.js && node tests/test_buffer_gate.js && node tests/test_scanner_differential.js && node tests/test_validate_json_scanner_cost.js && node tests/test_buffer_reject_cost.js && node tests/test_nan_verdict.js && node tests/test_remove_additional_nested.js && node tests/test_exclusive_bounds.js && node tests/test_engine_differential.js && node tests/test_error_shape_differential.js && node tests/test_output_format.js && node tests/test_retry_message.js && node tests/test_describe_schema.js && node tests/test_aot_parse.js && node tests/test_draft7_semantics.js && node tests/test_metaschema_ref.js && node tests/test_pure_js_unsupported.js && node tests/test_native_load_order.js && node tests/test_pack_purity.js && node tests/test_make_native_package.js && node tests/test_browser_nofs.js && node tests/test_browser_imports_guard.js && node tests/test_esm_exports.js && node tests/test_version_sync.js && node tests/test_native_loaded.js && node tests/test_native_lazy.js && node tests/test_cold_start_modules.js && node tests/test_safe_regex_source_sync.js && node tests/test_t_builder.js && node tests/test_async_refine.js && node tests/test_safe_regex.js && node tests/test_safe_regex_integration.js && node tests/test_aot_build.js && node tests/test_aot_differential.js && node tests/test_aot_cli_build.js && node tests/test_aot_cli_smoke.js && node tests/test_bundle_standalone.js && node tests/test_standalone_anyof.js && node tests/test_standalone_formats.js && node tests/test_aot_format_mode.js && node tests/test_aot_additional_props_errors.js && node tests/test_id_anchor_refs.js && node tests/test_engine_routing.js && node tests/test_engine_option.js && node tests/test_compile_cache_order.js && node tests/test_engine_diagnostic.js && node tests/test_format_engine_parity.js && node tests/test_error_accumulator_collision.js && node tests/test_uri_helper_parity.js && node tests/test_uri_fast_path.js && node tests/test_extend_verdict.js && node tests/test_ipv4_regex.js && node tests/test_ipv6_fast_path.js && node tests/test_nested_recursion_decline.js && node tests/test_generator_error_content.js && node tests/test_inherited_key_presence.js && node tests/test_proto_accessor.js && node tests/test_hybrid_tier.js && node tests/test_first_rejection_builds_one.js && node tests/test_container_local.js && node tests/test_one_shot_validate.js && node tests/test_fixed_pattern_inline.js && node tests/test_plan_source.js && node tests/test_fused_remove_additional.js && node tests/test_runtime_parse.js && node tests/test_formats_single_pass.js && node tests/test_email_format_cost.js && node tests/test_format_single_error.js && node tests/test_defs_pointer_alias.js && node tests/test_cross_doc_root_ref.js && node tests/test_codegen_entrypoint_agreement.js && node tests/test_ref_annotation_siblings.js && node tests/test_gate_wrapped_schemas.js && node tests/test_pattern_message_escape.js && node tests/test_nested_defaults_engines.js && node tests/test_nested_coercion_parity.js && node tests/test_preprocess_cache.js && node tests/test_large_schema_codegen.js && node tests/test_base_uri.js && node tests/test_hoisted_def_recursion.js && node tests/test_hybrid_agreement.js && node tests/test_codegen_edge_shapes.js && node tests/test_deferred_def_scope.js && node tests/test_node_scoped_ctx_flags.js && node tests/test_fast_slot_exhaustion.js && node tests/test_ajv_errors.js && node tests/test_custom_keywords.js && node tests/test_strict_schema.js && node tests/test_aot_external_checks.js && node tests/test_ajv_parity.js && node tests/test_user_format_error_path.js && node tests/test_unevaluated_error_path.js && node tests/test_unevaluated_error_shape.js && node tests/test_pattern_properties_errors.js && node tests/test_additional_properties_scaling.js && node tests/test_additional_props_combined_cost.js && node tests/test_no_input_mutation.js && node tests/test_typed_validator_runner.js && node tests/test_define_schema.js && node tests/test_error_codes_lock.js && node tests/test_error_code_lookup.js && node tests/test_error_order.js && node tests/test_error_order_ordinal.js && node tests/test_ref_error_order.js && node tests/test_rejection_shape.js && node tests/test_lazy_normalization.js && node tests/test_value_equality.js && node tests/test_vocabulary.js && node tests/test_schema_scan.js && node tests/test_lazy_errors.js && node tests/test_single_pass_errors.js && node tests/test_lazy_json_errors.js && node tests/test_lazy_instance.js && node tests/test_cyclic_input.js && node tests/test_native_error_codes.js && node tests/test_verdict_preprocess.js && node tests/test_lite_parity.js && node tests/test_lite_bundle_size.js && node tests/test_defaults_own_keys.js && node tests/test_plan_compiler.js && node tests/test_nullable.js && node tests/test_validate_and_parse.js && node tests/test_validate_data.js && node tests/test_enrich_error.js && node tests/test_enrich_received.js && node tests/test_rich_errors_optout.js && node tests/test_error_messages.js && node tests/test_source_positions.js && node tests/fuzz_positions.js && node tests/test_malformed_json_termination.js && node tests/test_data_positions.js && node tests/test_targeted_positions.js && node tests/test_position_map_cost.js && node tests/test_targeted_positions_cost.js && node tests/test_aot_staleness.js && node tests/test_file_positions.js && node tests/test_aot_positions_cost.js && node tests/test_schema_hash.js && node tests/test_render_shared.js && node tests/test_renderers.js && node tests/test_additive_fields.js && node tests/test_diagnostic_source.js && node tests/test_diagnose.js && node tests/test_correlate.js && node tests/test_diagnostics_score.js && node tests/test_runtime_error_dx.js && node tests/test_aot_error_dx.js && node tests/test_abort_early.js && node tests/test_branch_collapse.js && node tests/test_suggestions.js && node tests/test_cli_validate.js && node tests/test_cli_version.js && node benchmark/bench_aot_size.mjs",
+    "test": "node test.js && node tests/test_removed_aot_methods.js && node tests/test_no_native.js && node tests/test_no_eval.js && node tests/test_property_dependencies.js && node tests/test_v1_dialect.js && node tests/test_buffer_path_parity.js && node tests/test_text_path_errors.js && node tests/test_compiled_parity.js && node tests/test_buffer_gate.js && node tests/test_scanner_differential.js && node tests/test_validate_json_scanner_cost.js && node tests/test_buffer_reject_cost.js && node tests/test_nan_verdict.js && node tests/test_remove_additional_nested.js && node tests/test_exclusive_bounds.js && node tests/test_engine_differential.js && node tests/test_error_shape_differential.js && node tests/test_output_format.js && node tests/test_standard_json_schema.js && node tests/test_retry_message.js && node tests/test_describe_schema.js && node tests/test_aot_parse.js && node tests/test_draft7_semantics.js && node tests/test_metaschema_ref.js && node tests/test_pure_js_unsupported.js && node tests/test_native_load_order.js && node tests/test_pack_purity.js && node tests/test_make_native_package.js && node tests/test_browser_nofs.js && node tests/test_browser_imports_guard.js && node tests/test_esm_exports.js && node tests/test_version_sync.js && node tests/test_native_loaded.js && node tests/test_native_lazy.js && node tests/test_cold_start_modules.js && node tests/test_safe_regex_source_sync.js && node tests/test_t_builder.js && node tests/test_async_refine.js && node tests/test_safe_regex.js && node tests/test_safe_regex_integration.js && node tests/test_regex_ecma_whitespace.js && node tests/test_aot_build.js && node tests/test_aot_differential.js && node tests/test_aot_cli_build.js && node tests/test_aot_cli_smoke.js && node tests/test_bundle_standalone.js && node tests/test_standalone_anyof.js && node tests/test_standalone_formats.js && node tests/test_aot_format_mode.js && node tests/test_aot_additional_props_errors.js && node tests/test_id_anchor_refs.js && node tests/test_engine_routing.js && node tests/test_engine_option.js && node tests/test_compile_cache_order.js && node tests/test_engine_diagnostic.js && node tests/test_format_engine_parity.js && node tests/test_error_accumulator_collision.js && node tests/test_uri_helper_parity.js && node tests/test_uri_fast_path.js && node tests/test_extend_verdict.js && node tests/test_ipv4_regex.js && node tests/test_ipv6_fast_path.js && node tests/test_nested_recursion_decline.js && node tests/test_generator_error_content.js && node tests/test_inherited_key_presence.js && node tests/test_proto_accessor.js && node tests/test_hybrid_tier.js && node tests/test_first_rejection_builds_one.js && node tests/test_container_local.js && node tests/test_one_shot_validate.js && node tests/test_fixed_pattern_inline.js && node tests/test_plan_source.js && node tests/test_fused_remove_additional.js && node tests/test_runtime_parse.js && node tests/test_formats_single_pass.js && node tests/test_email_format_cost.js && node tests/test_format_single_error.js && node tests/test_defs_pointer_alias.js && node tests/test_cross_doc_root_ref.js && node tests/test_codegen_entrypoint_agreement.js && node tests/test_ref_annotation_siblings.js && node tests/test_gate_wrapped_schemas.js && node tests/test_pattern_message_escape.js && node tests/test_nested_defaults_engines.js && node tests/test_nested_coercion_parity.js && node tests/test_preprocess_cache.js && node tests/test_large_schema_codegen.js && node tests/test_base_uri.js && node tests/test_hoisted_def_recursion.js && node tests/test_alias_definitions.js && node tests/test_property_names_ref.js && node tests/test_hybrid_agreement.js && node tests/test_codegen_edge_shapes.js && node tests/test_deferred_def_scope.js && node tests/test_node_scoped_ctx_flags.js && node tests/test_fast_slot_exhaustion.js && node tests/test_ajv_errors.js && node tests/test_custom_keywords.js && node tests/test_strict_schema.js && node tests/test_aot_external_checks.js && node tests/test_ajv_parity.js && node tests/test_user_format_error_path.js && node tests/test_unevaluated_error_path.js && node tests/test_unevaluated_error_shape.js && node tests/test_pattern_properties_errors.js && node tests/test_additional_properties_scaling.js && node tests/test_additional_props_combined_cost.js && node tests/test_no_input_mutation.js && node tests/test_typed_validator_runner.js && node tests/test_define_schema.js && node tests/test_error_codes_lock.js && node tests/test_error_code_lookup.js && node tests/test_error_order.js && node tests/test_error_order_ordinal.js && node tests/test_ref_error_order.js && node tests/test_rejection_shape.js && node tests/test_lazy_normalization.js && node tests/test_value_equality.js && node tests/test_vocabulary.js && node tests/test_schema_scan.js && node tests/test_lazy_errors.js && node tests/test_single_pass_errors.js && node tests/test_lazy_json_errors.js && node tests/test_lazy_instance.js && node tests/test_cyclic_input.js && node tests/test_native_error_codes.js && node tests/test_verdict_preprocess.js && node tests/test_lite_parity.js && node tests/test_lite_bundle_size.js && node tests/test_defaults_own_keys.js && node tests/test_plan_compiler.js && node tests/test_nullable.js && node tests/test_validate_and_parse.js && node tests/test_validate_data.js && node tests/test_enrich_error.js && node tests/test_enrich_received.js && node tests/test_rich_errors_optout.js && node tests/test_error_messages.js && node tests/test_source_positions.js && node tests/fuzz_positions.js && node tests/test_malformed_json_termination.js && node tests/test_data_positions.js && node tests/test_targeted_positions.js && node tests/test_position_map_cost.js && node tests/test_targeted_positions_cost.js && node tests/test_aot_staleness.js && node tests/test_file_positions.js && node tests/test_aot_positions_cost.js && node tests/test_schema_hash.js && node tests/test_render_shared.js && node tests/test_renderers.js && node tests/test_additive_fields.js && node tests/test_diagnostic_source.js && node tests/test_diagnose.js && node tests/test_correlate.js && node tests/test_diagnostics_score.js && node tests/test_runtime_error_dx.js && node tests/test_aot_error_dx.js && node tests/test_abort_early.js && node tests/test_branch_collapse.js && node tests/test_suggestions.js && node tests/test_cli_validate.js && node tests/test_cli_version.js && node benchmark/bench_aot_size.mjs",
     "bench:size": "node benchmark/bench_aot_size.mjs",
     "test:suite": "node tests/run_suite.js && node tests/run_suite.js draft7 && node tests/run_suite.js v1",
     "test:compat": "node tests/test_compat.js",
@@ -117,6 +117,7 @@
     "aot.mjs",
     "aot.d.ts",
     "lib/",
+    "!lib/plan-source.js",
     "compat.js",
     "compat.mjs",
     "compat.d.ts",
@@ -134,13 +135,13 @@
     "LICENSE"
   ],
   "optionalDependencies": {
-    "@ata-validator/native-darwin-arm64": "1.36.1",
-    "@ata-validator/native-darwin-x64": "1.36.1",
-    "@ata-validator/native-linux-arm64-gnu": "1.36.1",
-    "@ata-validator/native-linux-arm64-musl": "1.36.1",
-    "@ata-validator/native-linux-x64-gnu": "1.36.1",
-    "@ata-validator/native-linux-x64-musl": "1.36.1",
-    "@ata-validator/native-win32-x64": "1.36.1"
+    "@ata-validator/native-darwin-arm64": "1.37.1",
+    "@ata-validator/native-darwin-x64": "1.37.1",
+    "@ata-validator/native-linux-arm64-gnu": "1.37.1",
+    "@ata-validator/native-linux-arm64-musl": "1.37.1",
+    "@ata-validator/native-linux-x64-gnu": "1.37.1",
+    "@ata-validator/native-linux-x64-musl": "1.37.1",
+    "@ata-validator/native-win32-x64": "1.37.1"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"

package/lib/plan-source.js

@@ -1,281 +0,0 @@
-'use strict';
-
-// Generated source from interpreter plans: the verdict function.
-//
-// The interpreted engine is the reference every other engine is tested
-// against, and its Plan is a schema node with every keyword resolved once.
-// lib/plan-compiler.js turns plans into closures; this turns them into source,
-// deciding at compile time exactly what plan-compiler decides, and calling the
-// same helpers (deepEqual, the code point bounds, multipleOfOk, the format
-// functions and compiled patterns the plan already holds), so the answers
-// cannot drift the way three hand-written generators did.
-//
-// The scope is deliberately narrow for now: value-level keywords, properties
-// and additionalProperties, prefixItems and items, and the in-place
-// applicators. Everything else, references, unevaluated*, contains,
-// propertyNames, patternProperties, dependentSchemas, custom keywords, makes
-// the compiler return null. It never emits a function with a keyword missing.
-
-const { createInterpreter, _planInternals: I } = require('./interpreter');
-const { Plan, deepEqual, cpAtLeast, cpAtMost, multipleOfOk, T_STRING, T_NUMBER, T_INTEGER, T_BOOLEAN, T_NULL, T_OBJECT, T_ARRAY } = I;
-
-const DECLINE = Symbol('plan-source.decline');
-const ALL_TYPES = T_STRING | T_NUMBER | T_INTEGER | T_BOOLEAN | T_NULL | T_OBJECT | T_ARRAY;
-
-// The own-property test the generators use; see ownKeyExpr in js-compiler.js.
-const HELPERS = 'const _hop=Object.prototype.hasOwnProperty;';
-
-const PROTO_NAMES = new Set([...Object.getOwnPropertyNames(Object.prototype), '__proto__']);
-
-function isPrimitive(x) {
-  return x === null || typeof x === 'string' || typeof x === 'boolean' || Number.isFinite(x);
-}
-
-function lit(x) {
-  return JSON.stringify(x);
-}
-
-function createCtx() {
-  return { n: 0, argNames: [], argVals: [], fns: [], fnFor: new Map() };
-}
-
-// A value the emitted code needs by reference: a function, a RegExp, a list.
-function arg(ctx, value) {
-  const i = ctx.argVals.indexOf(value);
-  if (i !== -1) return ctx.argNames[i];
-  const name = '_a' + ctx.argVals.length;
-  ctx.argNames.push(name);
-  ctx.argVals.push(value);
-  return name;
-}
-
-function local(ctx) {
-  return '_v' + ctx.n++;
-}
-
-// JSON Schema type bits, exactly as dataBits() assigns them: a non-finite
-// number has no type, so it matches neither number nor integer.
-function typeTest(mask, v) {
-  const parts = [];
-  if (mask & T_STRING) parts.push(`typeof ${v}==='string'`);
-  if (mask & T_NUMBER) parts.push(`Number.isFinite(${v})`);
-  else if (mask & T_INTEGER) parts.push(`Number.isInteger(${v})`);
-  if (mask & T_BOOLEAN) parts.push(`typeof ${v}==='boolean'`);
-  if (mask & T_NULL) parts.push(`${v}===null`);
-  if ((mask & T_OBJECT) && (mask & T_ARRAY)) parts.push(`(typeof ${v}==='object'&&${v}!==null)`);
-  else if (mask & T_OBJECT) parts.push(`(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`);
-  else if (mask & T_ARRAY) parts.push(`Array.isArray(${v})`);
-  return parts.length ? parts.join('||') : 'false';
-}
-
-// `plain` names a local holding `v.__proto__===Object.prototype`, read once per
-// object. With the key a constant at the `in`, the engine keeps the check
-// monomorphic; through a shared helper the key is a parameter and it is not.
-function ownTest(v, key, plain) {
-  const k = lit(key);
-  return PROTO_NAMES.has(key) ? `_hop.call(${v},${k})` : `(${plain}?${k} in ${v}:_hop.call(${v},${k}))`;
-}
-
-const K_NUM = T_NUMBER | T_INTEGER;
-// The body under a guard for one kind of value, given what the type check
-// already established: unconditional when the value can only be that kind,
-// nothing at all when it cannot be.
-function guarded(known, kind, cond, body) {
-  if (!body) return '';
-  if ((known & kind) === 0) return '';
-  if ((known & ~kind) === 0) return body;
-  return `if(${cond}){${body}}`;
-}
-
-// Value-level keywords, in compileLeafV's order and with its meaning.
-function emitLeaf(ctx, P, v, known) {
-  let out = '';
-  if (P.hasType) out += `if(!(${typeTest(P.typeMask, v)}))return false;`;
-  if (P.enum !== null) {
-    const vals = P.enum;
-    if (vals.length === 0) out += 'return false;';
-    else if (vals.every(isPrimitive)) out += `if(!(${vals.map((x) => `${v}===${lit(x)}`).join('||')}))return false;`;
-    else {
-      const a = arg(ctx, vals);
-      const de = arg(ctx, deepEqual);
-      const i = local(ctx);
-      out += `{let ${i}=0;for(;${i}<${a}.length;${i}++)if(${de}(${a}[${i}],${v}))break;if(${i}===${a}.length)return false}`;
-    }
-  }
-  if (P.hasConst) {
-    out += isPrimitive(P.const)
-      ? `if(${v}!==${lit(P.const)})return false;`
-      : `if(!${arg(ctx, deepEqual)}(${arg(ctx, P.const)},${v}))return false;`;
-  }
-  if (P.hasNumber) {
-    let n = '';
-    if (P.minimum !== undefined) n += `if(${v}<${lit(P.minimum)})return false;`;
-    if (P.maximum !== undefined) n += `if(${v}>${lit(P.maximum)})return false;`;
-    if (P.exclusiveMinimum !== undefined) n += `if(${v}<=${lit(P.exclusiveMinimum)})return false;`;
-    if (P.exclusiveMaximum !== undefined) n += `if(${v}>=${lit(P.exclusiveMaximum)})return false;`;
-    if (P.multipleOf !== undefined) n += `if(!${arg(ctx, multipleOfOk)}(${v},${lit(P.multipleOf)}))return false;`;
-    out += guarded(known, K_NUM, `Number.isFinite(${v})`, n);
-  }
-  if (P.hasString) {
-    let s = '';
-    if (P.minLength !== undefined) s += `if(!${arg(ctx, cpAtLeast)}(${v},${lit(P.minLength)}))return false;`;
-    if (P.maxLength !== undefined) s += `if(!${arg(ctx, cpAtMost)}(${v},${lit(P.maxLength)}))return false;`;
-    if (P.pattern !== null) s += `if(!${arg(ctx, P.pattern)}.test(${v}))return false;`;
-    if (P.formatFn !== null) s += `if(!${arg(ctx, P.formatFn)}(${v}))return false;`;
-    out += guarded(known, T_STRING, `typeof ${v}==='string'`, s);
-  }
-  if (P.minItems !== undefined || P.maxItems !== undefined || P.uniqueItems) {
-    let a = '';
-    if (P.minItems !== undefined) a += `if(${v}.length<${lit(P.minItems)})return false;`;
-    if (P.maxItems !== undefined) a += `if(${v}.length>${lit(P.maxItems)})return false;`;
-    if (P.uniqueItems) {
-      const de = arg(ctx, deepEqual);
-      const i = local(ctx), j = local(ctx);
-      a += `for(let ${i}=0;${i}<${v}.length;${i}++)for(let ${j}=${i}+1;${j}<${v}.length;${j}++)if(${de}(${v}[${i}],${v}[${j}]))return false;`;
-    }
-    out += guarded(known, T_ARRAY, `Array.isArray(${v})`, a);
-  }
-  return out;
-}
-
-// The object-level keywords of a node, value-level and structural together, so
-// the prototype of the object is read once for all of them.
-function emitObjectLeaf(ctx, P, v, plain) {
-  let o = '';
-  if (P.required !== null || P.minProperties !== undefined || P.maxProperties !== undefined || P.dependentRequired !== null) {
-    if (P.required !== null) for (const k of P.required) o += `if(!${ownTest(v, k, plain)})return false;`;
-    if (P.minProperties !== undefined) o += `if(Object.keys(${v}).length<${lit(P.minProperties)})return false;`;
-    if (P.maxProperties !== undefined) o += `if(Object.keys(${v}).length>${lit(P.maxProperties)})return false;`;
-    if (P.dependentRequired !== null) {
-      for (const [key, deps] of P.dependentRequired) {
-        o += `if(${ownTest(v, key, plain)}){${deps.map((dep) => `if(!${ownTest(v, dep, plain)})return false;`).join('')}}`;
-      }
-    }
-  }
-  return o;
-}
-
-// A subschema asked for a verdict of its own (a branch of anyOf/oneOf, the
-// subject of not/if) becomes a named function, emitted once per plan.
-function branchFn(ctx, node) {
-  if (node === true) return '_t';
-  if (node === false) return '_f';
-  let name = ctx.fnFor.get(node);
-  if (name !== undefined) return name;
-  name = '_b' + ctx.fnFor.size;
-  ctx.fnFor.set(node, name);
-  const body = emitNode(ctx, node, 'd');
-  ctx.fns.push(`function ${name}(d){${body}return true}`);
-  return name;
-}
-
-function emitNode(ctx, node, v) {
-  if (node === true) return '';
-  if (node === false) return 'return false;';
-  if (!(node instanceof Plan)) return '';
-  const P = node;
-  if (P.tracked || P.hasUnevaluated || P.hasCustom || P.macros !== null ||
-      P.contains !== undefined || P.propertyNames !== undefined || P.patternProperties !== null ||
-      P.dependentSchemas !== null || P.propertyDependencies !== null) {
-    throw DECLINE;
-  }
-  const known = P.hasType ? P.typeMask : ALL_TYPES;
-  let out = emitLeaf(ctx, P, v, known);
-
-  if (P.prefixItems !== null || P.items !== undefined) {
-    let a = '';
-    if (P.prefixItems !== null) {
-      P.prefixItems.forEach((child, i) => {
-        const x = local(ctx);
-        const body = emitNode(ctx, child, x);
-        if (body) a += `if(${v}.length>${i}){const ${x}=${v}[${i}];${body}}`;
-      });
-    }
-    if (P.items !== undefined) {
-      const start = P.prefixItems !== null ? P.prefixItems.length : 0;
-      const i = local(ctx);
-      const x = local(ctx);
-      const body = emitNode(ctx, P.items, x);
-      if (body) a += `for(let ${i}=${start};${i}<${v}.length;${i}++){const ${x}=${v}[${i}];${body}}`;
-    }
-    out += guarded(known, T_ARRAY, `Array.isArray(${v})`, a);
-  }
-
-  const plain = local(ctx);
-  let o = emitObjectLeaf(ctx, P, v, plain);
-  if (P.properties !== null || P.additionalProperties !== undefined) {
-    const declared = P.properties !== null ? [...P.properties.keys()] : [];
-    if (P.properties !== null) {
-      for (const [key, entry] of P.properties) {
-        const x = local(ctx);
-        const body = emitNode(ctx, entry.node, x);
-        if (body) o += `if(${ownTest(v, key, plain)}){const ${x}=${v}[${lit(key)}];${body}}`;
-      }
-    }
-    const ap = P.additionalProperties;
-    if (ap !== undefined && ap !== true) {
-      const k = local(ctx);
-      let isDeclared = 'false';
-      if (declared.length > 8) {
-        const set = Object.create(null);
-        for (const key of declared) set[key] = 1;
-        isDeclared = `${arg(ctx, set)}[${k}]===1`;
-      } else if (declared.length > 0) {
-        isDeclared = declared.map((key) => `${k}===${lit(key)}`).join('||');
-      }
-      let apBody;
-      if (ap === false) apBody = 'return false;';
-      else {
-        const x = local(ctx);
-        const body = emitNode(ctx, ap, x);
-        apBody = body ? `const ${x}=${v}[${k}];${body}` : '';
-      }
-      if (apBody) o += `for(const ${k} in ${v}){if(!${plain}&&!_hop.call(${v},${k}))continue;if(${isDeclared})continue;${apBody}}`;
-    }
-  }
-  if (o) out += guarded(known, T_OBJECT, `typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})`, `const ${plain}=${v}.__proto__===Object.prototype;${o}`);
-
-  if (P.allOf !== null) for (const child of P.allOf) out += emitNode(ctx, child, v);
-  if (P.anyOf !== null) out += `if(!(${P.anyOf.map((c) => `${branchFn(ctx, c)}(${v})`).join('||')}))return false;`;
-  if (P.oneOf !== null) {
-    const c = local(ctx);
-    out += `{let ${c}=0;${P.oneOf.map((b) => `if(${branchFn(ctx, b)}(${v})&&++${c}>1)return false;`).join('')}if(${c}!==1)return false}`;
-  }
-  if (P.not !== undefined) out += `if(${branchFn(ctx, P.not)}(${v}))return false;`;
-  if (P.if !== undefined) {
-    const t = P.then !== undefined ? emitNode(ctx, P.then, v) : '';
-    const e = P.else !== undefined ? emitNode(ctx, P.else, v) : '';
-    if (t || e) out += `if(${branchFn(ctx, P.if)}(${v})){${t}}else{${e}}`;
-  }
-  return out;
-}
-
-// Returns { fn, source } or null when the schema is outside what this emits.
-function compileVerdict(schema, options) {
-  let interp;
-  try {
-    interp = createInterpreter(schema, options || {});
-  } catch {
-    return null;
-  }
-  const ctx = createCtx();
-  let body;
-  try {
-    body = emitNode(ctx, interp.rootNode, 'd');
-  } catch (e) {
-    if (e === DECLINE) return null;
-    throw e;
-  }
-  const source = HELPERS + 'function _t(){return true}function _f(){return false}' +
-    ctx.fns.join('') + `return function(d){${body}return true}`;
-  let fn;
-  try {
-    // eslint-disable-next-line no-new-func
-    fn = new Function(...ctx.argNames, source)(...ctx.argVals);
-  } catch {
-    return null;
-  }
-  return { fn, source };
-}
-
-module.exports = { compileVerdict };