ata-validator 1.47.0 → 1.49.0

package/lib/js-compiler-errors.js

@@ -9,7 +9,7 @@ const { compileFunction } = require('./compile-fn')
 // the first call that compiles errors. Everything here was written as part
 // of js-compiler.js and reads its helpers from that module's _internal.
 const core = require('./js-compiler')
-const { hasConstraints, assertEmitted, prepareForCodegen, sharedCodegenGate, codegenSafe, isSimplePN, hasUnresolvableRef, needsBaseTracking, _cpLen, sharedRt, DECLINE, bindRt, compileSafe, emitGuardState, withPlain, REF_NEUTRAL_SIBLINGS, resolveCrossSchemaRef, enumCondition, emitDeq, emitConstant, ownGuard, ownKeyExpr, multipleOfBad, compilePatternInline, useSafeEngine, reFlags, FORMAT_CODEGEN, PROTO_NAMES, setOwn, nestedGenCode, compileToJSCodegen, SKIP_VALUE_KEYS, skipString, CYCLE_DEPTH, cyclicDefNames, sharedDefNames, reFlagArg, hoistOnce, PTR_ESC_HELPER, unevalContributions, emitUq, uqSources, safeReClosure, fastPrefixCheck, replaceTopLevel, refTargetFor, genCode, addLocalAnnotations, addTopApplicatorAnnotations, protoIs, ANNOT_APPLICATORS, SIZE_SKIPS, emitRootGuard, emitGuardedRun } = core._internal
+const { hasConstraints, assertEmitted, prepareForCodegen, sharedCodegenGate, codegenSafe, isSimplePN, hasUnresolvableRef, needsBaseTracking, _cpLen, sharedRt, DECLINE, bindRt, compileSafe, emitGuardState, withPlain, REF_NEUTRAL_SIBLINGS, resolveCrossSchemaRef, enumCondition, enumOperand, emitDeq, emitConstant, ownGuard, ownKeyExpr, multipleOfBad, compilePatternInline, useSafeEngine, reFlags, FORMAT_CODEGEN, PROTO_NAMES, setOwn, nestedGenCode, compileToJSCodegen, SKIP_VALUE_KEYS, skipString, CYCLE_DEPTH, cyclicDefNames, sharedDefNames, reFlagArg, hoistOnce, PTR_ESC_HELPER, unevalContributions, emitUq, uqSources, safeReClosure, fastPrefixCheck, replaceTopLevel, refTargetFor, genCode, addLocalAnnotations, addTopApplicatorAnnotations, protoIs, ANNOT_APPLICATORS, SIZE_SKIPS, emitRootGuard, emitGuardedRun } = core._internal
 
 
 function emitPtrEsc(ctx) {
@@ -289,7 +289,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, rootE: schema, rootSchema: inputSchema, userFormats: userFormats || null,
+  const ctx = { noOrdinal: !!(sourceOpts && sourceOpts.noOrdinal), varCounter: 0, helperCode: [], rootDefs: eRootDefs, shared: [], refStack: new Set(), schemaMap: schemaMap || null, anchors: eAnchors, rootE: schema, 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: [],
@@ -1143,7 +1143,8 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
 
   // enum
   if (schema.enum) {
-    lines.push(`if(!(${enumCondition(ctx, schema.enum, v)})){${fail('enum', 'enum', `{allowedValues:${JSON.stringify(schema.enum)}}`, "'must be equal to one of the allowed values'")}}`)
+    const ev = enumOperand(ctx, schema.enum, v, lines)
+    lines.push(`if(!(${enumCondition(ctx, schema.enum, ev)})){${fail('enum', 'enum', `{allowedValues:${JSON.stringify(schema.enum)}}`, "'must be equal to one of the allowed values'")}}`)
   }
 
   // const — use canonical (sorted-key) comparison for objects
@@ -1351,9 +1352,15 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   if (schema.properties) {
     for (const [key, prop] of Object.entries(schema.properties)) {
       const childPath = childPathExpr(pathExpr, ptrSeg(key))
+      const sp = schemaPrefix+'/properties/'+ptrSeg(key)
+      const from = lines.length
       lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${ownKeyExpr(ctx, v, key)}){`)
-      genCodeE(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx, schemaPrefix+'/properties/'+ptrSeg(key))
+      // A large subschema as a function of its own (emitPropFnE); false means inline.
+      if (!propFnCandidateE(prop, ctx, sp) || !emitPropFnE(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx, sp)) {
+        genCodeE(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx, sp)
+      }
       lines.push(`}`)
+      countInlineE(lines, from, ctx)
     }
   }
 
@@ -2039,6 +2046,86 @@ function emitSharedDefC(defName, v, pathExpr, lines, ctx, schemaPrefix) {
   return true
 }
 
+// The same split for the error collector (genCodeE): a large property
+// subschema becomes `_pe<n>(d,_p,_all,_e)` in the helper code, pushing into
+// the caller's list as an inlined body would, generated against the real
+// schema path since it has one call site. Not inside a shared definition's
+// body, whose placeholder path is substituted after the fact.
+function propFnCandidateE (prop, ctx, schemaPrefix) {
+  if (!ctx || ctx.nestedBoolean || ctx.condDepth) return false
+  if (typeof schemaPrefix !== 'string' || schemaPrefix.includes(SP_PLACEHOLDER)) return false
+  if (!prop || typeof prop !== 'object' || Array.isArray(prop)) return false
+  let size = 0
+  try { size = JSON.stringify(prop).length } catch { return false }
+  return size >= SPLIT_C_SCHEMA || ((ctx.fnBytesE || 0) > SPLIT_C_BUDGET && size >= SPLIT_C_SMALL)
+}
+function emitPropFnE (prop, v, pathExpr, lines, ctx, schemaPrefix) {
+  const outerBytes = ctx.fnBytesE
+  ctx.fnBytesE = 0
+  const bodyLines = []
+  try { genCodeE(prop, 'd', '_p', bodyLines, ctx, schemaPrefix) } finally { ctx.fnBytesE = outerBytes }
+  if (bodyLines.length === 0) return false
+  const body = bodyLines.join('\n  ')
+  if (body.includes(SP_PLACEHOLDER)) return false
+  const fnName = '_pe' + (ctx.propFnsE = (ctx.propFnsE || 0) + 1)
+  ctx.helperCode.push(`function ${fnName}(d,_p,_all,_e){${body}}`)
+  lines.push(`${fnName}(${v},${pathExpr || '""'},_all,_e);if(!_all&&_e.length)return{valid:false,errors:_e}`)
+  return true
+}
+function countInlineE (lines, from, ctx) {
+  let n = 0
+  for (let i = from; i < lines.length; i++) n += lines[i].length
+  ctx.fnBytesE = (ctx.fnBytesE || 0) + n
+}
+
+// A large property subschema as a function of its own, for the reason the
+// verdict generator has (emitPropFn in js-compiler.js): one function per
+// schema outgrew what V8 optimizes, and a 167 KB configuration schema's
+// one-pass function was 3.8 MB of source that ran in the interpreter. The
+// function is used at one site, so it is generated against the real schema
+// path and its errors keep their precise ordinal keys; it is not written
+// inside a shared definition's body, whose placeholder path is substituted
+// after the fact and would not reach a helper of its own.
+const SPLIT_C_SCHEMA = 1500
+const SPLIT_C_SMALL = 160
+const SPLIT_C_BUDGET = 16 * 1024
+function propFnCandidateC (prop, ctx, schemaPrefix) {
+  if (!ctx || ctx.inDefC || ctx.nestedBoolean || ctx.condDepth) return false
+  if (typeof schemaPrefix !== 'string' || schemaPrefix.includes(SP_PLACEHOLDER)) return false
+  if (!prop || typeof prop !== 'object' || Array.isArray(prop)) return false
+  let size = 0
+  try { size = JSON.stringify(prop).length } catch { return false }
+  return size >= SPLIT_C_SCHEMA || ((ctx.fnBytesC || 0) > SPLIT_C_BUDGET && size >= SPLIT_C_SMALL)
+}
+function emitPropFnC (prop, v, pathExpr, lines, ctx, schemaPrefix) {
+  const outerHoisted = ctx.hoisted
+  ctx.hoisted = []
+  const outerBytes = ctx.fnBytesC
+  ctx.fnBytesC = 0
+  const bodyLines = []
+  let hoisted
+  try {
+    genGuardedC(prop, '_dv', '_p', bodyLines, ctx, schemaPrefix)
+  } finally {
+    hoisted = ctx.hoisted
+    ctx.hoisted = outerHoisted
+    ctx.fnBytesC = outerBytes
+  }
+  if (bodyLines.length === 0) return false
+  const body = bodyLines.join('\n  ')
+  if (body.includes(SP_PLACEHOLDER) || /\b_so\b/.test(body)) return false
+  const decl = hoisted.length ? `let ${hoisted.map((n) => n + '=null').join(',')};` : ''
+  const fnName = '_pc' + (ctx.propFnsC = (ctx.propFnsC || 0) + 1)
+  ctx.helperCode.push(`function ${fnName}(_dv,_p,d){const _all=true;${decl}let _e;\n  ${body}\n  return _e}`)
+  lines.push(`{const _r=${fnName}(${v},${pathExpr || '""'},d);if(_r!==undefined){if(_e===undefined)_e=_r;else for(let _i=0;_i<_r.length;_i++)_e.push(_r[_i])}}`)
+  return true
+}
+function countInlineC (lines, from, ctx) {
+  let n = 0
+  for (let i = from; i < lines.length; i++) n += lines[i].length
+  ctx.fnBytesC = (ctx.fnBytesC || 0) + n
+}
+
 // One schema as a function of its own in the combined function (see
 // emitSharedDefC). The name is registered before the body is written, so a
 // reference back to it inside becomes a call. One that can re-enter itself,
@@ -2244,7 +2331,8 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   const emitEnumConst = () => {
     // enum
     if (schema.enum) {
-      lines.push(`if(!(${enumCondition(ctx, schema.enum, v)})){${fail('enum', 'enum', `{allowedValues:${JSON.stringify(schema.enum)}}`, "'must be equal to one of the allowed values'")}}`)
+      const ev = enumOperand(ctx, schema.enum, v, lines)
+      lines.push(`if(!(${enumCondition(ctx, schema.enum, ev)})){${fail('enum', 'enum', `{allowedValues:${JSON.stringify(schema.enum)}}`, "'must be equal to one of the allowed values'")}}`)
     }
 
     // const
@@ -2507,21 +2595,28 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     for (const [key, prop] of Object.entries(schema.properties)) {
       const pv = hoisted[key] || `${v}[${JSON.stringify(key)}]`
       const childPath = childPathExpr(pathExpr, ptrSeg(key))
+      const sp = schemaPrefix+'/properties/'+ptrSeg(key)
+      const from = lines.length
+      const split = propFnCandidateC(prop, ctx, sp)
+      // A large subschema as a function of its own (emitPropFnC), called
+      // where the inline code would be; false means it is written inline.
+      const sub = (pvExpr) => { if (!split || !emitPropFnC(prop, pvExpr, childPath, lines, ctx, sp)) genGuardedC(prop, pvExpr, childPath, lines, ctx, sp) }
       if (requiredSet.has(key) && isObj) {
         // A hoisted local was already cleared if the value is only inherited.
         lines.push(`if(${pv}!==undefined${hoisted[key] ? '' : '&&' + ownGuard(ctx, v, key)}){`)
-        genGuardedC(prop, pv, childPath, lines, ctx, schemaPrefix+'/properties/'+ptrSeg(key))
+        sub(pv)
         lines.push(`}`)
       } else if (isObj) {
         const oi = ctx.varCounter++
         lines.push(`{const _o${oi}=${v}[${JSON.stringify(key)}];if(_o${oi}!==undefined&&${ownGuard(ctx, v, key)}){`)
-        genGuardedC(prop, `_o${oi}`, childPath, lines, ctx, schemaPrefix+'/properties/'+ptrSeg(key))
+        sub(`_o${oi}`)
         lines.push(`}}`)
       } else {
         lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${ownKeyExpr(ctx, v, key)}){`)
-        genGuardedC(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx, schemaPrefix+'/properties/'+ptrSeg(key))
+        sub(`${v}[${JSON.stringify(key)}]`)
         lines.push(`}`)
       }
+      countInlineC(lines, from, ctx)
     }
   }
 

package/lib/js-compiler.js

@@ -135,6 +135,21 @@ function emitConstant(ctx, value) {
   return name
 }
 
+// The operand an `enum` test compares: `v` itself when it is a plain
+// identifier, otherwise a local bound once. The test is a chain of `===`,
+// one per member, and each used to repeat the access expression, so a
+// 32-member enum on a required property read `_e3["tool"]` 32 times; on an
+// array of items in several shapes those reads are polymorphic and cost
+// 59 ns against 20 with the value in a local. The binding goes to `lines`
+// ahead of the test.
+const IDENT_RE = /^[A-Za-z_$][\w$]*$/
+function enumOperand(ctx, vals, v, lines) {
+  if (IDENT_RE.test(v) || vals.length < 2) return v
+  const name = `_ev${ctx.varCounter++}`
+  lines.push(`const ${name}=${v}`)
+  return name
+}
+
 // One `enum` test: primitives compare with `===`, which needs no call, and
 // object members go through structural equality.
 function enumCondition(ctx, vals, v) {
@@ -1161,6 +1176,60 @@ function _setCodeBudget (n) { codeBudget = n === undefined ? CODE_BUDGET : n }
 // document that reached it, and the second cut the cycle, so the reference
 // checked nothing. While `nestedBoolean` is set, genCode declines at those
 // points instead, and the caller's generator declines the schema.
+// A property whose subschema is large becomes a function of its own in the
+// preamble, called where the property is checked, instead of its code inline.
+// V8 does not optimize a function past its bytecode budget (about 60 KB), and
+// a configuration schema of a few hundred properties compiled to one function
+// of a megabyte or more that ran in the interpreter for its whole life: on a
+// 167 KB schema the verdict took 407 us where the same checks in functions of
+// their own take 40. The threshold is on the schema's own size, which is
+// known before any code is written, so nothing is generated twice. A
+// property moves out on its own only when its schema is plainly large; the
+// usual case is the budget: once a function holds SPLIT_FN_BUDGET bytes of
+// inline code, every property past SPLIT_PROP_SMALL moves out, so a schema
+// of many middling properties splits after its first functions' worth and a
+// small or medium one, whose whole program fits the budget, never does and
+// pays no call.
+const SPLIT_PROP_SCHEMA = 2000
+const SPLIT_PROP_SMALL = 220
+const SPLIT_FN_BUDGET = 24 * 1024
+function propSchemaSize (prop) {
+  try { return JSON.stringify(prop).length } catch { return 0 }
+}
+function propFnCandidate (prop, ctx) {
+  if (!ctx.preamble || ctx.nestedBoolean || ctx.condDepth) return false
+  if (!prop || typeof prop !== 'object' || Array.isArray(prop)) return false
+  const size = propSchemaSize(prop)
+  return size >= SPLIT_PROP_SCHEMA || ((ctx.fnBytes || 0) > SPLIT_FN_BUDGET && size >= SPLIT_PROP_SMALL)
+}
+// Generated over its own `d`, the way a shared definition is (see the $ref
+// case in genCodeNode): the deferred checks belong to this body, and the
+// plain-object reuse state must not leak in or out. Null means "write it
+// inline after all": an empty body (the inline path then asserts it the
+// usual way) or one that calls the recursive entry, which is out of scope
+// in the preamble.
+function emitPropFn (prop, ctx) {
+  const bodyLines = []
+  const outerDeferred = ctx.deferredChecks
+  ctx.deferredChecks = null
+  const outerReuse = ctx.plainReuse
+  ctx.plainReuse = undefined
+  const outerBytes = ctx.fnBytes
+  ctx.fnBytes = 0
+  try { genCode(prop, 'd', bodyLines, ctx) } finally { ctx.plainReuse = outerReuse; ctx.fnBytes = outerBytes }
+  if (ctx.deferredChecks) for (const dc of ctx.deferredChecks) bodyLines.push(dc)
+  ctx.deferredChecks = outerDeferred
+  if (bodyLines.length === 0 || bodyLines.some((l) => /\b_validate\b/.test(l))) return null
+  const fnName = '_pf' + (ctx.propFns = (ctx.propFns || 0) + 1)
+  hoist(ctx, `function ${fnName}(d){${bodyLines.join('\n  ')}\n  return true}`)
+  return fnName
+}
+function countInline (lines, from, ctx) {
+  let n = 0
+  for (let i = from; i < lines.length; i++) n += lines[i].length
+  ctx.fnBytes = (ctx.fnBytes || 0) + n
+}
+
 function nestedGenCode(schema, v, lines, ctx) {
   ctx.nestedBoolean = (ctx.nestedBoolean || 0) + 1
   const before = lines.length
@@ -1262,6 +1331,14 @@ function sharedDefNames (root, defs) {
   }
   return out
 }
+// Raising this to inline small definitions at every site was measured and
+// rejected: SchemaStore's detekt applies one 200-character rule definition
+// at 293 sites, and inlining it took the verdict from 5287 ns to 452 but the
+// standalone module from 168 KB to 1692 KB and its compile to 33 ms. The
+// slowness of the shared function is megamorphic property reads (474 objects
+// of 72 shapes through one function); a for-in body for the shared function
+// was tried too and gave 1.5x, not enough to carry its complexity. Left as a
+// known trade: on that shape the shared function costs 27 ns a call.
 const SHARED_DEF_MIN_CHARS = 120
 
 function cyclicDefNames (defs) {
@@ -1932,8 +2009,32 @@ function sharedCodegenGate(schema, schemaMap) {
   _gateSchema = schema; _gateMap = schemaMap; _gateOk = ok
   return ok
 }
+// `unevaluatedProperties` or `unevaluatedItems` beside a `$ref` back to the
+// document root: the generated evaluated-set tracking does not credit what
+// the root evaluates through that reference, so a tree whose branches say
+// `{ unevaluatedProperties: false, $ref: '#' }` rejected valid branches (a
+// wrong reject, found through the 2019-09 `$recursiveRef` tests, and the same
+// in 2020-12). The interpreted engine answers it. A text check first: almost
+// no schema has both.
+function unevaluatedBesideRootRef(schema) {
+  const text = JSON.stringify(schema)
+  if (!text.includes('"$ref":"#"') || !/"unevaluated(?:Properties|Items)"/.test(text)) return false
+  let found = false
+  const seen = new Set()
+  const walk = (n) => {
+    if (found || n === null || typeof n !== 'object' || seen.has(n)) return
+    seen.add(n)
+    if (Array.isArray(n)) { for (const x of n) walk(x); return }
+    if (n.$ref === '#' && (n.unevaluatedProperties !== undefined || n.unevaluatedItems !== undefined)) { found = true; return }
+    for (const [k, v] of Object.entries(n)) if (k !== 'enum' && k !== 'const' && k !== 'default' && k !== 'examples') walk(v)
+  }
+  walk(schema)
+  return found
+}
+
 function sharedCodegenGateUncached(schema, schemaMap) {
   if (bothDefsContainers(schema)) return false
+  if (unevaluatedBesideRootRef(schema)) return false
   if (hasSameInstanceRefCycle(schema)) return false
   if (!codegenSafe(schema, schemaMap)) return false
   if (needsBaseTracking(schema, schemaMap, new Set())) return false
@@ -3243,7 +3344,8 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
 
   // enum
   if (schema.enum) {
-    lines.push(`if(!(${enumCondition(ctx, schema.enum, v)}))return false`)
+    const ev = enumOperand(ctx, schema.enum, v, lines)
+    lines.push(`if(!(${enumCondition(ctx, schema.enum, ev)}))return false`)
   }
 
   // const
@@ -3498,11 +3600,17 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
   // properties — use hoisted vars for required props, hoist optional to locals too
   if (schema.properties) {
     for (const [key, prop] of Object.entries(schema.properties)) {
+      const from = lines.length
+      // A large subschema as a function of its own (emitPropFn); the call
+      // takes the place of the inline code in each of the three shapes below.
+      const fn = propFnCandidate(prop, ctx) ? emitPropFn(prop, ctx) : null
       if (requiredSet.has(key) && isObj) {
         // Required + type:object — hoist to local to reduce repeated property lookups
         const access = hoisted[key] || `${v}[${JSON.stringify(key)}]`
-        const combined = tryGenCombined(prop, access, ctx)
-        if (combined) {
+        const combined = fn ? null : tryGenCombined(prop, access, ctx)
+        if (fn) {
+          lines.push(`if(!${fn}(${access}))return false`)
+        } else if (combined) {
           lines.push(combined)
         } else if (needsLocal(prop) || isPlainContainer(prop)) {
           const oi = ctx.varCounter++
@@ -3518,8 +3626,10 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
         const oi = ctx.varCounter++
         const local = `_o${oi}`
         lines.push(`{const ${local}=${v}[${JSON.stringify(key)}];if(${local}!==undefined&&${ownGuard(ctx, v, key)}){`)
-        const combined = tryGenCombined(prop, local, ctx)
-        if (combined) {
+        const combined = fn ? null : tryGenCombined(prop, local, ctx)
+        if (fn) {
+          lines.push(`if(!${fn}(${local}))return false`)
+        } else if (combined) {
           lines.push(combined)
         } else {
           genCode(prop, local, lines, ctx)
@@ -3527,9 +3637,11 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
         lines.push(`}}`)
       } else {
         lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${ownKeyExpr(ctx, v, key)}){`)
-        genCode(prop, `${v}[${JSON.stringify(key)}]`, lines, ctx)
+        if (fn) lines.push(`if(!${fn}(${v}[${JSON.stringify(key)}]))return false`)
+        else genCode(prop, `${v}[${JSON.stringify(key)}]`, lines, ctx)
         lines.push(`}`)
       }
+      countInline(lines, from, ctx)
     }
   }
 
@@ -5307,4 +5419,4 @@ Object.defineProperty(module.exports, '_expandDynamicScopes', { value: expandDyn
 // For tests/test_custom_keyword_codegen.js, which holds these copies to the interpreter's.
 Object.defineProperty(module.exports, '_kwTypeBits', { value: { kwTypeBit, kwDataBits, KW_T_ANY }, enumerable: false })
 
-module.exports._internal = { hasConstraints, assertEmitted, prepareForCodegen, sharedCodegenGate, codegenSafe, isSimplePN, hasUnresolvableRef, needsBaseTracking, _cpLen, sharedRt, DECLINE, bindRt, compileSafe, emitGuardState, withPlain, REF_NEUTRAL_SIBLINGS, resolveCrossSchemaRef, enumCondition, emitDeq, emitConstant, ownGuard, ownKeyExpr, multipleOfBad, compilePatternInline, useSafeEngine, reFlags, FORMAT_CODEGEN, PROTO_NAMES, setOwn, nestedGenCode, compileToJSCodegen, SKIP_VALUE_KEYS, skipString, CYCLE_DEPTH, cyclicDefNames, sharedDefNames, reFlagArg, hoistOnce, PTR_ESC_HELPER, unevalContributions, emitUq, uqSources, safeReClosure, fastPrefixCheck, replaceTopLevel, refTargetFor, genCode, addLocalAnnotations, addTopApplicatorAnnotations, protoIs, ANNOT_APPLICATORS, SIZE_SKIPS, emitRootGuard, emitGuardedRun }
+module.exports._internal = { hasConstraints, assertEmitted, prepareForCodegen, sharedCodegenGate, codegenSafe, isSimplePN, hasUnresolvableRef, needsBaseTracking, _cpLen, sharedRt, DECLINE, bindRt, compileSafe, emitGuardState, withPlain, REF_NEUTRAL_SIBLINGS, resolveCrossSchemaRef, enumCondition, enumOperand, emitDeq, emitConstant, ownGuard, ownKeyExpr, multipleOfBad, compilePatternInline, useSafeEngine, reFlags, FORMAT_CODEGEN, PROTO_NAMES, setOwn, nestedGenCode, compileToJSCodegen, SKIP_VALUE_KEYS, skipString, CYCLE_DEPTH, cyclicDefNames, sharedDefNames, reFlagArg, hoistOnce, PTR_ESC_HELPER, unevalContributions, emitUq, uqSources, safeReClosure, fastPrefixCheck, replaceTopLevel, refTargetFor, genCode, addLocalAnnotations, addTopApplicatorAnnotations, protoIs, ANNOT_APPLICATORS, SIZE_SKIPS, emitRootGuard, emitGuardedRun }

package/lib/metaschemas.js

@@ -2,8 +2,14 @@
 
 // The official meta-schemas, vendored so a `$ref` to one of them resolves
 // without a network. Draft 2020-12 is eight documents joined by $dynamicRef;
-// draft-07 is one. Sources: https://json-schema.org/draft/2020-12/schema and
-// http://json-schema.org/draft-07/schema, fetched 2026-08-23, unmodified.
+// draft-07 and draft-06 are one each; 2019-09 is seven. Sources:
+// https://json-schema.org/draft/2020-12/schema and
+// http://json-schema.org/draft-07/schema, fetched 2026-08-23, and
+// http://json-schema.org/draft-06/schema and
+// https://json-schema.org/draft/2019-09/schema, fetched 2026-10-10, unmodified.
+// The 2019-09 documents are read through the same 2019-09 rewrite as a
+// caller's schema (lib/draft7.js) once, at load, since they use
+// `$recursiveRef`, which the engines read as `$dynamicRef`.
 // Keyed by $id; index.js also registers the http/https and trailing-# spellings.
 
 const METASCHEMAS = new Map([
@@ -16,6 +22,19 @@ const METASCHEMAS = new Map([
   ["https://json-schema.org/draft/2020-12/meta/content", {"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://json-schema.org/draft/2020-12/meta/content","$dynamicAnchor":"meta","title":"Content vocabulary meta-schema","type":["object","boolean"],"properties":{"contentEncoding":{"type":"string"},"contentMediaType":{"type":"string"},"contentSchema":{"$dynamicRef":"#meta"}}}],
   ["https://json-schema.org/draft/2020-12/meta/unevaluated", {"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://json-schema.org/draft/2020-12/meta/unevaluated","$dynamicAnchor":"meta","title":"Unevaluated applicator vocabulary meta-schema","type":["object","boolean"],"properties":{"unevaluatedItems":{"$dynamicRef":"#meta"},"unevaluatedProperties":{"$dynamicRef":"#meta"}}}],
   ["http://json-schema.org/draft-07/schema#", {"$schema":"http://json-schema.org/draft-07/schema#","$id":"http://json-schema.org/draft-07/schema#","title":"Core schema meta-schema","definitions":{"schemaArray":{"type":"array","minItems":1,"items":{"$ref":"#"}},"nonNegativeInteger":{"type":"integer","minimum":0},"nonNegativeIntegerDefault0":{"allOf":[{"$ref":"#/definitions/nonNegativeInteger"},{"default":0}]},"simpleTypes":{"enum":["array","boolean","integer","null","number","object","string"]},"stringArray":{"type":"array","items":{"type":"string"},"uniqueItems":true,"default":[]}},"type":["object","boolean"],"properties":{"$id":{"type":"string","format":"uri-reference"},"$schema":{"type":"string","format":"uri"},"$ref":{"type":"string","format":"uri-reference"},"$comment":{"type":"string"},"title":{"type":"string"},"description":{"type":"string"},"default":true,"readOnly":{"type":"boolean","default":false},"writeOnly":{"type":"boolean","default":false},"examples":{"type":"array","items":true},"multipleOf":{"type":"number","exclusiveMinimum":0},"maximum":{"type":"number"},"exclusiveMaximum":{"type":"number"},"minimum":{"type":"number"},"exclusiveMinimum":{"type":"number"},"maxLength":{"$ref":"#/definitions/nonNegativeInteger"},"minLength":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"pattern":{"type":"string","format":"regex"},"additionalItems":{"$ref":"#"},"items":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/schemaArray"}],"default":true},"maxItems":{"$ref":"#/definitions/nonNegativeInteger"},"minItems":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"uniqueItems":{"type":"boolean","default":false},"contains":{"$ref":"#"},"maxProperties":{"$ref":"#/definitions/nonNegativeInteger"},"minProperties":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"required":{"$ref":"#/definitions/stringArray"},"additionalProperties":{"$ref":"#"},"definitions":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"properties":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"patternProperties":{"type":"object","additionalProperties":{"$ref":"#"},"propertyNames":{"format":"regex"},"default":{}},"dependencies":{"type":"object","additionalProperties":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/stringArray"}]}},"propertyNames":{"$ref":"#"},"const":true,"enum":{"type":"array","items":true,"minItems":1,"uniqueItems":true},"type":{"anyOf":[{"$ref":"#/definitions/simpleTypes"},{"type":"array","items":{"$ref":"#/definitions/simpleTypes"},"minItems":1,"uniqueItems":true}]},"format":{"type":"string"},"contentMediaType":{"type":"string"},"contentEncoding":{"type":"string"},"if":{"$ref":"#"},"then":{"$ref":"#"},"else":{"$ref":"#"},"allOf":{"$ref":"#/definitions/schemaArray"},"anyOf":{"$ref":"#/definitions/schemaArray"},"oneOf":{"$ref":"#/definitions/schemaArray"},"not":{"$ref":"#"}},"default":true}],
+  ["http://json-schema.org/draft-06/schema#", {"$schema":"http://json-schema.org/draft-06/schema#","$id":"http://json-schema.org/draft-06/schema#","title":"Core schema meta-schema","definitions":{"schemaArray":{"type":"array","minItems":1,"items":{"$ref":"#"}},"nonNegativeInteger":{"type":"integer","minimum":0},"nonNegativeIntegerDefault0":{"allOf":[{"$ref":"#/definitions/nonNegativeInteger"},{"default":0}]},"simpleTypes":{"enum":["array","boolean","integer","null","number","object","string"]},"stringArray":{"type":"array","items":{"type":"string"},"uniqueItems":true,"default":[]}},"type":["object","boolean"],"properties":{"$id":{"type":"string","format":"uri-reference"},"$schema":{"type":"string","format":"uri"},"$ref":{"type":"string","format":"uri-reference"},"title":{"type":"string"},"description":{"type":"string"},"default":{},"examples":{"type":"array","items":{}},"multipleOf":{"type":"number","exclusiveMinimum":0},"maximum":{"type":"number"},"exclusiveMaximum":{"type":"number"},"minimum":{"type":"number"},"exclusiveMinimum":{"type":"number"},"maxLength":{"$ref":"#/definitions/nonNegativeInteger"},"minLength":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"pattern":{"type":"string","format":"regex"},"additionalItems":{"$ref":"#"},"items":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/schemaArray"}],"default":{}},"maxItems":{"$ref":"#/definitions/nonNegativeInteger"},"minItems":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"uniqueItems":{"type":"boolean","default":false},"contains":{"$ref":"#"},"maxProperties":{"$ref":"#/definitions/nonNegativeInteger"},"minProperties":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"required":{"$ref":"#/definitions/stringArray"},"additionalProperties":{"$ref":"#"},"definitions":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"properties":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"patternProperties":{"type":"object","additionalProperties":{"$ref":"#"},"propertyNames":{"format":"regex"},"default":{}},"dependencies":{"type":"object","additionalProperties":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/stringArray"}]}},"propertyNames":{"$ref":"#"},"const":{},"enum":{"type":"array","minItems":1,"uniqueItems":true},"type":{"anyOf":[{"$ref":"#/definitions/simpleTypes"},{"type":"array","items":{"$ref":"#/definitions/simpleTypes"},"minItems":1,"uniqueItems":true}]},"format":{"type":"string"},"allOf":{"$ref":"#/definitions/schemaArray"},"anyOf":{"$ref":"#/definitions/schemaArray"},"oneOf":{"$ref":"#/definitions/schemaArray"},"not":{"$ref":"#"}},"default":{}}],
+  ["https://json-schema.org/draft/2019-09/schema", {"$schema":"https://json-schema.org/draft/2019-09/schema","$id":"https://json-schema.org/draft/2019-09/schema","$vocabulary":{"https://json-schema.org/draft/2019-09/vocab/core":true,"https://json-schema.org/draft/2019-09/vocab/applicator":true,"https://json-schema.org/draft/2019-09/vocab/validation":true,"https://json-schema.org/draft/2019-09/vocab/meta-data":true,"https://json-schema.org/draft/2019-09/vocab/format":false,"https://json-schema.org/draft/2019-09/vocab/content":true},"$recursiveAnchor":true,"title":"Core and Validation specifications meta-schema","allOf":[{"$ref":"meta/core"},{"$ref":"meta/applicator"},{"$ref":"meta/validation"},{"$ref":"meta/meta-data"},{"$ref":"meta/format"},{"$ref":"meta/content"}],"type":["object","boolean"],"properties":{"definitions":{"$comment":"While no longer an official keyword as it is replaced by $defs, this keyword is retained in the meta-schema to prevent incompatible extensions as it remains in common use.","type":"object","additionalProperties":{"$recursiveRef":"#"},"default":{}},"dependencies":{"$comment":"\"dependencies\" is no longer a keyword, but schema authors should avoid redefining it to facilitate a smooth transition to \"dependentSchemas\" and \"dependentRequired\"","type":"object","additionalProperties":{"anyOf":[{"$recursiveRef":"#"},{"$ref":"meta/validation#/$defs/stringArray"}]}}}}],
+  ["https://json-schema.org/draft/2019-09/meta/core", {"$schema":"https://json-schema.org/draft/2019-09/schema","$id":"https://json-schema.org/draft/2019-09/meta/core","$recursiveAnchor":true,"title":"Core vocabulary meta-schema","type":["object","boolean"],"properties":{"$id":{"type":"string","format":"uri-reference","$comment":"Non-empty fragments not allowed.","pattern":"^[^#]*#?$"},"$schema":{"type":"string","format":"uri"},"$anchor":{"type":"string","pattern":"^[A-Za-z][-A-Za-z0-9.:_]*$"},"$ref":{"type":"string","format":"uri-reference"},"$recursiveRef":{"type":"string","format":"uri-reference"},"$recursiveAnchor":{"type":"boolean","default":false},"$vocabulary":{"type":"object","propertyNames":{"type":"string","format":"uri"},"additionalProperties":{"type":"boolean"}},"$comment":{"type":"string"},"$defs":{"type":"object","additionalProperties":{"$recursiveRef":"#"},"default":{}}}}],
+  ["https://json-schema.org/draft/2019-09/meta/applicator", {"$schema":"https://json-schema.org/draft/2019-09/schema","$id":"https://json-schema.org/draft/2019-09/meta/applicator","$recursiveAnchor":true,"title":"Applicator vocabulary meta-schema","type":["object","boolean"],"properties":{"additionalItems":{"$recursiveRef":"#"},"unevaluatedItems":{"$recursiveRef":"#"},"items":{"anyOf":[{"$recursiveRef":"#"},{"$ref":"#/$defs/schemaArray"}]},"contains":{"$recursiveRef":"#"},"additionalProperties":{"$recursiveRef":"#"},"unevaluatedProperties":{"$recursiveRef":"#"},"properties":{"type":"object","additionalProperties":{"$recursiveRef":"#"},"default":{}},"patternProperties":{"type":"object","additionalProperties":{"$recursiveRef":"#"},"propertyNames":{"format":"regex"},"default":{}},"dependentSchemas":{"type":"object","additionalProperties":{"$recursiveRef":"#"}},"propertyNames":{"$recursiveRef":"#"},"if":{"$recursiveRef":"#"},"then":{"$recursiveRef":"#"},"else":{"$recursiveRef":"#"},"allOf":{"$ref":"#/$defs/schemaArray"},"anyOf":{"$ref":"#/$defs/schemaArray"},"oneOf":{"$ref":"#/$defs/schemaArray"},"not":{"$recursiveRef":"#"}},"$defs":{"schemaArray":{"type":"array","minItems":1,"items":{"$recursiveRef":"#"}}}}],
+  ["https://json-schema.org/draft/2019-09/meta/validation", {"$schema":"https://json-schema.org/draft/2019-09/schema","$id":"https://json-schema.org/draft/2019-09/meta/validation","$recursiveAnchor":true,"title":"Validation vocabulary meta-schema","type":["object","boolean"],"properties":{"multipleOf":{"type":"number","exclusiveMinimum":0},"maximum":{"type":"number"},"exclusiveMaximum":{"type":"number"},"minimum":{"type":"number"},"exclusiveMinimum":{"type":"number"},"maxLength":{"$ref":"#/$defs/nonNegativeInteger"},"minLength":{"$ref":"#/$defs/nonNegativeIntegerDefault0"},"pattern":{"type":"string","format":"regex"},"maxItems":{"$ref":"#/$defs/nonNegativeInteger"},"minItems":{"$ref":"#/$defs/nonNegativeIntegerDefault0"},"uniqueItems":{"type":"boolean","default":false},"maxContains":{"$ref":"#/$defs/nonNegativeInteger"},"minContains":{"$ref":"#/$defs/nonNegativeInteger","default":1},"maxProperties":{"$ref":"#/$defs/nonNegativeInteger"},"minProperties":{"$ref":"#/$defs/nonNegativeIntegerDefault0"},"required":{"$ref":"#/$defs/stringArray"},"dependentRequired":{"type":"object","additionalProperties":{"$ref":"#/$defs/stringArray"}},"const":true,"enum":{"type":"array","items":true},"type":{"anyOf":[{"$ref":"#/$defs/simpleTypes"},{"type":"array","items":{"$ref":"#/$defs/simpleTypes"},"minItems":1,"uniqueItems":true}]}},"$defs":{"nonNegativeInteger":{"type":"integer","minimum":0},"nonNegativeIntegerDefault0":{"$ref":"#/$defs/nonNegativeInteger","default":0},"simpleTypes":{"enum":["array","boolean","integer","null","number","object","string"]},"stringArray":{"type":"array","items":{"type":"string"},"uniqueItems":true,"default":[]}}}],
+  ["https://json-schema.org/draft/2019-09/meta/meta-data", {"$schema":"https://json-schema.org/draft/2019-09/schema","$id":"https://json-schema.org/draft/2019-09/meta/meta-data","$recursiveAnchor":true,"title":"Meta-data vocabulary meta-schema","type":["object","boolean"],"properties":{"title":{"type":"string"},"description":{"type":"string"},"default":true,"deprecated":{"type":"boolean","default":false},"readOnly":{"type":"boolean","default":false},"writeOnly":{"type":"boolean","default":false},"examples":{"type":"array","items":true}}}],
+  ["https://json-schema.org/draft/2019-09/meta/format", {"$schema":"https://json-schema.org/draft/2019-09/schema","$id":"https://json-schema.org/draft/2019-09/meta/format","$recursiveAnchor":true,"title":"Format vocabulary meta-schema","type":["object","boolean"],"properties":{"format":{"type":"string"}}}],
+  ["https://json-schema.org/draft/2019-09/meta/content", {"$schema":"https://json-schema.org/draft/2019-09/schema","$id":"https://json-schema.org/draft/2019-09/meta/content","$recursiveAnchor":true,"title":"Content vocabulary meta-schema","type":["object","boolean"],"properties":{"contentMediaType":{"type":"string"},"contentEncoding":{"type":"string"},"contentSchema":{"$recursiveRef":"#"}}}],
 ]);
 
+{
+  const { isDraft2019, normalizeDraft2019 } = require('./draft7')
+  for (const [id, doc] of METASCHEMAS) if (isDraft2019(doc)) METASCHEMAS.set(id, normalizeDraft2019(JSON.parse(JSON.stringify(doc)), true))
+}
+
 module.exports = { METASCHEMAS };