youeduc-sdk-messaging 0.0.0 → 0.5.0

package/dist/schema.js

@@ -0,0 +1,676 @@
+/**
+ * Loading and validation of JSON Schemas (Draft 2020-12).
+ *
+ * No error message produced here contains payload *values* (PII): only the JSON pointer of the
+ * field, the name of the violated rule and, for `required` / `additionalProperties`, the names
+ * of the properties involved. Wording, the selected error and the checked formats follow the
+ * Python SDK (`jsonschema` + `best_match`).
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import Ajv2020Module from 'ajv/dist/2020.js';
+import addFormatsModule from 'ajv-formats';
+import { SchemaNotFoundError, SchemaValidationError } from './errors.js';
+import * as naming from './naming.js';
+import { errorMessage, isPlainObject, pyRepr } from './util.js';
+// ajv / ajv-formats are CommonJS modules exposing the implementation on `module.exports` and
+// on `exports.default`; under NodeNext the typed entry point is `.default`.
+const Ajv2020 = Ajv2020Module.default;
+const addFormats = addFormatsModule.default;
+// ------------------------------------------------------------------------------ loaders
+function keyOf(domain, event, version) {
+    return JSON.stringify([domain, event, version]);
+}
+function cloneJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+/**
+ * Schemas in memory, indexed by `"domain/eventSlug/version"` (spec §17). Stores and returns
+ * deep copies: caller mutations never leak.
+ */
+export class InMemorySchemaLoader {
+    #schemas = new Map();
+    constructor(schemas) {
+        for (const [key, schema] of Object.entries(schemas)) {
+            const parts = key.split('/');
+            if (parts.length !== 3) {
+                throw new TypeError(`schema key must be 'domain/slug/version'; got ${pyRepr(key)}`);
+            }
+            const [domain, event, version] = parts;
+            this.#schemas.set(keyOf(domain, event, version), cloneJson(schema));
+        }
+    }
+    load(domain, event, version) {
+        const schema = this.#schemas.get(keyOf(domain, event, version));
+        if (schema === undefined)
+            throw new SchemaNotFoundError(domain, event, version);
+        return cloneJson(schema);
+    }
+}
+/**
+ * Asks `loaders` in order: the first one that does not throw `SchemaNotFoundError` wins.
+ *
+ * Typical use: the service's own schemas first, the SDK's bundled contracts after them:
+ * `new ChainSchemaLoader(new FileSystemSchemaLoader('schemas'), contracts.schemaLoader())`.
+ * Any other error of a loader (I/O, `SchemaValidationError` for a malformed file) propagates at
+ * once, without asking the next ones. None found → `SchemaNotFoundError`.
+ */
+export class ChainSchemaLoader {
+    #loaders;
+    constructor(...loaders) {
+        if (loaders.length === 0)
+            throw new RangeError('ChainSchemaLoader requires at least one loader');
+        this.#loaders = Object.freeze([...loaders]);
+    }
+    get loaders() {
+        return this.#loaders;
+    }
+    load(domain, event, version) {
+        for (const loader of this.#loaders) {
+            try {
+                return loader.load(domain, event, version);
+            }
+            catch (error) {
+                if (!(error instanceof SchemaNotFoundError))
+                    throw error;
+            }
+        }
+        throw new SchemaNotFoundError(domain, event, version);
+    }
+}
+// Errors meaning "the file does not exist". The others (EACCES, EMFILE, EIO...) are environment
+// problems, possibly transient, and propagate unchanged.
+const NOT_FOUND_CODES = new Set(['ENOENT', 'ENOTDIR', 'EISDIR']);
+const FORBIDDEN_COMPONENTS = new Set(['', '.', '..']);
+const nodeFileSystem = {
+    readFile: (filePath) => fs.readFileSync(filePath),
+    realpath: (filePath) => fs.realpathSync(filePath),
+};
+function isNotFound(error) {
+    const code = error?.code;
+    return typeof code === 'string' && NOT_FOUND_CODES.has(code);
+}
+/**
+ * Reads `root/{domain}/{event}/{version}.json`.
+ *
+ * Protected against path traversal: empty components, `.`/`..`, separators or NUL are refused,
+ * and the final path (after resolving symlinks) must stay inside `root`. Otherwise →
+ * `SchemaNotFoundError`. Only a missing file (`ENOENT`, `ENOTDIR`, `EISDIR`) becomes
+ * `SchemaNotFoundError`; other I/O errors propagate unchanged. Non-UTF-8, malformed JSON or a
+ * non-object → `SchemaValidationError`.
+ *
+ * Synchronous I/O: meant to be called once per schema (`SchemaRegistry` caches validators).
+ */
+export class FileSystemSchemaLoader {
+    #root;
+    #fs;
+    constructor(root, options = {}) {
+        this.#fs = options.fileSystem ?? nodeFileSystem;
+        const resolved = path.resolve(root);
+        let real = resolved;
+        try {
+            real = this.#fs.realpath(resolved);
+        }
+        catch {
+            // Missing root: keep the lexical path (every load will be "not found").
+        }
+        this.#root = real;
+    }
+    get root() {
+        return this.#root;
+    }
+    load(domain, event, version) {
+        const filePath = this.#pathFor(domain, event, version);
+        const name = path.basename(filePath);
+        let raw;
+        try {
+            raw = this.#fs.readFile(filePath);
+        }
+        catch (error) {
+            if (isNotFound(error))
+                throw new SchemaNotFoundError(domain, event, version);
+            throw error;
+        }
+        let text;
+        try {
+            text = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(raw);
+        }
+        catch {
+            throw new SchemaValidationError('', `schema file ${pyRepr(name)} is not valid UTF-8`);
+        }
+        let data;
+        try {
+            data = JSON.parse(text);
+        }
+        catch (error) {
+            throw new SchemaValidationError('', `malformed schema JSON in ${pyRepr(name)}: ${errorMessage(error)}`);
+        }
+        if (!isPlainObject(data)) {
+            throw new SchemaValidationError('', `schema in ${pyRepr(name)} must be a JSON object`);
+        }
+        return data;
+    }
+    #pathFor(domain, event, version) {
+        for (const part of [domain, event, version]) {
+            if (!isSafeComponent(part))
+                throw new SchemaNotFoundError(domain, event, version);
+        }
+        const lexical = path.join(this.#root, domain, event, `${version}.json`);
+        let candidate;
+        try {
+            candidate = this.#fs.realpath(lexical);
+        }
+        catch (error) {
+            if (isNotFound(error))
+                throw new SchemaNotFoundError(domain, event, version);
+            throw error;
+        }
+        if (candidate !== this.#root && !candidate.startsWith(this.#root + path.sep)) {
+            throw new SchemaNotFoundError(domain, event, version);
+        }
+        return candidate;
+    }
+}
+function isSafeComponent(part) {
+    return (typeof part === 'string' &&
+        !FORBIDDEN_COMPONENTS.has(part) &&
+        !part.includes('/') &&
+        !part.includes('\\') &&
+        !part.includes('\0'));
+}
+// ------------------------------------------------------------------------------ formats
+//
+// Spec §10: `format` is an assertion only for date, date-time, time, email, idn-email, uuid,
+// ipv4 and ipv6 (strings only); every other format (unknown included) is an annotation and is
+// never checked (Ajv with `strict: false` ignores formats it does not know).
+const RFC3339_RE = /^(\d{4})-(0[1-9]|1[0-2])-(\d{2})T(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/;
+const DATE_RE = /^(\d{4})-(\d{2})-(\d{2})$/;
+const UUID_RE = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+const DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+function isLeap(year) {
+    return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+}
+function maxDay(year, month) {
+    if (month === 2 && isLeap(year))
+        return 29;
+    return DAYS_IN_MONTH[month - 1] ?? 0;
+}
+/** RFC 3339 `date-time`, exact match; `t`/`z` accepted in lowercase; no leap second. */
+function isRfc3339DateTime(value) {
+    const match = RFC3339_RE.exec(value.replace(/[tz]/g, (c) => c.toUpperCase()));
+    if (match === null)
+        return false;
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    if (year === 0)
+        return false;
+    return day >= 1 && day <= maxDay(year, month);
+}
+function isTime(value) {
+    return isRfc3339DateTime(`1970-01-01T${value}`);
+}
+function isDate(value) {
+    const match = DATE_RE.exec(value);
+    if (match === null)
+        return false;
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    return year >= 1 && month >= 1 && month <= 12 && day >= 1 && day <= maxDay(year, month);
+}
+/** Strict `8-4-4-4-12` hexadecimal. */
+function isUuid(value) {
+    return UUID_RE.test(value);
+}
+function isEmail(value) {
+    return value.includes('@');
+}
+function newAjv() {
+    const ajv = new Ajv2020({
+        allErrors: true,
+        verbose: true,
+        strict: false,
+        logger: false,
+        validateFormats: true,
+        unicodeRegExp: true, // ECMA-262 with `u`: `.` matches an astral code point as one
+    });
+    ajv.addFormat('date-time', { type: 'string', validate: isRfc3339DateTime });
+    ajv.addFormat('time', { type: 'string', validate: isTime });
+    ajv.addFormat('date', { type: 'string', validate: isDate });
+    ajv.addFormat('uuid', { type: 'string', validate: isUuid });
+    ajv.addFormat('email', { type: 'string', validate: isEmail });
+    ajv.addFormat('idn-email', { type: 'string', validate: isEmail });
+    addFormats(ajv, { formats: ['ipv4', 'ipv6'], mode: 'full', keywords: false });
+    return ajv;
+}
+// ------------------------------------------------------------------------------ validator
+const ROOT_KEY = 'sdk-messaging-root';
+// Keywords whose value is data (instance), not a subschema: a "$ref" there is literal.
+const DATA_KEYWORDS = new Set(['const', 'enum', 'default', 'examples']);
+const REF_KEYWORDS = ['$ref', '$dynamicRef'];
+// Python's best_match: anyOf/oneOf are "weak" (superseded by same-level errors).
+const WEAK_KEYWORDS = new Set(['anyOf', 'oneOf']);
+// Ajv-only wrapper errors (jsonschema reports only the inner errors).
+const WRAPPER_KEYWORDS = new Set(['if', 'propertyNames']);
+const MISSING_REF_RE = /^can't resolve reference (.*) from id /s;
+function escapePointerToken(token) {
+    return token.replaceAll('~', '~0').replaceAll('/', '~1');
+}
+function toPointer(segments) {
+    return segments.map((segment) => `/${escapePointerToken(String(segment))}`).join('');
+}
+/** Decodes an Ajv `instancePath`, typing array indexes as numbers (by walking the instance). */
+function decodeInstancePath(instancePath, root) {
+    if (instancePath === '')
+        return [];
+    const segments = [];
+    let current = root;
+    for (const raw of instancePath.slice(1).split('/')) {
+        const token = raw.replaceAll('~1', '/').replaceAll('~0', '~');
+        if (Array.isArray(current)) {
+            const index = Number(token);
+            segments.push(index);
+            current = current[index];
+        }
+        else {
+            segments.push(token);
+            current =
+                isPlainObject(current) || (typeof current === 'object' && current !== null)
+                    ? current[token]
+                    : undefined;
+        }
+    }
+    return segments;
+}
+// Keywords whose descend adds an instance path segment: `{keyword}/{name}/false schema`.
+const PATH_DESCEND_KEYWORDS = new Set(['properties', 'patternProperties', 'prefixItems']);
+function reachedByPathDescend(schemaPath) {
+    const tokens = schemaPath.split('/');
+    return tokens.length >= 3 && PATH_DESCEND_KEYWORDS.has(tokens[tokens.length - 3] ?? '');
+}
+function isJsonType(value, type) {
+    switch (type) {
+        case 'null':
+            return value === null;
+        case 'boolean':
+            return typeof value === 'boolean';
+        case 'integer':
+            return typeof value === 'number' && Number.isInteger(value);
+        case 'number':
+            return typeof value === 'number';
+        case 'string':
+            return typeof value === 'string';
+        case 'array':
+            return Array.isArray(value);
+        case 'object':
+            return typeof value === 'object' && value !== null && !Array.isArray(value);
+        default:
+            return false;
+    }
+}
+/** jsonschema `ValidationError._matches_type()`. */
+function matchesType(candidate) {
+    const schema = candidate.parentSchema;
+    if (!isPlainObject(schema) || !('type' in schema))
+        return false;
+    const expected = schema.type;
+    if (typeof expected === 'string')
+        return isJsonType(candidate.data, expected);
+    if (Array.isArray(expected))
+        return expected.some((type) => isJsonType(candidate.data, type));
+    return false;
+}
+function comparePaths(a, b) {
+    const length = Math.min(a.length, b.length);
+    for (let i = 0; i < length; i += 1) {
+        const x = a[i];
+        const y = b[i];
+        if (x === y)
+            continue;
+        if (typeof x === 'number' && typeof y === 'number')
+            return x < y ? -1 : 1;
+        return String(x) < String(y) ? -1 : 1;
+    }
+    return a.length - b.length;
+}
+/** Compares jsonschema `relevance` keys: (-len(path), path, not weak, strong, not matches_type). */
+function compareRelevance(a, b) {
+    if (a.path.length !== b.path.length)
+        return b.path.length - a.path.length;
+    const byPath = comparePaths(a.path, b.path);
+    if (byPath !== 0)
+        return byPath;
+    const weakA = WEAK_KEYWORDS.has(a.keyword) ? 0 : 1;
+    const weakB = WEAK_KEYWORDS.has(b.keyword) ? 0 : 1;
+    if (weakA !== weakB)
+        return weakA - weakB;
+    const typeA = matchesType(a) ? 0 : 1;
+    const typeB = matchesType(b) ? 0 : 1;
+    return typeA - typeB;
+}
+/** `max(errors, key=relevance)`; exact ties in the same schema object follow schema order. */
+function pickMostRelevant(candidates) {
+    let best;
+    for (const candidate of candidates) {
+        if (best === undefined) {
+            best = candidate;
+            continue;
+        }
+        const order = compareRelevance(candidate, best);
+        if (order > 0 ||
+            (order === 0 &&
+                candidate.parentSchema === best.parentSchema &&
+                candidate.keywordIndex < best.keywordIndex)) {
+            best = candidate;
+        }
+    }
+    return best;
+}
+/** jsonschema `best_match`: most relevant error, descending into anyOf/oneOf context. */
+function bestMatch(candidates) {
+    let best = pickMostRelevant(candidates);
+    while (best !== undefined && best.context.length > 0) {
+        const sorted = [...best.context].sort(compareRelevance);
+        const [first, second] = sorted;
+        if (first === undefined)
+            break;
+        if (second !== undefined && compareRelevance(first, second) === 0)
+            return best;
+        best = first;
+    }
+    return best;
+}
+function missingRequired(candidate) {
+    const schema = candidate.parentSchema;
+    const data = candidate.data;
+    if (!isPlainObject(schema) || !Array.isArray(schema.required) || !isPlainObject(data))
+        return [];
+    return schema.required.filter((name) => typeof name === 'string' && (!Object.hasOwn(data, name) || data[name] === undefined));
+}
+function additionalProperties(candidate) {
+    const schema = candidate.parentSchema;
+    const data = candidate.data;
+    if (!isPlainObject(schema) || !isPlainObject(data))
+        return [];
+    const properties = isPlainObject(schema.properties) ? schema.properties : {};
+    const patterns = isPlainObject(schema.patternProperties) ? Object.keys(schema.patternProperties) : [];
+    const regexes = patterns.flatMap((pattern) => {
+        try {
+            return [new RegExp(pattern, 'u')];
+        }
+        catch {
+            return [];
+        }
+    });
+    return Object.keys(data)
+        .filter((name) => !Object.hasOwn(properties, name) && !regexes.some((regex) => regex.test(name)))
+        .sort();
+}
+/** Description of the error without payload values (Python `_safe_reason`). */
+function safeReason(candidate) {
+    if (candidate.keyword === 'false schema')
+        return 'failed schema validation';
+    let reason = `failed ${pyRepr(candidate.keyword)} constraint`;
+    if (candidate.keyword === 'required') {
+        const names = missingRequired(candidate);
+        if (names.length > 0)
+            reason += `: missing ${names.map(pyRepr).join(', ')}`;
+    }
+    else if (candidate.keyword === 'additionalProperties') {
+        const names = additionalProperties(candidate);
+        if (names.length > 0)
+            reason += `: unexpected ${names.map(pyRepr).join(', ')}`;
+    }
+    return reason;
+}
+function iterRefHolders(node, pointer, visit) {
+    if (Array.isArray(node)) {
+        node.forEach((item, index) => {
+            iterRefHolders(item, `${pointer}/${index}`, visit);
+        });
+        return;
+    }
+    if (!isPlainObject(node))
+        return;
+    if (REF_KEYWORDS.some((keyword) => typeof node[keyword] === 'string'))
+        visit(pointer, node);
+    for (const [keyword, value] of Object.entries(node)) {
+        if (!DATA_KEYWORDS.has(keyword))
+            iterRefHolders(value, `${pointer}/${uriPointerToken(keyword)}`, visit);
+    }
+}
+function uriPointerToken(token) {
+    return encodeURIComponent(escapePointerToken(token));
+}
+function indexPointers(node, pointer, index) {
+    if (typeof node !== 'object' || node === null)
+        return;
+    if (!index.has(node))
+        index.set(node, pointer);
+    if (Array.isArray(node)) {
+        node.forEach((item, i) => {
+            indexPointers(item, `${pointer}/${i}`, index);
+        });
+    }
+    else {
+        for (const [keyword, value] of Object.entries(node)) {
+            indexPointers(value, `${pointer}/${uriPointerToken(keyword)}`, index);
+        }
+    }
+}
+function invalidSchema(reason) {
+    return new SchemaValidationError('', `invalid schema${reason}`);
+}
+function unresolvable(error) {
+    if (!(error instanceof Error) || error.constructor.name !== 'MissingRefError')
+        return null;
+    const match = MISSING_REF_RE.exec(error.message);
+    const ref = match?.[1] ?? String(error.missingRef ?? '');
+    return invalidSchema(`: unresolvable reference ${pyRepr(ref)}`);
+}
+/**
+ * Validates payloads with Ajv (Draft 2020-12), including `format`.
+ *
+ * The schema is checked in the constructor (an invalid schema fails early). `$ref` is never
+ * fetched over the network: only local references (`#/$defs/...`, anchors, embedded subschemas
+ * with `$id`) resolve, and every `$ref`/`$dynamicRef` is resolved statically at construction;
+ * one that does not resolve (remote included) becomes `SchemaValidationError`.
+ *
+ * The reported error is the one Python's `jsonschema.best_match` would pick (shallowest
+ * instance path, lexicographically last sibling, anyOf/oneOf descended into their context).
+ */
+export class JsonSchemaValidator {
+    #ajv;
+    #validate;
+    #pointers = new Map();
+    #subValidators = new Map();
+    constructor(schema) {
+        const input = schema;
+        if (!isPlainObject(input) && typeof input !== 'boolean') {
+            throw invalidSchema(': schema must be a JSON object or boolean');
+        }
+        // Private tree copy: Ajv keeps references, and error objects are matched by identity.
+        const copy = cloneJson(input);
+        // Python always validates as Draft 2020-12, whatever "$schema" says.
+        if (isPlainObject(copy))
+            delete copy.$schema;
+        this.#ajv = newAjv();
+        if (!this.#ajv.validateSchema(copy)) {
+            const first = this.#ajv.errors?.[0];
+            const where = first?.instancePath ? ` at ${pyRepr(first.instancePath)}` : '';
+            throw invalidSchema(`${where}: ${first?.message ?? 'does not match the 2020-12 meta-schema'}`);
+        }
+        try {
+            this.#ajv.addSchema(copy, ROOT_KEY);
+            const validate = this.#ajv.getSchema(ROOT_KEY);
+            if (validate === undefined)
+                throw invalidSchema(': schema could not be compiled');
+            this.#validate = validate;
+            // Like Python, every reference must resolve, even in subschemas never reached.
+            iterRefHolders(copy, '', (pointer) => {
+                this.#ajv.getSchema(`${ROOT_KEY}#${pointer}`);
+            });
+        }
+        catch (error) {
+            if (error instanceof SchemaValidationError)
+                throw error;
+            throw unresolvable(error) ?? invalidSchema(`: ${errorMessage(error)}`);
+        }
+        indexPointers(copy, '', this.#pointers);
+    }
+    validate(payload) {
+        if (this.#validate(payload))
+            return;
+        const candidates = this.#structure(this.#validate.errors ?? [], payload, []);
+        const best = bestMatch(candidates);
+        if (best === undefined)
+            throw new SchemaValidationError('', 'failed schema validation');
+        // No `cause`: Ajv errors carry the instance (payload values).
+        throw new SchemaValidationError(toPointer([...best.base, ...best.path]), safeReason(best));
+    }
+    /** Turns Ajv's flat error list into jsonschema-like top-level errors (with context). */
+    #structure(errors, root, base) {
+        const result = [];
+        let i = errors.length - 1;
+        while (i >= 0) {
+            const error = errors[i];
+            if (WRAPPER_KEYWORDS.has(error.keyword)) {
+                i -= 1;
+                continue;
+            }
+            let context = [];
+            let consumed = 0;
+            if (error.keyword === 'anyOf' || error.keyword === 'oneOf' || error.keyword === 'contains') {
+                const sub = this.#subErrors(error, root, base);
+                if (sub !== null && sub.count <= i) {
+                    consumed = sub.count;
+                    context = sub.context;
+                }
+                else {
+                    // Fallback: drop the preceding errors located under this keyword.
+                    const prefix = `${error.schemaPath}/`;
+                    while (consumed < i && errors[i - consumed - 1].schemaPath.startsWith(prefix)) {
+                        consumed += 1;
+                    }
+                }
+            }
+            result.push(this.#candidate(error, root, base, context));
+            i -= 1 + consumed;
+        }
+        return result.reverse();
+    }
+    #candidate(error, root, base, context) {
+        const parentSchema = error.parentSchema;
+        let errorPath = decodeInstancePath(error.instancePath, root);
+        if (error.keyword === 'false schema' && reachedByPathDescend(error.schemaPath)) {
+            // jsonschema quirk: the error of a `false` subschema does not get the path segment of
+            // the descend that reached it ({"properties": {"x": false}} reports at the parent).
+            errorPath = errorPath.slice(0, -1);
+        }
+        return {
+            keyword: error.keyword,
+            path: errorPath,
+            base,
+            parentSchema,
+            data: error.data,
+            keywordIndex: isPlainObject(parentSchema) ? Object.keys(parentSchema).indexOf(error.keyword) : -1,
+            context,
+        };
+    }
+    /**
+     * Re-validates the instance of an anyOf/oneOf/contains error against each branch (compiled in
+     * the root document, so local refs resolve) to rebuild its context and to know how many of
+     * the preceding flat errors belong to it. `null` when the branches cannot be located.
+     */
+    #subErrors(error, root, base) {
+        const keywordValue = error.schema;
+        if (typeof keywordValue !== 'object' || keywordValue === null)
+            return null;
+        const pointer = this.#pointers.get(keywordValue);
+        if (pointer === undefined)
+            return null;
+        const instance = error.data;
+        const instanceBase = [...base, ...decodeInstancePath(error.instancePath, root)];
+        if (error.keyword === 'contains') {
+            const validate = this.#subValidator(pointer);
+            if (validate === null || !Array.isArray(instance))
+                return null;
+            let count = 0;
+            for (const item of instance) {
+                if (!validate(item))
+                    count += validate.errors?.length ?? 0;
+            }
+            return { count, context: [] };
+        }
+        if (!Array.isArray(keywordValue))
+            return null;
+        let count = 0;
+        const context = [];
+        for (let index = 0; index < keywordValue.length; index += 1) {
+            const validate = this.#subValidator(`${pointer}/${index}`);
+            if (validate === null)
+                return null;
+            if (validate(instance))
+                continue;
+            const branchErrors = [...(validate.errors ?? [])];
+            count += branchErrors.length;
+            context.push(...this.#structure(branchErrors, instance, instanceBase));
+        }
+        const passing = error.params.passingSchemas;
+        // oneOf failing because several branches match: jsonschema reports it without context.
+        if (error.keyword === 'oneOf' && Array.isArray(passing))
+            return { count, context: [] };
+        return { count, context };
+    }
+    #subValidator(pointer) {
+        if (!this.#subValidators.has(pointer)) {
+            let validate = null;
+            try {
+                validate = this.#ajv.getSchema(`${ROOT_KEY}#${pointer}`) ?? null;
+            }
+            catch {
+                validate = null;
+            }
+            this.#subValidators.set(pointer, validate);
+        }
+        return this.#subValidators.get(pointer) ?? null;
+    }
+}
+// ------------------------------------------------------------------------------ registry
+/**
+ * Implements {@link PayloadValidator}: resolves the schema of an event and validates.
+ *
+ * Validators are cached per `[domain, slug, version]`. Load failures (`SchemaNotFoundError`)
+ * and invalid schemas are not cached, so a schema published later is found without restarting.
+ */
+export class SchemaRegistry {
+    #loader;
+    #factory;
+    #cache = new Map();
+    constructor(loader, validatorFactory = (schema) => new JsonSchemaValidator(schema)) {
+        this.#loader = loader;
+        this.#factory = validatorFactory;
+    }
+    validate(request) {
+        let slug;
+        try {
+            slug = naming.schemaSlug(request.eventType);
+        }
+        catch (error) {
+            throw new SchemaValidationError('', errorMessage(error));
+        }
+        this.#validatorFor(request.domain, slug, request.version).validate(request.payload);
+    }
+    #validatorFor(domain, slug, version) {
+        const key = keyOf(domain, slug, version);
+        let validator = this.#cache.get(key);
+        if (validator === undefined) {
+            const schema = this.#loader.load(domain, slug, version);
+            validator = this.#factory(schema);
+            this.#cache.set(key, validator);
+        }
+        return validator;
+    }
+}
+//# sourceMappingURL=schema.js.map