@astrale-os/kernel-dsl 0.2.0 → 1.0.0-beta.10

package/dist/v1/language/class/unique.js

@@ -0,0 +1,264 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+import { ClassKey } from '../../addressing/class-key.js';
+import { compareUnicode } from '../../addressing/ordering.js';
+import { PropertyKey } from '../../addressing/property-key.js';
+/** The kinds of key fields, in canonical order: the endpoints, the slug, then the Properties. */
+const KINDS = Object.freeze([
+    'source',
+    'target',
+    'slug',
+    'property',
+]);
+/** The canonical order of forms: kind by kind, a form before every form it prefixes. */
+const compareForms = compareSequences(compareKinds);
+/**
+ * Every form a key tuple may take, in canonical order: each nonempty set of field kinds. A Property
+ * kind stands for one Property or more, whatever their keys.
+ */
+export const EDGE_UNIQUE_FORMS = Object.freeze(Array.from({ length: (1 << KINDS.length) - 1 }, (_, index) => Object.freeze(KINDS.filter((_, kind) => ((index + 1) & (1 << kind)) !== 0))).sort(compareForms));
+/** The one form a Node key tuple takes: its fields are Properties, whatever their keys. */
+export const NODE_UNIQUE_FORMS = Object.freeze([
+    Object.freeze(['property']),
+]);
+/** Every form of every kind, which a backend enforcing any key tuple announces. */
+export const UNIQUE_FORMS = Object.freeze({
+    edge: EDGE_UNIQUE_FORMS,
+    node: NODE_UNIQUE_FORMS,
+});
+/** No form of either kind: a backend that announces none enforces no key tuple. */
+export const NO_UNIQUE_FORMS = Object.freeze({
+    edge: Object.freeze([]),
+    node: Object.freeze([]),
+});
+/** The kind of `field`. */
+function kindOf(field) {
+    return typeof field === 'string' ? field : 'property';
+}
+function compareKinds(left, right) {
+    return KINDS.indexOf(left) - KINDS.indexOf(right);
+}
+/** The canonical order of fields: source, target, slug, then Properties by key. */
+export function compareEdgeUniqueFields(left, right) {
+    return (compareKinds(kindOf(left), kindOf(right)) ||
+        (typeof left === 'string' || typeof right === 'string'
+            ? 0
+            : compareUnicode(left.property, right.property)));
+}
+/** The canonical order of tuples: field by field, a tuple before every tuple it prefixes. */
+export const compareEdgeUniqueTuples = compareSequences(compareEdgeUniqueFields);
+/** The field `value` spells, detached, or undefined when it spells none. */
+function edgeUniqueField(value) {
+    if (value === 'source' || value === 'target' || value === 'slug')
+        return value;
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const keys = Object.keys(value);
+    const property = value.property;
+    return keys.length === 1 && keys[0] === 'property' && PropertyKey.is(property)
+        ? Object.freeze({ property })
+        : undefined;
+}
+/**
+ * The tuple `value` spells, detached, or undefined when it spells none: a nonempty list of fields,
+ * distinct and in canonical order, so one set of fields has one spelling.
+ */
+export function edgeUniqueTuple(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return undefined;
+    const fields = [];
+    for (const item of value) {
+        const field = edgeUniqueField(item);
+        if (field === undefined)
+            return undefined;
+        if (fields.length > 0 && compareEdgeUniqueFields(fields.at(-1), field) >= 0)
+            return undefined;
+        fields.push(field);
+    }
+    return Object.freeze(fields);
+}
+/**
+ * The tuple the endpoints and slug `named` holds spell, in canonical order, or undefined when it
+ * holds none: the key a selector names an Edge by. A selector names no Property.
+ */
+export function namedEdgeUniqueTuple(named) {
+    return edgeUniqueTuple(['source', 'target', 'slug'].filter((field) => named[field] !== undefined));
+}
+/** The canonical order of Node tuples: Property by Property, a tuple before every one it prefixes. */
+export const compareNodeUniqueTuples = compareSequences(compareUnicode);
+/**
+ * The Node tuple `value` spells, detached, or undefined when it spells none: a nonempty list of
+ * Property keys, distinct and in code-point order, so one set of Properties has one spelling.
+ */
+export function nodeUniqueTuple(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return undefined;
+    const keys = [];
+    for (const key of value) {
+        if (!PropertyKey.is(key))
+            return undefined;
+        if (keys.length > 0 && compareUnicode(keys.at(-1), key) >= 0)
+            return undefined;
+        keys.push(key);
+    }
+    return Object.freeze(keys);
+}
+/** The form of `NODE_UNIQUE_FORMS` that `value` spells, or undefined when it spells none. */
+export function nodeUniqueForm(value) {
+    return Array.isArray(value) && value.length === 1 && value[0] === 'property'
+        ? NODE_UNIQUE_FORMS[0]
+        : undefined;
+}
+/**
+ * Whether a backend announcing `forms` for Nodes enforces the Node tuple `value` spells: every
+ * Node tuple has the one Node form. False when `value` spells no tuple.
+ */
+export function enforcesNodeUniqueTuple(forms, value) {
+    return forms.length > 0 && nodeUniqueTuple(value) !== undefined;
+}
+/** The form of `tuple`: the kinds of its fields, each once. */
+export function edgeUniqueFormOf(tuple) {
+    const kinds = new Set(tuple.map(kindOf));
+    return EDGE_UNIQUE_FORMS.find((form) => form.length === kinds.size && form.every((kind) => kinds.has(kind)));
+}
+/** The form of `EDGE_UNIQUE_FORMS` that `value` spells, or undefined when it spells none. */
+export function edgeUniqueForm(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    return EDGE_UNIQUE_FORMS.find((form) => form.length === value.length && form.every((kind, index) => kind === value[index]));
+}
+/**
+ * Whether a backend announcing `forms` enforces the tuple `value` spells: its form is one of them.
+ * False when `value` spells no tuple, so a tuple is never taken as enforced by mistake.
+ */
+export function enforcesEdgeUniqueTuple(forms, value) {
+    const tuple = edgeUniqueTuple(value);
+    if (tuple === undefined)
+        return false;
+    const form = edgeUniqueFormOf(tuple);
+    return forms.some((candidate) => compareForms(candidate, form) === 0);
+}
+/**
+ * Whether a Property may be a key field (D-S1): a single-kind scalar by its ordering facet, a
+ * string, number, boolean or instant, that no automatic program writes.
+ */
+export function keyableProperty(ordering, auto) {
+    return ordering !== undefined && auto === undefined;
+}
+/**
+ * The values of the fields of `tuple` on `edge`, in order, or undefined when one of them is absent,
+ * so that an Edge without a slug or without a Property never collides.
+ */
+export function edgeUniqueValues(tuple, edge) {
+    return keyValues(tuple, (field) => typeof field === 'string' ? edge[field] : propertyOf(edge.props, field.property));
+}
+/**
+ * The value `edge` takes under `tuple`, the canonical JSON of the values of its fields, or
+ * undefined when one of them is absent: two distinct Edges of the Classes a tuple covers collide
+ * exactly when they take one value. Endpoints compare by NodeId, slugs by exact text and
+ * Properties by canonical Value.
+ */
+export function edgeUniqueValue(tuple, edge) {
+    return serialized(edgeUniqueValues(tuple, edge));
+}
+/**
+ * The values of the Properties of `tuple` on `node`, in order, or undefined when one of them is
+ * absent, so that a Node without one of them never collides, like NULL in an SQL UNIQUE.
+ */
+export function nodeUniqueValues(tuple, node) {
+    return keyValues(tuple, (key) => propertyOf(node.props, key));
+}
+/**
+ * The value `node` takes under `tuple`, the canonical JSON of the values of its Properties, or
+ * undefined when one of them is absent: two distinct Nodes of the Classes a tuple covers collide
+ * exactly when they take one value. Properties compare by canonical Value, nothing normalized.
+ */
+export function nodeUniqueValue(tuple, node) {
+    return serialized(nodeUniqueValues(tuple, node));
+}
+/**
+ * The tuples covering `candidate`: those it and each of its ancestors declare, each with the Class
+ * declaring it, ancestors found by `resolve`. A descendant never restates them.
+ */
+export function coveringEdgeUniqueTuples(candidate, resolve) {
+    return coveringTuples(candidate, resolve);
+}
+/**
+ * The Node tuples covering `candidate`: those it and each of its ancestors declare, each with the
+ * Class declaring it, ancestors found by `resolve`. A descendant never restates them.
+ */
+export function coveringNodeUniqueTuples(candidate, resolve) {
+    return coveringTuples(candidate, resolve);
+}
+/**
+ * The keys `edge` holds: its value under each tuple of `tuples`, tagged by the Class declaring the
+ * tuple, so two Edges collide exactly when they hold one key.
+ */
+export function edgeUniqueKeys(tuples, edge) {
+    return heldKeys(tuples, (fields) => edgeUniqueValue(fields, edge));
+}
+/**
+ * The keys `node` holds: its value under each tuple of `tuples`, tagged by the Class declaring the
+ * tuple, so two Nodes collide exactly when they hold one key.
+ */
+export function nodeUniqueKeys(tuples, node) {
+    return heldKeys(tuples, (fields) => nodeUniqueValue(fields, node));
+}
+/** The values `read` gives the fields of `tuple`, in order, or undefined when one is absent. */
+function keyValues(tuple, read) {
+    const values = [];
+    for (const field of tuple) {
+        const value = read(field);
+        if (value === undefined)
+            return undefined;
+        values.push(value);
+    }
+    return Object.freeze(values);
+}
+/** The value of the Property `key` in `props`, or undefined when it is absent. */
+function propertyOf(props, key) {
+    return Object.hasOwn(props, key) ? props[key] : undefined;
+}
+/** The canonical JSON of a key's values, or undefined when it has none. */
+function serialized(values) {
+    return values === undefined ? undefined : json.serializeAdmitted(values);
+}
+/**
+ * The tuples `candidate` and its ancestors declare, each with its declarer. Only ancestors of the
+ * candidate's kind are visited, so every tuple is of that kind.
+ */
+function coveringTuples(candidate, resolve) {
+    const tuples = [];
+    const seen = new Set();
+    const visit = (value) => {
+        if (seen.has(value) || value.kind !== candidate.kind)
+            return;
+        seen.add(value);
+        for (const fields of value.unique ?? [])
+            tuples.push(Object.freeze({ class: ClassKey.of(value.ref), fields }));
+        for (const ref of value.extends) {
+            const parent = resolve(ref);
+            if (parent !== undefined)
+                visit(parent);
+        }
+    };
+    visit(candidate);
+    return Object.freeze(tuples);
+}
+/** The keys a fact holds under `tuples`, its value under each tagged by the declaring Class. */
+function heldKeys(tuples, valueOf) {
+    return tuples.flatMap(({ class: declaring, fields }) => {
+        const value = valueOf(fields);
+        return value === undefined ? [] : [JSON.stringify([declaring, fields, value])];
+    });
+}
+/** The lexicographic order of sequences by `compare`, a sequence before every one it prefixes. */
+function compareSequences(compare) {
+    return (left, right) => {
+        for (let index = 0; index < Math.min(left.length, right.length); index += 1) {
+            const order = compare(left[index], right[index]);
+            if (order !== 0)
+                return order;
+        }
+        return left.length - right.length;
+    };
+}

package/dist/v1/language/index.d.ts

@@ -1,3 +1,4 @@
+export { admissionInputFields, isAdmissionMaxAge, MAXIMUM_ADMISSION_AGE_SECONDS, } from './callable/admission.js';
 export { isMethodExecutable } from './callable/executable.js';
 export { isBinaryInput } from './callable/model/callable.js';
 export type { ClassRef, CoreRef, DefinitionBase, DefinitionKey, DefinitionRef, FunctionRef, MethodKey, PolicyRef, PropertyKey, ViewRef, } from '../addressing/index.js';
@@ -13,8 +14,11 @@ export type * from './callable/resolved.js';
 export type * from './class/model/class.js';
 export type { DataDefinition, DataFacet, MediaType } from './class/model/data.js';
 export type * from './class/model/edge.js';
-export { edgeLifetimes } from './class/lifetime.js';
-export type { EdgeLifetime } from './class/lifetime.js';
+export { admitsForeignSubclass, inheritanceOf } from './class/inheritance.js';
+export { edgeLifetimes, lifetimeScope } from './class/lifetime.js';
+export type { LifetimeScope } from './class/lifetime.js';
+export { EDGE_UNIQUE_FORMS, NODE_UNIQUE_FORMS, NO_UNIQUE_FORMS, UNIQUE_FORMS, compareEdgeUniqueFields, compareEdgeUniqueTuples, compareNodeUniqueTuples, coveringEdgeUniqueTuples, coveringNodeUniqueTuples, edgeUniqueForm, edgeUniqueFormOf, edgeUniqueKeys, edgeUniqueTuple, edgeUniqueValue, edgeUniqueValues, enforcesEdgeUniqueTuple, enforcesNodeUniqueTuple, keyableProperty, namedEdgeUniqueTuple, nodeUniqueForm, nodeUniqueKeys, nodeUniqueTuple, nodeUniqueValue, nodeUniqueValues, } from './class/unique.js';
+export type { DeclaredEdgeUniqueTuple, DeclaredNodeUniqueTuple, EdgeUniqueFacts, NodeUniqueFacts, UniqueForms, } from './class/unique.js';
 export type * from './class/model/property.js';
 export type * from './class/resolved.js';
 export type * from './class/facets.js';

package/dist/v1/language/index.js

@@ -1,7 +1,10 @@
+export { admissionInputFields, isAdmissionMaxAge, MAXIMUM_ADMISSION_AGE_SECONDS, } from './callable/admission.js';
 export { isMethodExecutable } from './callable/executable.js';
 export { isBinaryInput } from './callable/model/callable.js';
 export { valueProgramIncludes } from './value/inclusion/includes.js';
 export { stateMachine } from './state/index.js';
-export { edgeLifetimes } from './class/lifetime.js';
+export { admitsForeignSubclass, inheritanceOf } from './class/inheritance.js';
+export { edgeLifetimes, lifetimeScope } from './class/lifetime.js';
+export { EDGE_UNIQUE_FORMS, NODE_UNIQUE_FORMS, NO_UNIQUE_FORMS, UNIQUE_FORMS, compareEdgeUniqueFields, compareEdgeUniqueTuples, compareNodeUniqueTuples, coveringEdgeUniqueTuples, coveringNodeUniqueTuples, edgeUniqueForm, edgeUniqueFormOf, edgeUniqueKeys, edgeUniqueTuple, edgeUniqueValue, edgeUniqueValues, enforcesEdgeUniqueTuple, enforcesNodeUniqueTuple, keyableProperty, namedEdgeUniqueTuple, nodeUniqueForm, nodeUniqueKeys, nodeUniqueTuple, nodeUniqueValue, nodeUniqueValues, } from './class/unique.js';
 export { PropertyValues } from './class/property-values.js';
 export { isClassRuleChecks, policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, projectedMemberClass, } from './policy/model/policy.js';

package/dist/v1/language/value/evaluate/validate.js

@@ -2,6 +2,7 @@ import { diagnostic } from '../../validation/diagnostic.js';
 import { validateCanonicalJsonDomain } from '../profile/json.validate.js';
 import { evaluateInstance } from './evaluator.js';
 import { prepareValueSchema, } from './preparation.js';
+import { satisfies } from './validity.optimization.js';
 const validatorCache = new WeakMap();
 /**
  * Validate one complete portable value with the admitted V1 Draft 2020-12 profile.
@@ -30,6 +31,9 @@ export function validatePreparedInstance(compiled, value) {
         : instanceDiagnostics(compiled, value, '');
 }
 function instanceDiagnostics(compiled, value, pointer) {
+    // A value the compiled check finds valid has nothing to report; any other is evaluated.
+    if (satisfies(compiled, value) === true)
+        return [];
     const result = evaluateInstance(compiled, value);
     if (result.valid)
         return [];

package/dist/v1/language/value/evaluate/validity.optimization.d.ts

@@ -0,0 +1,14 @@
+import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+import type { CompiledInstanceSchema } from './types.js';
+/**
+ * Whether a value satisfies its prepared schema, as the evaluator decides it, without building a
+ * failure, an instance pointer or an annotation: the evaluator's verdict, or undefined when this
+ * check cannot give it. Only the evaluator reports why a value fails, so a caller keeps it for
+ * every value this check does not find valid.
+ *
+ * Each schema location is compiled once into a closure over its keywords, retained with the
+ * prepared schema. A schema whose closure holds an annotation-dependent keyword
+ * (`unevaluatedItems`, `unevaluatedProperties`) is left to the evaluator, as is a value nested
+ * deeper than this check follows, and any value whose check throws.
+ */
+export declare function satisfies(compiled: CompiledInstanceSchema, value: JsonValue): boolean | undefined;

package/dist/v1/language/value/evaluate/validity.optimization.js

@@ -0,0 +1,342 @@
+import { isCanonicalBlobRef } from '../model/blob.js';
+import { isInstantValue } from '../model/instant.js';
+import { isValueObject as isJsonObject } from '../model/object.js';
+import { codePointLength, isMultipleOf, jsonEqual, matchesType, unique } from './assertions.js';
+/**
+ * Whether a value satisfies its prepared schema, as the evaluator decides it, without building a
+ * failure, an instance pointer or an annotation: the evaluator's verdict, or undefined when this
+ * check cannot give it. Only the evaluator reports why a value fails, so a caller keeps it for
+ * every value this check does not find valid.
+ *
+ * Each schema location is compiled once into a closure over its keywords, retained with the
+ * prepared schema. A schema whose closure holds an annotation-dependent keyword
+ * (`unevaluatedItems`, `unevaluatedProperties`) is left to the evaluator, as is a value nested
+ * deeper than this check follows, and any value whose check throws.
+ */
+export function satisfies(compiled, value) {
+    let checks = compilations.get(compiled);
+    if (checks === undefined) {
+        checks = annotationFree(compiled) ? new Map() : null;
+        compilations.set(compiled, checks);
+    }
+    if (checks === null)
+        return undefined;
+    const outer = verdicts;
+    verdicts = new Map();
+    try {
+        return checkOf(compiled, checks, compiled.root)(value, 0);
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        verdicts = outer;
+    }
+}
+/** Per prepared schema: its checks by location, or null when its closure needs annotations. */
+const compilations = new WeakMap();
+/** Locations one evaluation follows before leaving the value to the evaluator. */
+const MAXIMUM_DEPTH = 1_024;
+const UNDECIDED = new Error('The value is left to the evaluator.');
+/**
+ * The verdicts of the current evaluation by referenced location and value. Only a reference reaches
+ * one location from several places, so each referenced location is checked once per value, as the
+ * evaluator memoizes it, and a schema that references a location twice per level stays linear. A
+ * location entered again on the same value is a cycle, left to the evaluator.
+ */
+let verdicts = new Map();
+function annotationFree(compiled) {
+    for (const { schema } of compiled.locations.values()) {
+        if (isJsonObject(schema) &&
+            (Object.hasOwn(schema, 'unevaluatedItems') || Object.hasOwn(schema, 'unevaluatedProperties'))) {
+            return false;
+        }
+    }
+    return true;
+}
+/** The check of one location, compiled on its first use so that references may recur. */
+function checkOf(compiled, checks, location) {
+    let check = checks.get(location);
+    if (check === undefined) {
+        let body;
+        check = (value, depth) => {
+            if (depth > MAXIMUM_DEPTH)
+                throw UNDECIDED;
+            body ??= compileLocation(compiled, checks, location);
+            return body(value, depth);
+        };
+        checks.set(location, check);
+    }
+    return check;
+}
+/**
+ * The conjunction of the location's keywords, each as the evaluator applies it: an applicator
+ * checks the same value at its child location, a keyword of one type passes every other type.
+ */
+function compileLocation(compiled, checks, location) {
+    const schema = location.schema;
+    if (schema === true)
+        return () => true;
+    if (schema === false)
+        return () => false;
+    const child = (keyword, member) => checkOf(compiled, checks, compiled.child(location, keyword, member));
+    const parts = [];
+    if (Object.hasOwn(schema, '$ref')) {
+        const target = compiled.reference(location);
+        if (target === undefined)
+            throw UNDECIDED;
+        const check = checkOf(compiled, checks, target);
+        parts.push((value, depth) => {
+            let byValue = verdicts.get(target);
+            if (byValue === undefined)
+                verdicts.set(target, (byValue = new Map()));
+            const known = byValue.get(value);
+            if (known === null)
+                throw UNDECIDED;
+            if (known !== undefined)
+                return known;
+            byValue.set(value, null);
+            const verdict = check(value, depth + 1);
+            byValue.set(value, verdict);
+            return verdict;
+        });
+    }
+    compileCompositions(schema, child, parts);
+    compileCommon(schema, parts);
+    compileNumber(schema, parts);
+    compileString(compiled, schema, parts);
+    compileArray(schema, child, parts);
+    compileObject(compiled, schema, child, parts);
+    if (parts.length === 0)
+        return () => true;
+    if (parts.length === 1)
+        return parts[0];
+    return (value, depth) => {
+        for (const part of parts)
+            if (!part(value, depth))
+                return false;
+        return true;
+    };
+}
+function compileCompositions(schema, child, parts) {
+    const allOf = schemaList(schema.allOf)?.map((_, index) => child('allOf', index));
+    if (allOf !== undefined) {
+        parts.push((value, depth) => allOf.every((check) => check(value, depth + 1)));
+    }
+    const anyOf = schemaList(schema.anyOf)?.map((_, index) => child('anyOf', index));
+    if (anyOf !== undefined) {
+        parts.push((value, depth) => anyOf.some((check) => check(value, depth + 1)));
+    }
+    const oneOf = schemaList(schema.oneOf)?.map((_, index) => child('oneOf', index));
+    if (oneOf !== undefined) {
+        parts.push((value, depth) => {
+            let admitted = 0;
+            for (const check of oneOf)
+                if (check(value, depth + 1) && ++admitted > 1)
+                    return false;
+            return admitted === 1;
+        });
+    }
+    if (isSchema(schema.not)) {
+        const not = child('not');
+        parts.push((value, depth) => !not(value, depth + 1));
+    }
+    if (isSchema(schema.if)) {
+        const condition = child('if');
+        const then = isSchema(schema.then) ? child('then') : undefined;
+        const otherwise = isSchema(schema.else) ? child('else') : undefined;
+        parts.push((value, depth) => {
+            const branch = condition(value, depth + 1) ? then : otherwise;
+            return branch === undefined || branch(value, depth + 1);
+        });
+    }
+}
+function compileCommon(schema, parts) {
+    const kind = schema['x-astrale-value-kind'];
+    if (kind === 'instant')
+        parts.push((value) => isInstantValue(value));
+    if (kind === 'blob')
+        parts.push((value) => isCanonicalBlobRef(value));
+    const type = schema.type;
+    if (typeof type === 'string')
+        parts.push((value) => matchesType(type, value));
+    else if (Array.isArray(type)) {
+        const types = type.filter((candidate) => typeof candidate === 'string');
+        parts.push((value) => types.some((candidate) => matchesType(candidate, value)));
+    }
+    if (Object.hasOwn(schema, 'const')) {
+        const expected = schema.const;
+        parts.push((value) => jsonEqual(value, expected));
+    }
+    const choices = schema.enum;
+    if (Array.isArray(choices)) {
+        parts.push((value) => choices.some((candidate) => jsonEqual(value, candidate)));
+    }
+}
+function compileNumber(schema, parts) {
+    const { multipleOf, maximum, exclusiveMaximum, minimum, exclusiveMinimum } = schema;
+    const bounded = typeof multipleOf === 'number' ||
+        typeof maximum === 'number' ||
+        typeof exclusiveMaximum === 'number' ||
+        typeof minimum === 'number' ||
+        typeof exclusiveMinimum === 'number';
+    if (!bounded)
+        return;
+    parts.push((value) => typeof value !== 'number' ||
+        ((typeof multipleOf !== 'number' || isMultipleOf(value, multipleOf)) &&
+            (typeof maximum !== 'number' || value <= maximum) &&
+            (typeof exclusiveMaximum !== 'number' || value < exclusiveMaximum) &&
+            (typeof minimum !== 'number' || value >= minimum) &&
+            (typeof exclusiveMinimum !== 'number' || value > exclusiveMinimum)));
+}
+function compileString(compiled, schema, parts) {
+    const { maxLength, minLength, pattern, fullMatch } = schema;
+    if (typeof maxLength === 'number' || typeof minLength === 'number') {
+        // For n UTF-16 units, ceil(n / 2) <= code points <= n: count only when the bounds cannot
+        // decide, as the evaluator does.
+        parts.push((value) => {
+            if (typeof value !== 'string')
+                return true;
+            if ((typeof maxLength !== 'number' || value.length <= maxLength) &&
+                (typeof minLength !== 'number' || Math.ceil(value.length / 2) >= minLength)) {
+                return true;
+            }
+            const length = codePointLength(value);
+            return ((typeof maxLength !== 'number' || length <= maxLength) &&
+                (typeof minLength !== 'number' || length >= minLength));
+        });
+    }
+    if (typeof pattern === 'string') {
+        const matcher = compiled.matcher(pattern);
+        parts.push((value) => typeof value !== 'string' || matcher.test(value));
+    }
+    if (typeof fullMatch === 'string') {
+        const matcher = compiled.matcher(fullMatch);
+        parts.push((value) => typeof value !== 'string' || matcher.matches(value));
+    }
+}
+function compileArray(schema, child, parts) {
+    const { maxItems, minItems } = schema;
+    if (typeof maxItems === 'number' || typeof minItems === 'number' || schema.uniqueItems === true) {
+        const distinct = schema.uniqueItems === true;
+        parts.push((value) => !Array.isArray(value) ||
+            ((typeof maxItems !== 'number' || value.length <= maxItems) &&
+                (typeof minItems !== 'number' || value.length >= minItems) &&
+                (!distinct || unique(value))));
+    }
+    const prefix = schemaList(schema.prefixItems)?.map((_, index) => child('prefixItems', index));
+    const items = isSchema(schema.items) ? child('items') : undefined;
+    if (prefix !== undefined || items !== undefined) {
+        const leading = prefix ?? [];
+        parts.push((value, depth) => {
+            if (!Array.isArray(value))
+                return true;
+            for (let index = 0; index < value.length; index++) {
+                const check = index < leading.length ? leading[index] : items;
+                if (check !== undefined && !check(value[index], depth + 1))
+                    return false;
+            }
+            return true;
+        });
+    }
+    if (isSchema(schema.contains)) {
+        const contains = child('contains');
+        const least = typeof schema.minContains === 'number' ? schema.minContains : 1;
+        const most = typeof schema.maxContains === 'number' ? schema.maxContains : Number.POSITIVE_INFINITY;
+        parts.push((value, depth) => {
+            if (!Array.isArray(value))
+                return true;
+            let matches = 0;
+            for (const item of value)
+                if (contains(item, depth + 1))
+                    matches++;
+            return matches >= least && matches <= most;
+        });
+    }
+}
+function compileObject(compiled, schema, child, parts) {
+    const { maxProperties, minProperties } = schema;
+    const required = Array.isArray(schema.required)
+        ? schema.required.filter((name) => typeof name === 'string')
+        : [];
+    const dependentRequired = isJsonObject(schema.dependentRequired)
+        ? Object.entries(schema.dependentRequired).flatMap(([name, names]) => Array.isArray(names)
+            ? [[name, names.filter((other) => typeof other === 'string')]]
+            : [])
+        : [];
+    if (typeof maxProperties === 'number' ||
+        typeof minProperties === 'number' ||
+        required.length > 0 ||
+        dependentRequired.length > 0) {
+        parts.push((value) => {
+            if (!isJsonObject(value))
+                return true;
+            if (typeof maxProperties === 'number' || typeof minProperties === 'number') {
+                const count = Object.keys(value).length;
+                if (typeof maxProperties === 'number' && count > maxProperties)
+                    return false;
+                if (typeof minProperties === 'number' && count < minProperties)
+                    return false;
+            }
+            for (const name of required)
+                if (!Object.hasOwn(value, name))
+                    return false;
+            for (const [name, names] of dependentRequired) {
+                if (Object.hasOwn(value, name) && !names.every((other) => Object.hasOwn(value, other))) {
+                    return false;
+                }
+            }
+            return true;
+        });
+    }
+    // Each member is checked by every pattern it matches, by its declared schema, and by the
+    // additional schema when neither declares it.
+    const declared = isJsonObject(schema.properties) ? schema.properties : {};
+    const properties = new Map(Object.keys(declared).map((name) => [name, child('properties', name)]));
+    const patterns = isJsonObject(schema.patternProperties)
+        ? Object.keys(schema.patternProperties).map((source) => [compiled.matcher(source), child('patternProperties', source)])
+        : [];
+    const additional = isSchema(schema.additionalProperties)
+        ? child('additionalProperties')
+        : undefined;
+    const names = isSchema(schema.propertyNames) ? child('propertyNames') : undefined;
+    if (properties.size > 0 || patterns.length > 0 || additional !== undefined || names) {
+        parts.push((value, depth) => {
+            if (!isJsonObject(value))
+                return true;
+            for (const name of Object.keys(value)) {
+                const member = value[name];
+                let matched = false;
+                for (const [matcher, check] of patterns) {
+                    if (!matcher.test(name))
+                        continue;
+                    matched = true;
+                    if (!check(member, depth + 1))
+                        return false;
+                }
+                const check = Object.hasOwn(declared, name) ? properties.get(name) : undefined;
+                if (check !== undefined) {
+                    if (!check(member, depth + 1))
+                        return false;
+                }
+                else if (!matched && additional !== undefined && !additional(member, depth + 1)) {
+                    return false;
+                }
+                if (names !== undefined && !names(name, depth + 1))
+                    return false;
+            }
+            return true;
+        });
+    }
+    if (isJsonObject(schema.dependentSchemas)) {
+        const dependent = Object.keys(schema.dependentSchemas).map((name) => [name, child('dependentSchemas', name)]);
+        parts.push((value, depth) => !isJsonObject(value) ||
+            dependent.every(([name, check]) => !Object.hasOwn(value, name) || check(value, depth + 1)));
+    }
+}
+function schemaList(input) {
+    return Array.isArray(input) ? input : undefined;
+}
+function isSchema(input) {
+    return typeof input === 'boolean' || isJsonObject(input);
+}