ata-validator 1.48.0 → 1.50.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
@@ -2330,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

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) {
@@ -1316,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) {
@@ -1986,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
@@ -3297,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
@@ -5371,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 };

package/lib/public-api.js

@@ -0,0 +1,80 @@
+'use strict';
+
+// The public names of the package, shared by index.js (with the code
+// generator) and index.edge.js (without it), so the two entries export the
+// same thing.
+const core = require('./validator-core.js');
+
+
+
+// The parts no Validator calls: TypeScript generation, the error renderers,
+// the spec output format, the retry message for language models, the schema
+// description and the suggestion helper. ata-validator/lite leaves them out.
+// Each loads its module on first call. None of them is on the path to a first
+// validated request, and together they were about a sixth of what requiring
+// the package cost.
+function toTypeScript (...a) { return require('./ts-gen').toTypeScript(...a); }
+function renderPretty (...a) { return require('./render-pretty').renderPretty(...a); }
+function renderCompact (...a) { return require('./render-compact').renderCompact(...a); }
+function toOutput (...a) { return require('./output-format').toOutput(...a); }
+function toRetryMessage (...a) { return require('./retry-message').toRetryMessage(...a); }
+function describeSchema (...a) { return require('./describe-schema').describeSchema(...a); }
+function renderJSON (...a) { return require('./render-json').renderJSON(...a); }
+
+// Walk a JSON pointer (RFC 6901 escapes) into a data tree. Mirrors the helper
+// inside lib/suggestions.js, kept local to avoid exporting an internal.
+function _walkPointer (root, pointer) {
+  if (!pointer) return root;
+  const parts = pointer.replace(/^\//, '').split('/').map(s => s.replace(/~1/g, '/').replace(/~0/g, '~'));
+  let cur = root;
+  for (const p of parts) { if (cur == null) return undefined; cur = cur[p]; }
+  return cur;
+}
+
+// Post-hoc suggestion enrichment for AOT-compiled validators. The standalone
+// modules do not embed the suggestion engine, so consumers who want
+// suggestions pass the error array through this after validation.
+function attachSuggestions (errors, data) {
+  if (!errors) return errors;
+  const { suggestFor } = require('./suggestions');
+  const { reprValue } = require('./enrich-error');
+  for (const e of errors) {
+    if (!e || e.suggestion) continue;
+    let received = e.received;
+    if (received === undefined && data !== undefined) {
+      const ptr = e.instancePath != null ? e.instancePath : (e.path || '');
+      const raw = _walkPointer(data, ptr);
+      if (raw !== undefined || ptr === '') received = reprValue(raw);
+    }
+    const probe = received !== undefined && e.received === undefined
+      ? Object.assign({}, e, { received })
+      : e;
+    const s = suggestFor(probe, data);
+    if (s) e.suggestion = s;
+  }
+  // AOT modules import nothing, so this is their only route to a frame. The
+  // caller holds the original object and ran no preprocessing through here.
+  require('./diagnostic-source').setDiagnosticSource(errors, { data, mutatesInput: false });
+  return errors;
+}
+
+module.exports = {
+  Validator: core.Validator,
+  compile: core.compile,
+  validate: core.validate,
+  validateAsync: core.validateAsync,
+  parseAsync: core.parseAsync,
+  version: core.version,
+  createPaddedBuffer: core.createPaddedBuffer,
+  SIMDJSON_PADDING: core.SIMDJSON_PADDING,
+  parseJSON: core.parseJSON,
+  toTypeScript,
+  defineSchema: core.defineSchema,
+  renderPretty,
+  renderCompact,
+  toOutput,
+  toRetryMessage,
+  describeSchema,
+  renderJSON,
+  attachSuggestions, // internal: used by the renderers; not public API
+};

package/lib/regex-linear.js

@@ -3,34 +3,56 @@
 const { parse } = require('./safe-regex')
 
 // True when the platform RegExp, a backtracking engine, also runs `src` in
-// linear time, so it can take the pattern: every unbounded quantifier on one
-// character, class or `.`; at most one of them, and then anchored with `^`;
-// a finite repeat may cover a group that holds no unbounded quantifier; few
-// bounded choices in all; only escapes both engines read alike; nothing
-// outside the BMP, so both see the same UTF-16 units.
-// tests/test_regex_native_linear.js holds it.
+// linear time, so it can take the pattern instead of the linear-time engine
+// in safe-regex.js, which costs three to five times as much per character.
+// Two rules, and a pattern passes on either:
+//
+// The simple rule, the original one: every unbounded quantifier is on one
+// character, class or `.`; at most one of them, and then the pattern is
+// anchored with `^` on every branch; a finite repeat may cover a group that
+// holds no unbounded quantifier; few bounded choices in all. One loop whose
+// body cannot be split two ways, exited at most once per position, with
+// bounded work after it.
+//
+// The deterministic rule, for the patterns the simple one declines: dotted
+// identifiers, `[^/]+/[^/]+`, version numbers. On the Glushkov construction
+// the characters, classes and dots are positions. Around every unbounded
+// loop the next character must decide the single way to continue: the
+// positions that can follow a position inside a loop accept pairwise
+// disjoint characters, and so do the positions a match can start at when a
+// loop is among them; a position reaches a follower by one route only, since
+// `(a+)+` reaches `a` from `a` through the inner loop and again through the
+// outer one and that double route is what a backtracking engine explores
+// exponentially; a loop body must not match the empty string, since `(a*)*`
+// iterates emptily without bound. Ambiguity away from any loop, `(pwa|PWA)`,
+// costs a bounded factor and is allowed, as the simple rule allows it. A
+// bounded repeat is a loop only when its body holds an unbounded one, since
+// `(\w+\s?){5}` splits five ways where `(?:[A-F0-9]{2}:){31}` counts. With
+// an unbounded quantifier the pattern must be anchored with `^` on every
+// branch, since an unanchored search retries from each position.
+//
+// Both rules allow only escapes both engines read alike and nothing outside
+// the BMP, so both see the same UTF-16 units. tests/test_regex_native_linear.js
+// holds them: every accepted pattern answers as the linear engine does and
+// stays fast on inputs built to make a backtracking engine retry.
 const NATIVE_ESCAPES = new Set(['d', 'D', 'w', 'W', 's', 'S', 'n', 'r', 't', 'f', 'v', '.', '\\', '/', '^', '$', '|', '?', '*', '+', '(', ')', '[', ']', '{', '}', '-', 'x', 'u'])
-function nativeIsLinear (src) {
-  if (typeof src !== 'string' || src.length > 512) return false
-  for (let i = 0; i < src.length; i++) {
-    const c = src.charCodeAt(i)
-    if (c >= 0xd800 && c <= 0xdfff) return false
-    if (src[i] === '\\') {
-      const e = src[i + 1]
-      if (!NATIVE_ESCAPES.has(e)) return false
-      if (e === 'x' && !/^[0-9a-fA-F]{2}$/.test(src.slice(i + 2, i + 4))) return false
-      if (e === 'u' && !/^[0-9a-fA-F]{4}$/.test(src.slice(i + 2, i + 6))) return false
-      i++
-    }
-  }
-  let ast
-  try { ast = parse(src) } catch { return false }
+const MAX_BOUNDED_CHOICES = 64
+
+const atom = (n) => n.t === 'char' || n.t === 'class' || n.t === 'any'
+
+// Anchored at the start on every top-level branch.
+function anchored (ast) {
+  let top = ast
+  while (top.t === 'group') top = top.child
+  const branches = top.t === 'alt' ? top.opts : [top]
+  const first = (n) => { while (n && n.t === 'group') n = n.child; return n && n.t === 'concat' ? first(n.parts[0]) : n }
+  return branches.every((b) => { const f = first(b); return f && f.t === 'bol' })
+}
+
+function simpleRule (ast) {
   // Per subtree: how many unbounded quantifiers it holds (`u`) and how many
   // bounded choices a backtracking engine could try (`b`), or null where the
-  // shape is not provably linear. A finite repeat of a group is linear when
-  // the group holds no unbounded quantifier: `(?:[A-F0-9]{2}:){31}` has
-  // nothing to retry, and its choices multiply through the nesting.
-  const atom = (n) => n.t === 'char' || n.t === 'class' || n.t === 'any'
+  // shape is not provably linear.
   const info = (n) => {
     switch (n.t) {
       case 'star': case 'plus':
@@ -56,19 +78,154 @@ function nativeIsLinear (src) {
     }
   }
   const r = info(ast)
-  const ok = r !== null
-  const unbounded = ok ? r.u : 0
-  const bounded = ok ? r.b : 0
-  if (!ok || unbounded > 1 || bounded > 64) return false
-  if (unbounded === 1) {
-    // Anchored at the start on every top-level branch.
-    let top = ast
-    while (top.t === 'group') top = top.child
-    const branches = top.t === 'alt' ? top.opts : [top]
-    const first = (n) => { while (n && n.t === 'group') n = n.child; return n && n.t === 'concat' ? first(n.parts[0]) : n }
-    if (!branches.every((b) => { const f = first(b); return f && f.t === 'bol' })) return false
+  if (r === null || r.u > 1 || r.b > MAX_BOUNDED_CHOICES) return false
+  return r.u === 0 || anchored(ast)
+}
+
+// The characters a position accepts: 128 ASCII bits and one bit for "some
+// code point at 128 or above", which keeps two classes with non-ASCII
+// members apart only when one of them has none. Conservative in the right
+// direction: an overlap that is not there only sends a pattern to the
+// linear engine.
+function charSet (node) {
+  const bits = new Uint8Array(128)
+  let high = 0
+  if (node.t === 'any') {
+    bits.fill(1); bits[10] = 0; bits[13] = 0; high = 1
+  } else if (node.t === 'char') {
+    if (node.c < 128) bits[node.c] = 1; else high = 1
+  } else {
+    for (const [lo, hi] of node.ranges) {
+      for (let c = Math.max(0, lo), top = Math.min(127, hi); c <= top; c++) bits[c] = 1
+      if (hi >= 128) high = 1
+    }
+    if (node.neg) { for (let c = 0; c < 128; c++) bits[c] ^= 1; high = 1 }
   }
-  return true
+  return { bits, high }
+}
+
+function overlap (a, b) {
+  if (a.high && b.high) return true
+  for (let c = 0; c < 128; c++) if (a.bits[c] & b.bits[c]) return true
+  return false
+}
+
+// Whether a subtree holds an unbounded quantifier.
+function hasUnbounded (n) {
+  switch (n.t) {
+    case 'star': case 'plus': return true
+    case 'repeat': return n.max === Infinity || hasUnbounded(n.child)
+    case 'quest': case 'group': return hasUnbounded(n.child)
+    case 'concat': return n.parts.some(hasUnbounded)
+    case 'alt': return n.opts.some(hasUnbounded)
+    default: return false
+  }
+}
+
+function deterministicRule (ast) {
+  const sets = []
+  const follow = []
+  const inLoop = []
+  let ok = true
+  let unbounded = 0
+  let bounded = 0
+  let depth = 0
+  // Pairwise disjoint, required when a loop position is among them.
+  const disjoint = (ids) => {
+    const arr = Array.from(ids)
+    if (!arr.some((p) => inLoop[p])) return
+    for (let i = 0; i < arr.length && ok; i++) {
+      for (let j = i + 1; j < arr.length; j++) if (overlap(sets[arr[i]], sets[arr[j]])) { ok = false; return }
+    }
+  }
+  const link = (from, to) => {
+    for (const p of to) {
+      if (follow[from].has(p)) { ok = false; return }
+      follow[from].add(p)
+    }
+  }
+  const empty = () => ({ nullable: true, first: new Set(), last: new Set() })
+  const walk = (n) => {
+    if (!ok) return empty()
+    switch (n.t) {
+      case 'char': case 'class': case 'any': {
+        const id = sets.length
+        sets.push(charSet(n))
+        follow.push(new Set())
+        inLoop.push(depth > 0)
+        return { nullable: false, first: new Set([id]), last: new Set([id]) }
+      }
+      case 'bol': case 'eol': return empty()
+      case 'group': return walk(n.child)
+      case 'star': case 'plus': case 'quest': case 'repeat': {
+        const infinite = n.t === 'star' || n.t === 'plus' || (n.t === 'repeat' && n.max === Infinity)
+        const loops = infinite || (n.t === 'repeat' && n.max > 1 && hasUnbounded(n.child))
+        const optional = n.t === 'star' || n.t === 'quest' || (n.t === 'repeat' && n.min === 0)
+        if (loops) depth++
+        const c = walk(n.child)
+        if (loops) depth--
+        if (infinite) {
+          unbounded++
+          if (c.nullable) ok = false
+        } else if (n.t === 'quest') {
+          bounded += 1
+        } else {
+          bounded += (n.max - n.min)
+          if (!atom(n.child)) bounded += n.max
+        }
+        if (loops) for (const l of c.last) link(l, c.first)
+        return { nullable: c.nullable || optional, first: c.first, last: c.last }
+      }
+      case 'concat': {
+        let acc = empty()
+        for (const part of n.parts) {
+          const r = walk(part)
+          for (const l of acc.last) link(l, r.first)
+          const first = new Set(acc.first)
+          if (acc.nullable) for (const f of r.first) first.add(f)
+          const last = new Set(r.last)
+          if (r.nullable) for (const l of acc.last) last.add(l)
+          acc = { nullable: acc.nullable && r.nullable, first, last }
+        }
+        return acc
+      }
+      case 'alt': {
+        const rs = n.opts.map(walk)
+        const first = new Set()
+        const last = new Set()
+        for (const r of rs) { for (const f of r.first) first.add(f); for (const l of r.last) last.add(l) }
+        return { nullable: rs.some((r) => r.nullable), first, last }
+      }
+      default:
+        ok = false
+        return empty()
+    }
+  }
+  const root = walk(ast)
+  if (!ok) return false
+  disjoint(root.first)
+  for (let p = 0; p < sets.length && ok; p++) disjoint(follow[p])
+  if (!ok) return false
+  if (bounded > MAX_BOUNDED_CHOICES) return false
+  return unbounded === 0 || anchored(ast)
+}
+
+function nativeIsLinear (src) {
+  if (typeof src !== 'string' || src.length > 512) return false
+  for (let i = 0; i < src.length; i++) {
+    const c = src.charCodeAt(i)
+    if (c >= 0xd800 && c <= 0xdfff) return false
+    if (src[i] === '\\') {
+      const e = src[i + 1]
+      if (!NATIVE_ESCAPES.has(e)) return false
+      if (e === 'x' && !/^[0-9a-fA-F]{2}$/.test(src.slice(i + 2, i + 4))) return false
+      if (e === 'u' && !/^[0-9a-fA-F]{4}$/.test(src.slice(i + 2, i + 6))) return false
+      i++
+    }
+  }
+  let ast
+  try { ast = parse(src) } catch { return false }
+  return simpleRule(ast) || deterministicRule(ast)
 }
 
 module.exports = { nativeIsLinear }

package/lib/safe-regex.js

@@ -410,7 +410,8 @@ function __ataSafeRegex () {
       id = states.length
       let isMatch = false
       for (let k = 0; k < pcs.length; k++) if (ops[pcs[k]] === OP_MATCH) { isMatch = true; break }
-      states.push({ pcs: Int32Array.from(pcs), isMatch, next: new Int32Array(128).fill(-2), nextEnd: new Int32Array(128).fill(-2) })
+      // `dead`: an anchored match with no thread left cannot recover.
+      states.push({ pcs: Int32Array.from(pcs), isMatch, dead: anchored && pcs.length === 0, next: new Int32Array(128).fill(-2), nextEnd: new Int32Array(128).fill(-2) })
       stateIds.set(key, id)
       return id
     }
@@ -452,23 +453,36 @@ function __ataSafeRegex () {
       }
       if (id < 0) return testNFA(s)
       let state = states[id]
-      for (let pos = 0; pos < len; pos++) {
+      if (len === 0) return state.isMatch
+      // The last character is stepped with the end-of-input flag set and is
+      // handled after the loop, so the loop body selects no table and tests
+      // no position.
+      const last = len - 1
+      for (let pos = 0; pos < last; pos++) {
         if (state.isMatch) return true
         const c = s.charCodeAt(pos)
-        const atEnd = pos + 1 === len
         let nid
         if (c < 128) {
-          const table = atEnd ? state.nextEnd : state.next
-          nid = table[c]
-          if (nid === -2) { nid = step(state, c, atEnd); table[c] = nid }
+          nid = state.next[c]
+          if (nid === -2) { nid = step(state, c, false); state.next[c] = nid }
         } else {
-          nid = step(state, c, atEnd)
+          nid = step(state, c, false)
         }
         if (nid < 0) return testNFA(s)
         state = states[nid]
-        if (anchored && state.pcs.length === 0) return false
+        if (state.dead) return false
       }
-      return state.isMatch
+      if (state.isMatch) return true
+      const c = s.charCodeAt(last)
+      let nid
+      if (c < 128) {
+        nid = state.nextEnd[c]
+        if (nid === -2) { nid = step(state, c, true); state.nextEnd[c] = nid }
+      } else {
+        nid = step(state, c, true)
+      }
+      if (nid < 0) return testNFA(s)
+      return states[nid].isMatch
     }
 
     return function test (s) {

package/lib/schema-runtime-entry.js

@@ -0,0 +1,21 @@
+'use strict';
+
+// The runtime a schema module (`ata build --mode schema`) imports: the verdict
+// and the errors both come from the interpreted engine walking the embedded
+// schema, so a module is its schema and a few lines. Smaller and quicker to
+// load than generated code, slower per check once warm; see docs/API.md.
+// One interpreter per schema answers both, so the schema is prepared once.
+// It loads lib/interpreter.js, which brings the plan compiler for schemas
+// used often (TIER in lib/interpreter-core.js).
+const { createInterpreter } = require('./interpreter');
+const { errorsOf, interpreterOptions } = require('./error-runtime-entry');
+
+function createValidator(schema, codeOf, options) {
+  const interp = createInterpreter(schema, interpreterOptions(options));
+  return {
+    isValid: (data) => interp.isValid(data),
+    errors: (data) => errorsOf(interp, schema, codeOf, data),
+  };
+}
+
+module.exports = { createValidator };