ata-validator 1.62.1 → 1.63.0

package/lib/kernels/table.mjs

@@ -0,0 +1,182 @@
+// The table backend's interpreter: a schema the IR's front end has read,
+// written by lib/ir/table.mjs as a plan of steps (one array per schema
+// node), and run here. Paths, schema paths, params and messages are made
+// from the step and the descriptor it names, as the module writer writes
+// them out (lib/ir/emit.mjs), so the errors are the same, field for field and
+// in order. A page with many forms carries this once and each form as data.
+//
+// A step is [handler, ...]: the handler is the function below that runs it,
+// named by the plan, so a bundle carries the handlers its plans use and no
+// other. A node is an array of steps, run in the schema's own key order; P
+// is the plan, its nodes by index, the root first. A handler returns false
+// to stop a verdict at its first failure; collecting errors (e an array), it
+// pushes them and goes on.
+import { own, isObj, keysOf, seg, copyOf, setOwn, E, relate } from './rt.mjs'
+import { type, typeP, required, requiredP, additionalProperties, additionalP, not as notK, falseSchema } from './kernels.mjs'
+
+const PN = ({}).__proto__ === Object.prototype
+const NONE = Object.freeze([])
+// Whether x is an object with Object.prototype: then a defined value under a
+// name Object.prototype lacks is an own property.
+const plainOf = (x) => isObj(x) && (PN ? x.__proto__ : Object.getPrototypeOf(x)) === Object.prototype
+// A name is present the current engine's way: an own key, and for a name
+// Object.prototype lacks on such an object, a defined value.
+const has = (x, p, k) => k in Object.prototype ? own(x, k) : p || own(x, k)
+// A name as a JSON pointer segment; most names need no escape.
+const esc = (k) => k.indexOf('~') === -1 && k.indexOf('/') === -1 ? k : seg(k)
+// Paths are built only for a walk that collects errors; a verdict reads none.
+const at = (e, a, b) => e === null ? '' : a + b
+// A node: by its index in P (shared, or reached again), or written in place.
+const nd = (c, r) => typeof r === 'number' ? c.P[r] : r
+// Whether the node's properties step (index j, -1 for none) names k.
+const known = (N, j, k) => j !== -1 && own(N[j][1], k)
+
+// [tType, n]
+export const tType = (c, t, x, e, s, path, sp, v) => c.T.ok(x, t[1]) || (e !== null && (c.push(e, c.T, path, sp + '/type', t[1], v, s), true))
+// [tProps, { name: node, ... }], the schema's own order (the plan writer
+// refuses names an object literal would reorder or treat specially).
+export function tProps (c, t, x, e, s, path, sp) {
+  if (!isObj(x)) return true
+  const p = plainOf(x); const l = t[1]
+  for (const k in l) {
+    const y = x[k]
+    if (y !== undefined && has(x, p, k) && !c.run(nd(c, l[k]), y, e, s, at(e, path + '/', esc(k)), at(e, sp + '/properties/', esc(k)), y) && e === null) return false
+  }
+  return true
+}
+// [tReq, [name, ...]], or [tReq, mask, the properties step] where the names
+// are the properties step's own, in its order: bit i for its i-th name.
+export function tReq (c, t, x, e, s, path, sp, v, N) {
+  if (!isObj(x)) return true
+  const p = plainOf(x)
+  const l = typeof t[1] === 'number' ? Object.keys(N[t[2]][1]).filter((_, i) => t[1] >>> i & 1) : t[1]
+  for (const r of l) if (x[r] === undefined || !has(x, p, r)) { if (e === null) return false; c.push(e, c.R, path, sp + '/required', r, v, s) }
+  return true
+}
+// additionalProperties false: [tClosed, the node's properties step or -1]
+export function tClosed (c, t, x, e, s, path, sp, v, N) {
+  if (!isObj(x)) return true
+  const p = plainOf(x)
+  for (const k in x) if (!known(N, t[1], k) && (p || own(x, k))) { if (e === null) return false; c.push(e, c.A, path, sp + '/additionalProperties', k, v, s) }
+  return true
+}
+// additionalProperties a schema: [tAddl, node, the properties step or -1]
+export function tAddl (c, t, x, e, s, path, sp, v, N) {
+  if (isObj(x)) for (const k of keysOf(x)) if (!known(N, t[2], k) && !c.run(nd(c, t[1]), x[k], e, s, at(e, path + '/', esc(k)), at(e, sp, '/additionalProperties'), x[k]) && e === null) return false
+  return true
+}
+// A leaf: [tLeaf, descriptor, n], or for a format [tLeaf, descriptor, n,
+// check, code, hint]. A descriptor that prepares its argument (pattern) has
+// it prepared on first use, kept as t[3].
+export function tLeaf (c, t, x, e, s, path, sp, v) {
+  const K = t[1]
+  if (K.on && !K.on(x)) return true
+  if (t.length < 4) t[3] = K.prepare ? K.prepare(t[2]) : t[2]
+  const f = K.fail ? K.fail(x, t[2]) : K.ok(x, t[3]) ? null : 0
+  if (f === null) return true
+  if (e === null) return false
+  c.push(e, K, path, sp + '/' + K.kw, t[2], v, s, f || null, t[4], t[5])
+  return true
+}
+// [tItems, node, first index]
+export function tItems (c, t, x, e, s, path, sp) {
+  if (Array.isArray(x)) for (let j = t[2]; j < x.length; j++) if (!c.run(nd(c, t[1]), x[j], e, s, at(e, path + '/', j), at(e, sp, '/items'), x[j]) && e === null) return false
+  return true
+}
+// [tTuple, [node, ...]]
+export function tTuple (c, t, x, e, s, path, sp) {
+  if (Array.isArray(x)) for (let j = 0; j < t[1].length && j < x.length; j++) if (!c.run(nd(c, t[1][j]), x[j], e, s, at(e, path + '/', j), at(e, sp + '/prefixItems/', j), x[j]) && e === null) return false
+  return true
+}
+// A call on the same value through $ref or allOf that comes back to a node
+// already running on it is cut, the inner entry adding no error, as the
+// current engine cuts it.
+function here (c, n, x, e, s, path, sp, v) {
+  let on = c.a.get(n)
+  if (on === undefined) c.a.set(n, on = new Set())
+  if (on.has(x)) return true
+  on.add(x)
+  try { return c.run(nd(c, n), x, e, s, path, sp, v) } finally { on.delete(x) }
+}
+// [tAll, [node, ...]]
+export function tAll (c, t, x, e, s, path, sp, v) {
+  for (let j = 0; j < t[1].length; j++) if (!here(c, t[1][j], x, e, s, path, at(e, sp + '/allOf/', j), v) && e === null) return false
+  return true
+}
+// $ref: [tRef, node], same value, same paths.
+export const tRef = (c, t, x, e, s, path, sp, v) => here(c, t[1], x, e, s, path, sp, v) || e !== null
+// Made in a pure call, so a bundle whose plans have no `not` drops it: a
+// property read at the top level would be kept.
+const NOT = /* @__PURE__ */ (() => ({ kw: 'not', code: notK.code, rank: notK.rank, params: () => ({}), msg: () => notK.msg, exp: () => void 0 }))()
+// [tNot, node]
+export function tNot (c, t, x, e, s, path, sp, v) {
+  if (!c.run(nd(c, t[1]), x, null, true, path, sp + '/not', v)) return true
+  if (e === null) return false
+  c.push(e, NOT, path, sp + '/not', 0, v, s)
+  return true
+}
+// [tIf, if node, then node or -1, else node or -1]
+export function tIf (c, t, x, e, s, path, sp, v) {
+  // The branch by the condition's answer, not by which node it is: then and
+  // else may be the same schema.
+  const ok = c.run(nd(c, t[1]), x, null, true, path, sp + '/if', v); const b = ok ? t[2] : t[3]
+  return b === -1 || c.run(nd(c, b), x, e, s, path, sp + (ok ? '/then' : '/else'), v) || e !== null
+}
+// dependentRequired: [tDepReq, [name, [required, ...], ...]]
+export function tDepReq (c, t, x, e, s, path, sp, v) {
+  if (!isObj(x)) return true
+  const p = plainOf(x)
+  for (let j = 0, l = t[1]; j < l.length; j += 2) if (own(x, l[j])) for (const r of l[j + 1]) if (x[r] === undefined || !has(x, p, r)) { if (e === null) return false; c.push(e, c.R, path, sp + '/dependentRequired', r, v, s, null, 'ATA7005') }
+  return true
+}
+const FALSE = /* @__PURE__ */ (() => ({ kw: falseSchema.keyword, code: falseSchema.code, rank: falseSchema.rank, params: () => ({}), msg: () => falseSchema.msg, exp: () => void 0 }))()
+// The false schema: [tFalse]
+export const tFalse = (c, t, x, e, s, path, sp, v) => e !== null && (c.push(e, FALSE, path, sp, 0, v, s), true)
+
+// push(e, descriptor, path, schemaPath, n, value, seen, failure, code, hint)
+// order: the errors into schema order (kernels.mjs ordered), where the
+// module writer sorts them too (lib/ir/front.mjs needsOrder).
+function make (P, F, push, post, T, R, A, fill, order) {
+  const c = {
+    P, push, T, R, A, a: new Map(),
+    run (N, x, e, s, path, sp, v) {
+      for (let i = 0; i < N.length; i++) if (!N[i][0](c, N[i], x, e, s, path, sp, v, N)) return false
+      return true
+    },
+  }
+  const isValid = (d) => { if (fill) fill(F, 0, d); return c.run(P[0], d, null, true, '', '#', d) }
+  // isValidObject: the name the build plugin's wrapper reads, so a plan it
+  // places needs no wrapper of its own.
+  return {
+    isValid,
+    isValidObject: isValid,
+    validate (d) {
+      if (fill) fill(F, 0, d)
+      if (c.run(P[0], d, null, true, '', '#', d)) return { valid: true, data: d, errors: NONE }
+      const e = []
+      c.run(P[0], d, e, !(!d && d !== 0 && d !== false), '', '#', d)
+      const o = order ? order(e) : e
+      return { valid: false, errors: post !== null && o.length > 1 ? post(o) : o }
+    },
+  }
+}
+
+// Defaults, for a plan whose schema has any: F, by index, holds for each
+// node [defaults [k, v, ...], properties [k, f, ...], prefixItems [f or -1,
+// ...], items f or -1, dependentSchemas [k, f, ...], in place [f, ...]], in
+// the order and by the rules of the module writer's fill (lib/ir/front.mjs).
+export function tableFill (F, f, d) {
+  if (typeof d !== 'object' || d === null) return
+  const [defs, props, tuple, each, deps, here] = F[f]
+  for (let j = 0; j < defs.length; j += 2) if (!own(d, defs[j])) setOwn(d, defs[j], copyOf(defs[j + 1]))
+  for (let j = 0; j < props.length; j += 2) if (own(d, props[j])) tableFill(F, props[j + 1], d[props[j]])
+  if (Array.isArray(d) && (tuple.length || each !== -1)) for (let j = 0; j < d.length; j++) { if (j < tuple.length) { if (tuple[j] !== -1) tableFill(F, tuple[j], d[j]) } else if (each !== -1) tableFill(F, each, d[j]) }
+  for (let j = 0; j < deps.length; j += 2) if (!Array.isArray(d) && own(d, deps[j])) tableFill(F, deps[j + 1], d)
+  for (const g of here) tableFill(F, g, d)
+}
+
+// The errors as the plain shape: what richErrors: false gives.
+export const tablePlain = (P, F = [], fill, order) => make(P, F, (e, K, path, sp, n, v, s, f) => { e.push({ keyword: K.kw, instancePath: path, schemaPath: sp, params: f ? f.params : K.params(n), message: f ? f.msg : K.msg(n) }) }, null, typeP, requiredP, additionalP, fill, order)
+// The errors as ata's rich shape (rt.mjs E); `rel` when a node has both
+// required and additionalProperties, whose errors may point at each other.
+export const tableRich = (P, F = [], fill, rel, order) => make(P, F, (e, K, path, sp, n, v, s, f, code, hint) => { e.push(E(code || K.code, K.kw, path, sp, f ? f.params : K.params(n), f ? f.msg : K.msg(n), K.exp(n), K.rank, v, s, K.detail, hint || K.suggest)) }, rel ? relate : null, type, required, additionalProperties, fill, order)

package/lib/kernels/unique.mjs

@@ -0,0 +1,157 @@
+// Generated by scripts/gen-kernels-cjs.js from lib/unique-items.js. Do not edit.
+
+// uniqueItems for every engine. These are real functions: the interpreted
+// engine calls them, and the code generator emits their source text
+// (`String(fn)`) into the function it builds, so both run the same code.
+// They read only each other, `_deq` and `_uqpI`, which the generator emits
+// beside them.
+//
+// Short arrays compare pairwise and allocate nothing. Longer arrays of
+// primitives key a Set or Map by the value itself. Longer arrays that hold an
+// object key a Map by a numeric structural hash, and only items whose hashes
+// collide are compared with `_deq`. Equal values always hash alike: numbers
+// by their bits, with 0 and -0 as one (1 and 1.0 are one double already),
+// strings by their characters, arrays by position, and objects by the sum of their own key-value hashes,
+// whatever the key order. The hash replaced a sorted-key canonical string
+// built for every item on every call, which was over a quarter of the time a
+// generated verdict spent on SchemaStore's sample documents.
+
+// JSON equality, the same function the generator hoists as DEQ_HELPER.
+function _deq(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') return false;
+  var aa = Array.isArray(a);
+  if (aa !== Array.isArray(b)) return false;
+  var i, k, x, y;
+  if (aa) {
+    if (a.length !== b.length) return false;
+    for (i = a.length; i-- !== 0;) if (!_deq(a[i], b[i])) return false;
+    return true;
+  }
+  var ka = Object.keys(a);
+  if (ka.length !== Object.keys(b).length) return false;
+  // Keys and scalar values first, nested values after, from the last key back:
+  // two items of a list most often differ in a name, a path or an id, and
+  // walking a nested list first made each comparison of rust-project's crates
+  // three times what it needed (250 against 78 ns for the three; the default
+  // validator's deep equal takes 115).
+  for (i = ka.length; i-- !== 0;) {
+    k = ka[i];
+    if (!Object.prototype.hasOwnProperty.call(b, k)) return false;
+    x = a[k]; y = b[k];
+    if (x !== y && (x === null || y === null || typeof x !== 'object' || typeof y !== 'object')) return false;
+  }
+  for (i = ka.length; i-- !== 0;) {
+    k = ka[i]; x = a[k];
+    if (x !== null && typeof x === 'object' && !_deq(x, b[k])) return false;
+  }
+  return true;
+}
+
+function _uqh(x) {
+  if (x === null) return 1;
+  var t = typeof x, h, i;
+  if (t === 'boolean') return x ? 2 : 3;
+  if (t === 'number') {
+    if (x === 0) return 4;
+    h = x | 0;
+    if (h === x) return Math.imul(h, 0x9e3779b1) ^ 5;
+    // Every bit of the number goes into the hash, read through a typed
+    // array kept on the function (its source is emitted into modules, so
+    // nothing outside it is read). Nine decimal places, which this used to
+    // keep, hashed every number below 1e-9 alike, and an array of them was
+    // compared item against item.
+    var f = _uqh.f || (_uqh.f = new Float64Array(1)), w = _uqh.w || (_uqh.w = new Uint32Array(f.buffer));
+    f[0] = x;
+    return Math.imul(w[0] ^ Math.imul(w[1], 0x9e3779b1), 0x85ebca6b) ^ 5;
+  }
+  if (t === 'string') {
+    h = 0x811c9dc5 ^ x.length;
+    for (i = 0; i < x.length; i++) h = Math.imul(h ^ x.charCodeAt(i), 16777619);
+    return h;
+  }
+  if (t !== 'object') return 6;
+  if (Array.isArray(x)) {
+    h = 0x2545f491 ^ x.length;
+    for (i = 0; i < x.length; i++) h = Math.imul(h ^ _uqh(x[i]), 16777619);
+    return h;
+  }
+  var ks = Object.keys(x);
+  h = 0x6c8e9cf5 ^ ks.length;
+  for (i = 0; i < ks.length; i++) h = (h + Math.imul(_uqh(ks[i]) ^ Math.imul(_uqh(x[ks[i]]), 0x5bd1e995), 0x27d4eb2d)) | 0;
+  return h;
+}
+
+// Whether every item is distinct.
+function _uq(a) {
+  var n = a.length, i, k;
+  if (n < 2) return true;
+  if (n <= 12) {
+    for (i = 1; i < n; i++) for (k = 0; k < i; k++) if (_deq(a[i], a[k])) return false;
+    return true;
+  }
+  var prim = true;
+  for (i = 0; i < n; i++) { var x = a[i]; if (x !== null && typeof x === 'object') { prim = false; break; } }
+  if (prim) {
+    var s = new Set();
+    for (i = 0; i < n; i++) { if (s.has(a[i])) return false; s.add(a[i]); }
+    return true;
+  }
+  var m = new Map();
+  for (i = 0; i < n; i++) {
+    var hh = _uqh(a[i]), b = m.get(hh);
+    if (b === undefined) m.set(hh, i);
+    else if (typeof b === 'number') { if (_deq(a[b], a[i])) return false; m.set(hh, [b, i]); }
+    else { for (k = 0; k < b.length; k++) if (_deq(a[b[k]], a[i])) return false; b.push(i); }
+  }
+  return true;
+}
+
+// The duplicate pair an error reports: the first item that has a later
+// equal, and its first later equal. Returns that later index and leaves the
+// first in _uqpI, or returns -1 when every item is distinct.
+var _uqpI = 0;
+function _uqp(a) {
+  var n = a.length, i, k;
+  if (n < 2) return -1;
+  if (n <= 12) {
+    for (i = 0; i < n - 1; i++) for (k = i + 1; k < n; k++) if (_deq(a[i], a[k])) { _uqpI = i; return k; }
+    return -1;
+  }
+  var prim = true;
+  for (i = 0; i < n; i++) { var x = a[i]; if (x !== null && typeof x === 'object') { prim = false; break; } }
+  var bi = -1, bj = -1, m = new Map();
+  if (prim) {
+    for (i = 0; i < n; i++) {
+      var p = m.get(a[i]);
+      if (p === undefined) m.set(a[i], i);
+      else if (p >= 0) { if (bi < 0 || p < bi) { bi = p; bj = i; } m.set(a[i], -1); }
+    }
+  } else {
+    // Each bucket holds the first occurrence of every distinct value that
+    // hashed there, in index order; a value is paired with its first later
+    // equal only once.
+    var paired = null;
+    for (i = 0; i < n; i++) {
+      var hh = _uqh(a[i]), b = m.get(hh), r = -1;
+      if (b === undefined) { m.set(hh, i); continue; }
+      if (typeof b === 'number') { if (_deq(a[b], a[i])) r = b; else m.set(hh, [b, i]); }
+      else { for (k = 0; k < b.length; k++) if (_deq(a[b[k]], a[i])) { r = b[k]; break; } if (r < 0) b.push(i); }
+      if (r >= 0) {
+        if (paired === null) paired = new Set();
+        if (!paired.has(r)) { paired.add(r); if (bi < 0 || r < bi) { bi = r; bj = i; } }
+      }
+    }
+  }
+  if (bi < 0) return -1;
+  _uqpI = bi;
+  return bj;
+}
+
+// For the interpreted engine.
+function allDistinct(a) { return _uq(a); }
+function duplicatePair(a) {
+  var j = _uqp(a);
+  return j < 0 ? null : [_uqpI, j];
+}
+export { _deq, duplicatePair };

package/lib/native-positions.js

@@ -12,7 +12,7 @@ let _native;
 function nativeTargeted (text, wanted) {
   if (typeof text !== 'string' || text.length < NATIVE_MIN) return null;
   if (_native === undefined) {
-    try { _native = require('./native-load')(); } catch { _native = null; }
+    try { const l = require('./native-load'); _native = (typeof l === 'function' ? l : l.default)(); } catch { _native = null; }
     if (_native && typeof _native.locatePointers !== 'function') _native = null;
   }
   if (_native === null || typeof Buffer === 'undefined' || Buffer.byteLength(text, 'utf8') !== text.length) return null;

package/lib/openapi.d.ts

@@ -0,0 +1,2 @@
+/** The JSON Schema of each operation's JSON request body, by operationId (or method and path). */
+export declare function operationSchemas(doc: object): Record<string, object>

package/lib/openapi.js

@@ -0,0 +1,128 @@
+'use strict';
+// ata-validator/openapi: the JSON Schema of each operation's request body in
+// an OpenAPI document, ready for new Validator(schema), so a server and a page
+// built from the same document check the same schema. @ata-project/unplugin
+// writes a page's validators from it; a server reads it directly.
+//
+//   const { operationSchemas } = require('ata-validator/openapi')
+//   const bodies = operationSchemas(require('./openapi.json'))
+//   const createUser = new Validator(bodies.createUser)
+//
+// Each schema carries the document's components.schemas as $defs, its
+// references rewritten to them. OpenAPI 3.1 schemas are JSON Schema 2020-12
+// and are taken as they are (a nullable left in one is read as ata reads it
+// in every dialect); a document's jsonSchemaDialect becomes each schema's
+// $schema. OpenAPI 3.0 schemas are read as 3.0 defines
+// them: nullable: true adds null to the type (and to an enum), and a boolean
+// exclusiveMinimum or exclusiveMaximum makes minimum or maximum exclusive.
+// Only application/json bodies (and +json media types) are read. A reference
+// outside components.schemas, or to a schema that is not there, throws.
+
+const METHODS = ['get', 'put', 'post', 'delete', 'options', 'head', 'patch', 'trace'];
+const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const own = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
+
+// An operation's name, a JavaScript identifier: its operationId in camel
+// case (create-user, users.update and create_user give createUser,
+// usersUpdate and createUser; a name that is one already is kept), or, with
+// none, its method and path (post /users/{id}/roles -> postUsersIdRoles).
+function identifier(words) {
+  const w = words.filter(Boolean);
+  if (!w.length) return null;
+  const out = w[0][0].toLowerCase() + w[0].slice(1) + w.slice(1).map((x) => x[0].toUpperCase() + x.slice(1)).join('');
+  return /^[0-9]/.test(out) ? '_' + out : out;
+}
+function nameOf(method, p, op) {
+  if (typeof op.operationId === 'string' && op.operationId.trim() !== '') {
+    if (/^[A-Za-z_$][\w$]*$/.test(op.operationId) && !op.operationId.includes('_')) return op.operationId;
+    const id = identifier(op.operationId.split(/[^A-Za-z0-9$]+/));
+    if (id !== null) return id;
+  }
+  return identifier([method, ...(p.match(/[A-Za-z0-9]+/g) || [])]);
+}
+
+function jsonBody(content) {
+  if (!isObj(content)) return null;
+  for (const type of Object.keys(content)) {
+    const base = type.split(';')[0].trim().toLowerCase();
+    if ((base === 'application/json' || /^application\/[\w.-]+\+json$/.test(base)) && isObj(content[type]) && own(content[type], 'schema')) return content[type].schema;
+  }
+  return null;
+}
+
+// Where a schema keeps its subschemas: one, a list, or a map of names to
+// subschemas (a name there is the data's, not a keyword). Every other keyword
+// is copied as it is.
+const ONE = new Set(['items', 'additionalItems', 'additionalProperties', 'not', 'if', 'then', 'else', 'contains', 'propertyNames', 'unevaluatedItems', 'unevaluatedProperties']);
+const LIST = new Set(['allOf', 'anyOf', 'oneOf', 'prefixItems']);
+const MAP = new Set(['properties', 'patternProperties', '$defs', 'definitions', 'dependentSchemas']);
+
+// A copy of a schema with references into components.schemas pointed at
+// $defs, and, for 3.0, its nullable and boolean exclusive bounds rewritten.
+function convert(s, v30, where) {
+  if (!isObj(s)) return s;
+  const out = {};
+  for (const k of Object.keys(s)) {
+    const v = s[k];
+    if (k === '$ref' && typeof v === 'string') {
+      const m = /^#\/components\/schemas\/(.+)$/.exec(v);
+      if (!m) throw new Error(`ata-validator/openapi: ${where} refers to ${v}; only #/components/schemas/... is read`);
+      out.$ref = '#/$defs/' + m[1];
+    } else if (ONE.has(k)) out[k] = Array.isArray(v) ? v.map((x, i) => convert(x, v30, `${where}/${k}/${i}`)) : convert(v, v30, `${where}/${k}`);
+    else if (LIST.has(k) && Array.isArray(v)) out[k] = v.map((x, i) => convert(x, v30, `${where}/${k}/${i}`));
+    else if (MAP.has(k) && isObj(v)) { const m = {}; for (const n of Object.keys(v)) m[n] = convert(v[n], v30, `${where}/${k}/${n}`); out[k] = m; }
+    else out[k] = v;
+  }
+  if (v30) {
+    if (out.nullable === true) {
+      if (typeof out.type === 'string') out.type = [out.type, 'null'];
+      else if (Array.isArray(out.type) && !out.type.includes('null')) out.type = [...out.type, 'null'];
+      if (Array.isArray(out.enum) && !out.enum.includes(null)) out.enum = [...out.enum, null];
+    }
+    delete out.nullable;
+    if (out.exclusiveMinimum === true && typeof out.minimum === 'number') { out.exclusiveMinimum = out.minimum; delete out.minimum; } else if (typeof out.exclusiveMinimum === 'boolean') delete out.exclusiveMinimum;
+    if (out.exclusiveMaximum === true && typeof out.maximum === 'number') { out.exclusiveMaximum = out.maximum; delete out.maximum; } else if (typeof out.exclusiveMaximum === 'boolean') delete out.exclusiveMaximum;
+  }
+  return out;
+}
+
+// { [operation name]: schema } for every operation with a JSON request body.
+function operationSchemas(doc) {
+  if (!isObj(doc) || !isObj(doc.paths)) throw new Error('ata-validator/openapi: not an OpenAPI document (no paths)');
+  const version = typeof doc.openapi === 'string' ? doc.openapi : '';
+  const v30 = /^3\.0\./.test(version);
+  if (!v30 && !/^3\.1\./.test(version)) throw new Error(`ata-validator/openapi: OpenAPI 3.0 or 3.1 is read, not ${JSON.stringify(doc.openapi || doc.swagger)}`);
+  const dialect = !v30 && typeof doc.jsonSchemaDialect === 'string' ? doc.jsonSchemaDialect : null;
+  const components = isObj(doc.components) ? doc.components : {};
+  const schemas = isObj(components.schemas) ? components.schemas : {};
+  const defs = {};
+  for (const k of Object.keys(schemas)) defs[k] = convert(schemas[k], v30, '#/components/schemas/' + k);
+  const out = {}; const seen = {};
+  for (const p of Object.keys(doc.paths)) {
+    const item = doc.paths[p];
+    if (!isObj(item)) continue;
+    for (const method of METHODS) {
+      const op = item[method];
+      if (!isObj(op)) continue;
+      let body = op.requestBody;
+      if (isObj(body) && typeof body.$ref === 'string') {
+        const m = /^#\/components\/requestBodies\/(.+)$/.exec(body.$ref);
+        body = m && isObj(components.requestBodies) ? components.requestBodies[m[1]] : undefined;
+        if (!isObj(body)) throw new Error(`ata-validator/openapi: ${method} ${p} refers to a request body that is not there`);
+      }
+      if (!isObj(body)) continue;
+      const schema = jsonBody(body.content);
+      if (schema === null) continue;
+      const name = nameOf(method, p, op);
+      if (own(out, name)) throw new Error(`ata-validator/openapi: ${seen[name]} and ${method} ${p} are both named ${name}; give one a different operationId`);
+      seen[name] = `${method} ${p}`;
+      const root = convert(schema, v30, `${method} ${p} request body`);
+      const withDefs = Object.keys(defs).length ? { ...root, $defs: { ...defs, ...(isObj(root.$defs) ? root.$defs : {}) } } : root;
+      // A 3.1 document's jsonSchemaDialect is the dialect of its schemas.
+      out[name] = dialect && withDefs.$schema === undefined ? { $schema: dialect, ...withDefs } : withDefs;
+    }
+  }
+  return out;
+}
+
+module.exports = { operationSchemas };

package/lib/plan-compiler.js

@@ -56,6 +56,21 @@ function install(deps) {
           T_STRING, T_NUMBER, T_INTEGER, T_BOOLEAN, T_NULL, T_ARRAY, T_OBJECT, resolveRef, splitFragment, resolveUri } = deps;
 
   const TRUE_FN = () => true;
+  // Leaf codes (leafCode in compileLeafV): a string with lengths and a
+  // pattern, an integer or a number with minimum and maximum, a boolean, an
+  // enum of primitives, a primitive const. Each answers as the closure it
+  // stands for.
+  const LC_STR = 1, LC_INT = 2, LC_NUM = 3, LC_BOOL = 4, LC_ENUM = 5, LC_CONST = 6;
+  function leafOk(c, d) {
+    switch (c[0]) {
+      case LC_STR: return typeof d === 'string' && (c[1] === -1 || cpAtLeast(d, c[1])) && (c[2] === -1 || cpAtMost(d, c[2])) && (c[3] === null || c[3].test(d));
+      case LC_INT: case LC_NUM: return (c[0] === LC_INT ? Number.isInteger(d) : typeof d === 'number' && isFinite(d)) && d >= c[1] && d <= c[2];
+      case LC_BOOL: return typeof d === 'boolean';
+      case LC_ENUM: return c[1].has(d);
+      default: return d === c[1];
+    }
+  }
+
   // `leaf`: the node compiled no subschema of its own (see compileNode). A
   // collecting caller asks a leaf for its verdict first and builds the paths
   // for its errors only when it fails.
@@ -183,11 +198,17 @@ function install(deps) {
     // chain of guarded checks: the interpreted engine spent a fifth of a
     // document in those calls.
     const reqFolded = P.required !== null && P.requiredUndef === null && P.properties !== null;
+    // The operands of the commonest leaves, for an object walk that checks
+    // them in place (leafCode below): bounds that are only minimum and
+    // maximum, and string checks that are only lengths and a pattern.
+    let nLo = -Infinity, nHi = Infinity, nPlain = true;
+    let sLo = -1, sHi = -1, sRe = null, sPlain = true;
     let numsRun = null;
     if (P.hasNumber) {
       const nums = [];
-      if (P.minimum !== undefined) { const m = P.minimum; nums.push((d) => d >= m); }
-      if (P.maximum !== undefined) { const m = P.maximum; nums.push((d) => d <= m); }
+      if (P.minimum !== undefined) { const m = P.minimum; nLo = m; nums.push((d) => d >= m); }
+      if (P.maximum !== undefined) { const m = P.maximum; nHi = m; nums.push((d) => d <= m); }
+      if (P.exclusiveMinimum !== undefined || P.exclusiveMaximum !== undefined || P.multipleOf !== undefined) nPlain = false;
       if (P.exclusiveMinimum !== undefined) { const m = P.exclusiveMinimum; nums.push((d) => d > m); }
       if (P.exclusiveMaximum !== undefined) { const m = P.exclusiveMaximum; nums.push((d) => d < m); }
       if (P.multipleOf !== undefined) { const m = P.multipleOf; nums.push((d) => multipleOfOk(d, m)); }
@@ -196,6 +217,10 @@ function install(deps) {
     let strsRun = null;
     if (P.hasString) {
       const strs = [];
+      if (P.minLength !== undefined) sLo = P.minLength;
+      if (P.maxLength !== undefined) sHi = P.maxLength;
+      if (P.pattern !== null) sRe = P.pattern;
+      if (P.formatFn !== null) sPlain = false;
       if (P.minLength !== undefined && P.maxLength !== undefined) {
         const lo = P.minLength, hi = P.maxLength;
         strs.push((d) => { const n = d.length; return (n >= 2 * lo && n <= hi) || (cpAtLeast(d, lo) && cpAtMost(d, hi)); });
@@ -254,10 +279,10 @@ function install(deps) {
       if (!foreign) {
         const r = own;
         switch (m) {
-          case T_STRING: return r === null ? (d) => typeof d === 'string' : (d) => typeof d === 'string' && r(d);
-          case T_INTEGER: return r === null ? (d) => Number.isInteger(d) : (d) => Number.isInteger(d) && r(d);
-          case T_NUMBER: return r === null ? (d) => typeof d === 'number' && isFinite(d) : (d) => typeof d === 'number' && isFinite(d) && r(d);
-          case T_BOOLEAN: return (d) => typeof d === 'boolean';
+          case T_STRING: return leafCode(r === null ? (d) => typeof d === 'string' : (d) => typeof d === 'string' && r(d), sPlain ? [LC_STR, sLo, sHi, sRe] : null);
+          case T_INTEGER: return leafCode(r === null ? (d) => Number.isInteger(d) : (d) => Number.isInteger(d) && r(d), nPlain ? [LC_INT, nLo, nHi] : null);
+          case T_NUMBER: return leafCode(r === null ? (d) => typeof d === 'number' && isFinite(d) : (d) => typeof d === 'number' && isFinite(d) && r(d), nPlain ? [LC_NUM, nLo, nHi] : null);
+          case T_BOOLEAN: return leafCode((d) => typeof d === 'boolean', [LC_BOOL]);
           case T_NULL: return (d) => d === null;
           case T_OBJECT: return r === null ? (d) => typeof d === 'object' && d !== null && !Array.isArray(d) : (d) => typeof d === 'object' && d !== null && !Array.isArray(d) && r(d);
           case T_ARRAY: return r === null ? (d) => Array.isArray(d) : (d) => Array.isArray(d) && r(d);
@@ -279,7 +304,16 @@ function install(deps) {
     }
     if (checks.length === 0) return TRUE_FN;
     if (!needsBits) {
-      if (checks.length === 1) { const a = checks[0]; return (data) => a(data, 0); }
+      if (checks.length === 1) {
+        const a = checks[0];
+        const fn = (data) => a(data, 0);
+        // An enum of primitives alone, or a primitive const alone.
+        if (!P.hasType && !P.hasCustom && numsRun === null && strsRun === null && arrsRun === null && objsRun === null) {
+          if (P.enum !== null && P.enum.length > 0 && P.enumObjs.length === 0) return leafCode(fn, [LC_ENUM, P.enumPrims]);
+          if (P.hasConst && P.enum === null && (P.const === null || typeof P.const !== 'object')) return leafCode(fn, [LC_CONST, P.const]);
+        }
+        return fn;
+      }
       return (data) => {
         for (let i = 0; i < checks.length; i++) if (!checks[i](data, 0)) return false;
         return true;
@@ -297,6 +331,16 @@ function install(deps) {
     };
   }
 
+  // A leaf check that an object walk may run in place, by its code and
+  // operands, instead of calling it: one call site calling every property's
+  // check cannot be inlined, and on a form the calls were most of the
+  // verdict. leafOk must answer as the function does; tests/test_plan_leaf_codes.js
+  // holds the two to each other.
+  function leafCode(fn, code) {
+    if (code !== null) fn.lc = code;
+    return fn;
+  }
+
   // Folds a group's checks into one call, or null when the group is empty.
   function combineValue(fns) {
     if (fns.length === 0) return null;
@@ -704,6 +748,39 @@ function install(deps) {
         }
         return seenReq === reqN;
       });
+        // From three names to 32: below three the key array costs less than
+        // the for-in (1.7 ns on one name), past 32 the scan costs more.
+        if (apFalse && patterns === null && pnFn === null && !collect && propKeys !== null && propKeys.length >= 3 && propKeys.length <= 32) {
+          // A closed object with a short list of names, on an ordinary
+          // object: walk its keys with for-in and find each in the list, no
+          // key array and no Map. A key the list lacks is extra when it is
+          // the object's own (an enumerable name on Object.prototype is not).
+          // A listed key is read directly: for-in meets Object.prototype's
+          // own names (`constructor`) only on the object itself, so this is
+          // the short walk's rule. Other objects take the walk above.
+          const keyed = vsteps.pop();
+          const n = propKeys.length;
+          const fns = propList.map((e) => e.fn);
+          const reqs = propList.map((e) => e.req);
+          // A property whose check is a coded leaf is checked in place.
+          const codes = propList.map((e) => (e.fn.leaf && e.fn.v.lc !== undefined ? e.fn.v.lc : null));
+          vsteps.push((data, stack, rec) => {
+            if (dataBits(data) !== T_OBJECT || Object.getPrototypeOf(data) !== Object.prototype) return keyed(data, stack, rec);
+            if (fusedLeaf !== null && !fusedLeaf(data)) return false;
+            let seen = 0;
+            for (const key in data) {
+              let i = 0;
+              while (i < n && propKeys[i] !== key) i++;
+              if (i === n) { if (Object.hasOwn(data, key)) return false; continue; }
+              const value = data[key];
+              if (value === undefined) { if (reqs[i]) return false; continue; }
+              const lc = codes[i];
+              if (lc !== null ? !leafOk(lc, value) : !fns[i].v(value, stack)) return false;
+              if (reqs[i]) seen++;
+            }
+            return seen === reqN;
+          });
+        }
       }
     }
     if (P.dependentSchemas !== null) {

package/lib/public-api.js

@@ -58,6 +58,11 @@ function attachSuggestions (errors, data) {
   return errors;
 }
 
+// Loaded on first call, like the tools: a process that never calls them does
+// not read the file.
+function defineSchema (schema) { return require('./schema-helpers.js').defineSchema(schema); }
+function schemaOf (...a) { return require('./schema-helpers.js').schemaOf(...a); }
+
 module.exports = {
   Validator: core.Validator,
   compile: core.compile,
@@ -69,8 +74,8 @@ module.exports = {
   SIMDJSON_PADDING: core.SIMDJSON_PADDING,
   parseJSON: core.parseJSON,
   toTypeScript,
-  defineSchema: core.defineSchema,
-  schemaOf: core.schemaOf,
+  defineSchema,
+  schemaOf,
   renderPretty,
   renderCompact,
   toOutput,

package/lib/rejections.js

@@ -159,7 +159,9 @@ function stripOrdinal(e) {
   // lib/branch-collapse.js builds, the only place these codes come from. Its
   // fields are copied by name, in that order, without the ordinal: walking
   // its keys with for-in was most of the cost of reading such an error.
-  if (e.path !== undefined && e.docUrl === undefined && COLLAPSE_CODES.has(e.code)) {
+  // One that carries verbose's fields takes the copy of every key below,
+  // which keeps them; this one dropped them.
+  if (e.path !== undefined && e.docUrl === undefined && COLLAPSE_CODES.has(e.code) && !('parentSchema' in e)) {
     const out = { code: e.code, keyword: e.keyword, instancePath: e.instancePath, path: e.path, schemaPath: e.schemaPath, message: e.message, params: e.params };
     if ('branchErrors' in e) out.branchErrors = Array.isArray(e.branchErrors) ? e.branchErrors.map(stripOrdinal) : e.branchErrors;
     return out;