ata-validator 1.62.0 → 1.63.0

package/lib/kernels/kernels.mjs

@@ -0,0 +1,285 @@
+// One definition per keyword. The check, its params, its message and
+// its enrichment live together, and both IR backends (lib/ir/run.mjs
+// and lib/ir/emit.mjs) read this one definition.
+//
+// A leaf kernel:
+//   code              the public error code (a function of the value for format)
+//   on(v)             the instance types the keyword constrains; others pass
+//   ok(v, n)          the check. One expression over v, n and exported helpers:
+//                     the specializer writes its source in with n replaced by
+//                     the schema's value, so there is no second copy of it.
+//   prepare(n)        optional: the value ok() receives, built once
+//   params, msg, exp  functions of the schema value only: evaluated at build
+//   rank, detail, suggest   the enrichment; detail and suggest are named
+//                     exports, so a module imports only the ones it uses.
+
+import { cpLen, nearest, isObj, typeName, MISSING } from './rt.mjs'
+// The helpers here are ES modules all the way down: a CommonJS file reachable
+// from ata-validator/kernels stays in some bundlers' output unused (see
+// scripts/gen-kernels-cjs.js). What reads the current engine's CommonJS
+// files at compile time lives in ./leaves.mjs.
+import { _deq, duplicatePair } from './unique.mjs'
+import { repr } from './rt.mjs'
+
+// JSON equality and the duplicate search, the functions every engine shares.
+export const deq = _deq
+export const dupPair = duplicatePair
+
+export const isStr = (v) => typeof v === 'string'
+export const isNum = (v) => typeof v === 'number'
+
+// One predicate per JSON type. isType reads this table, and the specializer
+// writes a type's own predicate in place, so both use the same definition.
+export const TYPES = {
+  string: (v) => typeof v === 'string',
+  integer: (v) => Number.isInteger(v),
+  number: (v) => typeof v === 'number' && Number.isFinite(v),
+  boolean: (v) => typeof v === 'boolean',
+  null: (v) => v === null,
+  object: (v) => typeof v === 'object' && v !== null && !Array.isArray(v),
+  array: (v) => Array.isArray(v),
+}
+export const isType = (v, t) => { const f = TYPES[t]; return f !== undefined && f(v) }
+export const isTypes = (v, ts) => { for (let i = 0; i < ts.length; i++) if (isType(v, ts[i])) return true; return false }
+
+export const typeDetail = (received, v, p) => `expected ${p.type}, found ${typeName(v, received)}`
+export const typeSuggest = (v, p) => {
+  if (typeof v !== 'string') return null
+  const t = p.type
+  let ok = false; let what
+  if (t === 'integer') { ok = /^-?\d+$/.test(v); what = 'an integer' } else if (t === 'number') { ok = /^-?\d+(\.\d+)?$/.test(v); what = 'a number' } else if (t === 'boolean') { ok = v === 'true' || v === 'false'; what = 'a boolean' }
+  return ok ? { text: 'value would coerce; enable `coerceTypes` or pass ' + what, kind: 'coercion' } : null
+}
+const typeOk = (v, n) => typeof n === 'string' ? isType(v, n) : isTypes(v, n)
+const typeParams = (n) => ({ type: n })
+const typeMsg = (n) => `must be ${typeof n === 'string' ? n : n.join(', ')}`
+export const type = {
+  kw: 'type', code: 'ATA1001', on: null, ok: typeOk, params: typeParams, msg: typeMsg, exp: (n) => String(n),
+  rank: 1, detail: typeDetail, suggest: typeSuggest,
+}
+// The plain shape's view of a descriptor (richErrors: false): the keyword,
+// its check, its params and its message, the same functions, without the
+// detail and hint the rich shape adds (lib/kernels/table.mjs).
+export const typeP = { kw: 'type', ok: typeOk, params: typeParams, msg: typeMsg }
+
+const minLengthOk = (v, n) => cpLen(v) >= n
+const minLengthParams = (n) => ({ limit: n })
+const minLengthMsg = (n) => `must NOT have fewer than ${n} characters`
+export const minLength = {
+  kw: 'minLength', code: 'ATA2001', on: isStr, ok: minLengthOk,
+  params: minLengthParams, msg: minLengthMsg, exp: (n) => `string with ≥${n} chars`, rank: 2,
+}
+export const minLengthP = { kw: 'minLength', on: isStr, ok: minLengthOk, params: minLengthParams, msg: minLengthMsg }
+const maxLengthOk = (v, n) => cpLen(v) <= n
+const maxLengthParams = (n) => ({ limit: n })
+const maxLengthMsg = (n) => `must NOT have more than ${n} characters`
+export const maxLength = {
+  kw: 'maxLength', code: 'ATA2002', on: isStr, ok: maxLengthOk,
+  params: maxLengthParams, msg: maxLengthMsg, exp: (n) => `string with ≤${n} chars`, rank: 2,
+}
+export const maxLengthP = { kw: 'maxLength', on: isStr, ok: maxLengthOk, params: maxLengthParams, msg: maxLengthMsg }
+const minimumOk = (v, n) => !(v < n)
+const minimumParams = (n) => ({ comparison: '>=', limit: n })
+const minimumMsg = (n) => `must be >= ${n}`
+export const minimum = {
+  kw: 'minimum', code: 'ATA2003', on: isNum, ok: minimumOk,
+  params: minimumParams, msg: minimumMsg, exp: (n) => `≥${n}`, rank: 2,
+}
+export const minimumP = { kw: 'minimum', on: isNum, ok: minimumOk, params: minimumParams, msg: minimumMsg }
+const maximumOk = (v, n) => !(v > n)
+const maximumParams = (n) => ({ comparison: '<=', limit: n })
+const maximumMsg = (n) => `must be <= ${n}`
+export const maximum = {
+  kw: 'maximum', code: 'ATA2004', on: isNum, ok: maximumOk,
+  params: maximumParams, msg: maximumMsg, exp: (n) => `≤${n}`, rank: 2,
+}
+export const maximumP = { kw: 'maximum', on: isNum, ok: maximumOk, params: maximumParams, msg: maximumMsg }
+const patternOk = (v, n) => n.test(v)
+const patternParams = (n) => ({ pattern: n })
+const patternMsg = (n) => `must match pattern "${n}"`
+export const pattern = {
+  kw: 'pattern', code: 'ATA2013', on: isStr, ok: patternOk, prepare: (n) => new RegExp(n, 'u'),
+  params: patternParams, msg: patternMsg, exp: (n) => `string matching /${n}/`, rank: 2,
+}
+export const patternP = { kw: 'pattern', on: isStr, ok: patternOk, prepare: (n) => new RegExp(n, 'u'), params: patternParams, msg: patternMsg }
+
+// A format's detail; the format keyword itself is in ./leaves.mjs.
+export const formatDetail = (received, v, p) => `not a valid ${p.format}: ${received}`
+// What a format's error says, shared by the compile-time descriptor in
+// ./leaves.mjs and the table interpreter (./table.mjs); the check itself is
+// the format's function, the code and hint come with it.
+const formatOk = (v, f) => f(v)
+const formatParams = (n) => ({ format: n })
+const formatMsg = (n) => `must match format "${n}"`
+export const formatK = { kw: 'format', on: isStr, ok: formatOk, params: formatParams, msg: formatMsg, exp: (n) => `format '${n}'`, rank: 2, detail: formatDetail }
+export const formatP = { kw: 'format', on: isStr, ok: formatOk, params: formatParams, msg: formatMsg }
+export const makeHintSuggest = (hint) => (v) => { if (typeof v !== 'string') return null; const t = hint(v); return t ? { text: t, kind: 'format' } : null }
+
+// Structural kernels: their errors name the container, not a child.
+export const requiredDetail = (received, v, p) => `missing required property "${p.missingProperty}"`
+export const requiredSuggest = (v, p) => {
+  if (v === MISSING || !v || typeof v !== 'object') return null
+  const keys = Object.keys(v)
+  if (keys.length > 64) return null
+  const best = nearest(p.missingProperty, keys)
+  return best === null ? null : { text: `did you mean \`${p.missingProperty}\` instead of \`${best}\`?`, kind: 'similar-key' }
+}
+const requiredParams = (k) => ({ missingProperty: k })
+const requiredMsg = (k) => `must have required property '${k}'`
+export const required = {
+  kw: 'required', code: 'ATA7001', rank: 0,
+  params: requiredParams, msg: requiredMsg, exp: (k) => `property '${k}'`,
+  detail: requiredDetail, suggest: requiredSuggest,
+}
+export const requiredP = { kw: 'required', params: requiredParams, msg: requiredMsg }
+
+export const additionalDetail = (received, v, p) => `unknown property "${p.additionalProperty}"`
+const additionalParams = (k) => ({ additionalProperty: k })
+const additionalMsg = () => 'must NOT have additional properties'
+export const additionalProperties = {
+  kw: 'additionalProperties', code: 'ATA7002', rank: 0,
+  params: additionalParams, msg: additionalMsg, exp: () => undefined,
+  detail: additionalDetail,
+}
+export const additionalP = { kw: 'additionalProperties', params: additionalParams, msg: additionalMsg }
+
+// The current engine has no expected text for the exclusive bounds but words
+// their detail as if it had one: "expected undefined, found 1".
+export const exclusiveDetail = (received) => `expected undefined, found ${received}`
+const exclusiveMinimumOk = (v, n) => !(v <= n)
+const exclusiveMinimumParams = (n) => ({ comparison: '>', limit: n })
+const exclusiveMinimumMsg = (n) => `must be > ${n}`
+export const exclusiveMinimum = {
+  kw: 'exclusiveMinimum', code: 'ATA2005', on: isNum, ok: exclusiveMinimumOk,
+  params: exclusiveMinimumParams, msg: exclusiveMinimumMsg, exp: () => undefined, rank: 2,
+  detail: exclusiveDetail,
+}
+export const exclusiveMinimumP = { kw: 'exclusiveMinimum', on: isNum, ok: exclusiveMinimumOk, params: exclusiveMinimumParams, msg: exclusiveMinimumMsg }
+const exclusiveMaximumOk = (v, n) => !(v >= n)
+const exclusiveMaximumParams = (n) => ({ comparison: '<', limit: n })
+const exclusiveMaximumMsg = (n) => `must be < ${n}`
+export const exclusiveMaximum = {
+  kw: 'exclusiveMaximum', code: 'ATA2006', on: isNum, ok: exclusiveMaximumOk,
+  params: exclusiveMaximumParams, msg: exclusiveMaximumMsg, exp: () => undefined, rank: 2,
+  detail: exclusiveDetail,
+}
+export const exclusiveMaximumP = { kw: 'exclusiveMaximum', on: isNum, ok: exclusiveMaximumOk, params: exclusiveMaximumParams, msg: exclusiveMaximumMsg }
+const multipleOfOk = (v, n) => n !== 0 && (Number.isInteger(v / n) || Math.abs(v / n - Math.round(v / n)) < 1e-9)
+const multipleOfParams = (n) => ({ multipleOf: n })
+const multipleOfMsg = (n) => `must be multiple of ${n}`
+export const multipleOf = {
+  kw: 'multipleOf', code: 'ATA2007', on: isNum, ok: multipleOfOk,
+  params: multipleOfParams, msg: multipleOfMsg, exp: () => undefined, rank: 2,
+}
+export const multipleOfP = { kw: 'multipleOf', on: isNum, ok: multipleOfOk, params: multipleOfParams, msg: multipleOfMsg }
+export const isArr = (v) => Array.isArray(v)
+export const isObjV = (v) => typeof v === 'object' && v !== null && !Array.isArray(v)
+const minItemsOk = (v, n) => v.length >= n
+const minItemsParams = (n) => ({ limit: n })
+const minItemsMsg = (n) => `must NOT have fewer than ${n} items`
+export const minItems = {
+  kw: 'minItems', code: 'ATA2008', on: isArr, ok: minItemsOk,
+  params: minItemsParams, msg: minItemsMsg, exp: () => undefined, rank: 2,
+}
+export const minItemsP = { kw: 'minItems', on: isArr, ok: minItemsOk, params: minItemsParams, msg: minItemsMsg }
+const maxItemsOk = (v, n) => v.length <= n
+const maxItemsParams = (n) => ({ limit: n })
+const maxItemsMsg = (n) => `must NOT have more than ${n} items`
+export const maxItems = {
+  kw: 'maxItems', code: 'ATA2009', on: isArr, ok: maxItemsOk,
+  params: maxItemsParams, msg: maxItemsMsg, exp: () => undefined, rank: 2,
+}
+export const maxItemsP = { kw: 'maxItems', on: isArr, ok: maxItemsOk, params: maxItemsParams, msg: maxItemsMsg }
+const minPropertiesOk = (v, n) => Object.keys(v).length >= n
+const minPropertiesParams = (n) => ({ limit: n })
+const minPropertiesMsg = (n) => `must NOT have fewer than ${n} properties`
+export const minProperties = {
+  kw: 'minProperties', code: 'ATA2010', on: isObjV, ok: minPropertiesOk,
+  params: minPropertiesParams, msg: minPropertiesMsg, exp: () => undefined, rank: 2,
+}
+export const minPropertiesP = { kw: 'minProperties', on: isObjV, ok: minPropertiesOk, params: minPropertiesParams, msg: minPropertiesMsg }
+const maxPropertiesOk = (v, n) => Object.keys(v).length <= n
+const maxPropertiesParams = (n) => ({ limit: n })
+const maxPropertiesMsg = (n) => `must NOT have more than ${n} properties`
+export const maxProperties = {
+  kw: 'maxProperties', code: 'ATA2011', on: isObjV, ok: maxPropertiesOk,
+  params: maxPropertiesParams, msg: maxPropertiesMsg, exp: () => undefined, rank: 2,
+}
+export const maxPropertiesP = { kw: 'maxProperties', on: isObjV, ok: maxPropertiesOk, params: maxPropertiesParams, msg: maxPropertiesMsg }
+export const isAny = () => true
+// The guard a kernel's `on` names, by identity: the IR writes the name, and a
+// minifier that renames the functions (the front end in a browser bundle)
+// must not change it.
+export const GUARD_NAME = /* @__PURE__ */ (() => new Map([[isStr, 'isStr'], [isNum, 'isNum'], [isArr, 'isArr'], [isObjV, 'isObjV'], [isAny, 'isAny']]))()
+const constOk = (v, n) => deq(v, n)
+const constParams = (n) => ({ allowedValue: n })
+const constMsg = () => 'must be equal to constant'
+const constExp = (n) => repr(n)
+export const constK = {
+  kw: 'const', code: 'ATA6002', on: isAny, ok: constOk,
+  params: constParams, msg: constMsg, exp: constExp, rank: 2,
+}
+export const constP = { kw: 'const', on: isAny, ok: constOk, params: constParams, msg: constMsg }
+// const and enum whose values are all primitives: equal to one exactly when
+// === to it (JSON numbers have no NaN, and 0 and -0 are one value to JSON
+// equality too), so a bundle of such schemas carries no deep equality.
+const constPrimOk = (v, n) => v === n
+export const constPrimK = {
+  kw: 'const', code: 'ATA6002', on: isAny, ok: constPrimOk,
+  params: constParams, msg: constMsg, exp: constExp, rank: 2,
+}
+export const constPrimP = { kw: 'const', on: isAny, ok: constPrimOk, params: constParams, msg: constMsg }
+export const enumSuggest = (v, p) => {
+  if (typeof v !== 'string') return null
+  const a = p.allowedValues
+  if (!Array.isArray(a) || a.length === 0 || a.length > 30) return null
+  const best = nearest(v, a)
+  return best === null ? null : { text: `did you mean \`${best}\`?`, kind: 'typo' }
+}
+const enumOk = (v, n) => n.some((x) => deq(v, x))
+const enumParams = (n) => ({ allowedValues: n })
+const enumMsg = () => 'must be equal to one of the allowed values'
+const enumExp = (n) => `one of [${n.map(repr).join(', ')}]`
+export const enumK = {
+  kw: 'enum', code: 'ATA6001', on: isAny, ok: enumOk,
+  params: enumParams, msg: enumMsg, exp: enumExp, rank: 2,
+  suggest: enumSuggest,
+}
+export const enumP = { kw: 'enum', on: isAny, ok: enumOk, params: enumParams, msg: enumMsg }
+const enumPrimOk = (v, n) => n.indexOf(v) !== -1
+export const enumPrimK = {
+  kw: 'enum', code: 'ATA6001', on: isAny, ok: enumPrimOk,
+  params: enumParams, msg: enumMsg, exp: enumExp, rank: 2,
+  suggest: enumSuggest,
+}
+export const enumPrimP = { kw: 'enum', on: isAny, ok: enumPrimOk, params: enumParams, msg: enumMsg }
+// A keyword whose message names what it found: fail() returns the params and
+// message of the failure, or null.
+export const uniqueFail = (v, n) => { if (n !== true) return null; const p = dupPair(v); return p === null ? null : { params: { i: p[0], j: p[1] }, msg: `must NOT have duplicate items (items ## ${p[1]} and ${p[0]} are identical)` } }
+export const uniqueItems = {
+  kw: 'uniqueItems', code: 'ATA2012', on: isArr, rank: 2, exp: () => undefined,
+  fail: uniqueFail,
+}
+
+
+// anyOf and oneOf: the current engine's own collapse (lib/branch-collapse.js),
+// which picks the closest branch by error count and severity.
+import { __ataCollapse } from './collapse.mjs'
+export const collapse = __ataCollapse
+export const not = { code: 'ATA4005', keyword: 'not', msg: 'must NOT be valid', rank: 3 }
+export const branchRank = 3
+
+// unevaluatedProperties false: one error per property; unevaluatedItems
+// false: one error naming the first unevaluated index, worded as a length.
+export const unevaluatedDetail = (received, v, p) => `unevaluated property "${p.unevaluatedProperty}"`
+export const unevaluatedProperties = { code: 'ATA7003', msg: 'must NOT have unevaluated properties', rank: 0, detail: unevaluatedDetail }
+export const unevaluatedItems = { code: 'ATA7004', rank: 0 }
+
+// The false schema.
+export const falseSchema = { code: 'ATA4005', keyword: 'not', msg: 'boolean schema is false', rank: 3 }
+// contains, minContains, maxContains: one error, keyword contains.
+export const contains = { code: 'ATA7007', rank: 2 }
+
+
+// Keywords that carry no constraint.
+export const ANNOTATIONS = new Set(['$schema', '$id', '$comment', 'title', 'description', 'default', 'examples', 'deprecated', 'readOnly', 'writeOnly'])

package/lib/kernels/leaves.mjs

@@ -0,0 +1,28 @@
+// The leaf keywords as the IR's front end and closures read them
+// (lib/ir/front.mjs), with the format keyword, which reads the current
+// engine's CommonJS files: its run-time checks, codes and hints. This module
+// is not part of ata-validator/kernels; a module written by the IR imports
+// none of it.
+import { minLength, maxLength, minimum, maximum, exclusiveMinimum, exclusiveMaximum, multipleOf, pattern, minItems, maxItems, minProperties, maxProperties, constK, enumK, uniqueItems, formatK } from './kernels.mjs'
+
+// Formats are the current engine's own: its run-time checks (lib/formats.js
+// formatChecks), its codes (lib/error-codes.js codeFor) and its hints
+// (lib/suggestions.js; generated code carries only its format's hint, see lib/ir/emit.mjs). The generated code is its code generator's
+// (FORMAT_CODEGEN, written in by ir/emit.mjs). A format it does not know is
+// not checked, as there.
+import formats from '../formats.js'
+import errorCodes from '../error-codes.js'
+import suggestions from '../suggestions.js'
+const formatCheck = (n) => { const fc = formats.formatChecks(); return Object.prototype.hasOwnProperty.call(fc, n) ? fc[n] : null }
+// The closures call it; a written module carries only its format's hint (lib/ir/emit.mjs).
+export function formatSuggest (v, p) { return suggestions.suggestFormat(p.format, v) }
+export const format = {
+  code: (n) => errorCodes.codeFor('format', n), on: formatK.on, ok: formatK.ok,
+  // null: a format the current engine does not know, which it does not check.
+  prepare: (n) => formatCheck(n),
+  params: formatK.params, msg: formatK.msg, exp: formatK.exp, rank: formatK.rank,
+  detail: formatK.detail,
+  suggest: formatSuggest,
+}
+
+export const LEAVES = { minLength, maxLength, minimum, maximum, exclusiveMinimum, exclusiveMaximum, multipleOf, pattern, format, minItems, maxItems, minProperties, maxProperties, const: constK, enum: enumK, uniqueItems }

package/lib/kernels/order.mjs

@@ -0,0 +1,25 @@
+// The errors into schema order, a module of its own so a page that never
+// sorts (most forms) does not carry it, and ata-validator/plan can load it
+// when a plan asks.
+import { rankFor } from './rank.mjs'
+
+// The errors in schema declaration order, as the current engine orders them:
+// by the rank of each error's schemaPath in the root schema (rankFor of
+// lib/schema-order.js, copied in ./rank.mjs; lib/aot-order.js sorts by it too), stable, and
+// a collapsed error's branch errors the same way, in a copy.
+const after = (a, b) => { const m = Math.min(a.length, b.length); for (let i = 0; i < m; i++) if (a[i] !== b[i]) return a[i] > b[i]; return a.length > b.length }
+export function ordered (root, list) {
+  const n = list.length
+  if (n === 1 && !Array.isArray(list[0].branchErrors)) return list
+  const out = new Array(n); const keys = new Array(n)
+  for (let i = 0; i < n; i++) {
+    let e = list[i]
+    if (Array.isArray(e.branchErrors) && e.branchErrors.length) { const b = ordered(root, e.branchErrors); if (b !== e.branchErrors) e = Object.assign({}, e, { branchErrors: b }) }
+    const k = rankFor(root, e.schemaPath) || []
+    let j = i - 1
+    while (j >= 0 && after(keys[j], k)) { keys[j + 1] = keys[j]; out[j + 1] = out[j]; j-- }
+    keys[j + 1] = k; out[j + 1] = e
+  }
+  for (let i = 0; i < n; i++) if (out[i] !== list[i]) return out
+  return list
+}

package/lib/kernels/plan-rich.mjs

@@ -0,0 +1,17 @@
+// ata-validator/plan-rich: fromPlan for plans with ata's rich errors (code,
+// expected, received, detail, suggestion), and with plain ones. A separate
+// entry so a page reading plain plans carries none of this: the descriptors
+// that carry the rich fields, and the format hints the module writer writes
+// into its modules (lib/ir/emit-deps.mjs).
+import { tableRich } from './table.mjs'
+import { fromPlan as fromAnyPlan, PLAN_VERSION } from './plan.mjs'
+import { type, required, additionalProperties, enumK, constK, formatK, minLength, maxLength, minimum, maximum, exclusiveMinimum, exclusiveMaximum, multipleOf, pattern, minItems, maxItems, minProperties, maxProperties } from './kernels.mjs'
+import { FORMAT_HINTS } from '../ir/emit-deps.mjs'
+
+const RICH = { tableRich, type, required, additionalProperties, enumK, constK, formatK, minLength, maxLength, minimum, maximum, exclusiveMinimum, exclusiveMaximum, multipleOf, pattern, minItems, maxItems, minProperties, maxProperties }
+// A format's hint, as the module writer builds it from the same source.
+const hint = (name) => { const h = Object.prototype.hasOwnProperty.call(FORMAT_HINTS, name) ? FORMAT_HINTS[name] : null; return h === null ? undefined : (v) => { const t = h(v); return t ? { text: t, kind: 'format' } : null } }
+
+export { PLAN_VERSION }
+// The validator for a plan, rich or plain.
+export const fromPlan = (plan) => fromAnyPlan(plan, { RICH, hint, tableRich })

package/lib/kernels/plan.d.ts

@@ -0,0 +1,9 @@
+/** A plan written by tablePlan in ata-validator/ir. */
+export interface Plan { v: 1; ata?: string; rich: boolean; P: unknown[]; F: unknown[]; rel: boolean; sk: unknown; uses: string[] }
+export interface PlanValidator {
+  validate(data: unknown): { valid: true; data: unknown; errors: readonly [] } | { valid: false; errors: Array<Record<string, unknown>> }
+  isValid(data: unknown): boolean
+}
+export declare const PLAN_VERSION: 1
+/** The validator for a plan, once the kernels it names are loaded. */
+export declare function fromPlan(plan: Plan): Promise<PlanValidator>

package/lib/kernels/plan.mjs

@@ -0,0 +1,128 @@
+// ata-validator/plan: validators for schemas that arrive at run time, as
+// plans a server writes with tablePlan (ata-validator/ir) instead of schemas.
+// The heavy work (references, dialects, normalization) is done where the plan
+// is written; the page carries the table interpreter and, loaded when a plan
+// names them, the format checks, the error order and the rich error shape.
+// The verdicts, errors and filled defaults are those of the server's
+// validator for the same schema. This entry reads plans with plain errors
+// (richErrors: false); ata-validator/plan-rich reads both, and only a page
+// that imports it carries the rich error shape.
+//
+//   const v = await fromPlan(await (await fetch('/plans/signup.json')).json())
+//   v.validate(data)
+//
+// A plan names kernels in fixed places only (each step's handler, a leaf's
+// descriptor, check and hint); every other value is the schema's own data
+// and is used as data.
+import { tablePlain, tableFill, tType, tProps, tReq, tClosed, tAddl, tLeaf, tItems, tTuple, tAll, tRef, tNot, tIf, tDepReq, tFalse } from './table.mjs'
+import { typeP, requiredP, additionalP, enumP, constP, formatP, uniqueItems, minLengthP, maxLengthP, minimumP, maximumP, exclusiveMinimumP, exclusiveMaximumP, multipleOfP, patternP, minItemsP, maxItemsP, minPropertiesP, maxPropertiesP } from './kernels.mjs'
+
+import ATA_VERSION from '../version.js'
+
+const CORE = { tablePlain, tableFill, tType, tProps, tReq, tClosed, tAddl, tLeaf, tItems, tTuple, tAll, tRef, tNot, tIf, tDepReq, tFalse, typeP, requiredP, additionalP, enumP, constP, formatP, uniqueItems, minLengthP, maxLengthP, minimumP, maximumP, exclusiveMinimumP, exclusiveMaximumP, multipleOfP, patternP, minItemsP, maxItemsP, minPropertiesP, maxPropertiesP }
+export const PLAN_VERSION = 1
+
+const warned = new Set()
+const fail = (why) => { throw new Error('ata-validator/plan: ' + why) }
+// Names an object literal would reorder or treat specially; a plan never
+// carries them (lib/ir/table.mjs refuses such schemas).
+const safeName = (k) => k !== '__proto__' && !/^(0|[1-9][0-9]*)$/.test(k)
+
+const HANDLERS = new Set(['tType', 'tProps', 'tReq', 'tClosed', 'tAddl', 'tLeaf', 'tItems', 'tTuple', 'tAll', 'tRef', 'tNot', 'tIf', 'tDepReq', 'tFalse'])
+const isInt = (n) => Number.isInteger(n) && n >= 0
+const isStrings = (a) => Array.isArray(a) && a.every((x) => typeof x === 'string')
+
+// Every step checked as it is read, so a plan that is not one the writer
+// makes is refused here, by what is wrong with it, and never runs.
+function decode (P, K, hints) {
+  if (!Array.isArray(P) || P.length === 0) fail('a plan has at least its root node')
+  const kernel = (n) => typeof n === 'string' && K[n] !== undefined ? K[n] : fail(`unknown kernel ${JSON.stringify(n)}`)
+  const descriptor = (n) => { const D = kernel(n); return D !== null && typeof D === 'object' && typeof D.kw === 'string' && (typeof D.ok === 'function' || typeof D.fail === 'function') ? D : fail(`${JSON.stringify(n)} is not a keyword descriptor`) }
+  const ref = (r) => typeof r === 'number' ? (isInt(r) && r < P.length ? r : fail('a node index out of range')) : node(r)
+  // The node's properties step, for tReq, tClosed and tAddl to name.
+  const propsStep = (N, j) => j === -1 || (isInt(j) && j < N.length && Array.isArray(N[j]) && N[j][0] === 'tProps') ? j : fail('a step names a properties step that is not one')
+  function node (N) {
+    if (!Array.isArray(N)) fail('a node is not a list of steps')
+    return N.map((t) => step(t, N))
+  }
+  function step (t, N) {
+    if (!Array.isArray(t) || !HANDLERS.has(t[0])) fail(`a step whose handler is ${JSON.stringify(Array.isArray(t) ? t[0] : t)}`)
+    const out = t.slice(); out[0] = kernel(t[0])
+    switch (t[0]) {
+      // A list may hold what draft 3 allowed there; the check only reads it.
+      case 'tType': if (!(typeof t[1] === 'string' || Array.isArray(t[1]))) fail('tType takes a type or a list'); break
+      case 'tProps': {
+        if (t[1] === null || typeof t[1] !== 'object' || Array.isArray(t[1])) fail('tProps takes an object')
+        const o = {}
+        for (const k of Object.keys(t[1])) { if (!safeName(k)) fail(`a property name ${JSON.stringify(k)} a plan cannot carry`); o[k] = ref(t[1][k]) }
+        out[1] = o; break
+      }
+      case 'tReq':
+        if (isStrings(t[1])) break
+        if (!(isInt(t[1]) && t[1] < 2 ** 31)) fail('tReq takes names or a mask')
+        if (propsStep(N, t[2]) === -1) fail('a required mask with no properties step'); break
+      case 'tClosed': propsStep(N, t[1]); break
+      case 'tAddl': out[1] = ref(t[1]); propsStep(N, t[2]); break
+      case 'tItems': out[1] = ref(t[1]); if (!isInt(t[2])) fail('tItems takes a first index'); break
+      case 'tRef': case 'tNot': out[1] = ref(t[1]); break
+      case 'tTuple': case 'tAll': if (!Array.isArray(t[1])) fail(t[0] + ' takes a list of nodes'); out[1] = t[1].map(ref); break
+      case 'tIf': out[1] = ref(t[1]); out[2] = t[2] === -1 ? -1 : ref(t[2]); out[3] = t[3] === -1 ? -1 : ref(t[3]); break
+      case 'tDepReq':
+        if (!Array.isArray(t[1]) || t[1].length % 2 !== 0) fail('tDepReq takes names and lists of names')
+        for (let j = 0; j < t[1].length; j += 2) if (typeof t[1][j] !== 'string' || !isStrings(t[1][j + 1])) fail('tDepReq takes names and lists of names')
+        break
+      case 'tFalse': break
+      case 'tLeaf':
+        out[1] = descriptor(t[1])
+        if (t.length === 6) {
+          if (out[1].kw !== 'format' || typeof t[3] !== 'string' || !/^fmt_\w+$/.test(t[3]) || typeof t[4] !== 'string') fail('a format step is not one')
+          out[3] = kernel(t[3]); out[5] = t[5] == null ? undefined : hints(t[5])
+        } else if (t.length !== 3) fail('a leaf step has a descriptor and its argument')
+        break
+    }
+    return out
+  }
+  return P.map(node)
+}
+
+// The defaults table: [defaults [k, v, ...], properties [k, f, ...],
+// prefixItems [f or -1, ...], items f or -1, dependentSchemas [k, f, ...],
+// in place [f, ...]], every f an index into it.
+function checkFill (F) {
+  if (!Array.isArray(F)) fail('the defaults table is not a list')
+  const f = (i) => i === -1 || (isInt(i) && i < F.length) || fail('a defaults index out of range')
+  const pairs = (a, idx) => { if (!Array.isArray(a) || a.length % 2 !== 0) fail('a defaults entry is not pairs'); for (let j = 0; j < a.length; j += 2) { if (typeof a[j] !== 'string') fail('a defaults name is not a string'); if (idx) f(a[j + 1]) } }
+  for (const e of F) {
+    if (!Array.isArray(e) || e.length !== 6) fail('a defaults entry has six parts')
+    pairs(e[0], false); pairs(e[1], true)
+    if (!Array.isArray(e[2])) fail('a defaults entry is not well formed'); e[2].forEach(f)
+    f(e[3]); pairs(e[4], true)
+    if (!Array.isArray(e[5])) fail('a defaults entry is not well formed'); e[5].forEach(f)
+  }
+  return F
+}
+
+// The validator for a plan, once the kernels it names are loaded. `rich`:
+// what ata-validator/plan-rich passes in.
+export async function fromPlan (plan, rich = null) {
+  if (plan === null || typeof plan !== 'object' || plan.v !== PLAN_VERSION) fail(`a plan of version ${PLAN_VERSION} is expected`)
+  const uses = Array.isArray(plan.uses) ? plan.uses : fail('the plan does not list its kernels')
+  // The page and the server decide alike when both run the same ata-validator.
+  if (typeof plan.ata === 'string' && plan.ata !== ATA_VERSION && !warned.has(plan.ata)) {
+    warned.add(plan.ata)
+    console.warn(`ata-validator/plan: this plan was written by ata-validator ${plan.ata} and is read by ${ATA_VERSION}; a page and a server agree on every document only on the same version.`)
+  }
+  const K = Object.assign(Object.create(null), CORE)
+  const loads = []
+  if (plan.rich) { if (rich === null) fail('this plan has rich errors: read it with ata-validator/plan-rich'); Object.assign(K, rich.RICH) }
+  if (uses.some((n) => /^fmt_\w+_s$/.test(n))) loads.push(import('./formats-small.mjs').then((m) => Object.assign(K, m)))
+  if (uses.some((n) => /^fmt_\w+$/.test(n) && !/_s$/.test(n))) loads.push(import('./formats.mjs').then((m) => Object.assign(K, m)))
+  let order
+  if (plan.sk) loads.push(import('./order.mjs').then((m) => { order = (e) => m.ordered(plan.sk, e) }))
+  await Promise.all(loads)
+  for (const n of uses) if (n !== 'ordered' && K[n] === undefined) fail(`this plan needs "${n}", which this version of ata-validator does not have`)
+  const P = decode(plan.P, K, (name) => rich ? rich.hint(name) : undefined)
+  const F = checkFill(plan.F === undefined ? [] : plan.F)
+  const fill = F.length ? tableFill : null
+  return plan.rich ? rich.tableRich(P, F, fill, plan.rel, order) : tablePlain(P, F, fill, order)
+}