@astrale-os/kernel-dsl 0.2.0-beta.4 → 0.2.0-beta.40

package/dist/v1/compiled/admission/accept.js

@@ -0,0 +1,1050 @@
+import { accept as acceptPortable } from '@astrale-os/kernel-dsl/value';
+import { dependencyLimits } from '../../addressing/domain-dependency.js';
+import { isDefinitionRef, Key } from '../../addressing/index.js';
+import { DEPENDENCY_ALIAS_PATTERN, DOMAIN_ORIGIN_PATTERN, DOMAIN_REVISION_PATTERN, MEMBER_NAME_PATTERN, } from '../../addressing/patterns.js';
+import { MEDIA_TYPE_PATTERN } from '../../language/class/model/data.js';
+import { PropertyValues } from '../../language/class/property-values.js';
+import { admitStateTopology } from '../../language/state/topology.js';
+import { bindValueProgram } from '../../language/value/compile/load.js';
+import { isValueObject } from '../../language/value/model/object.js';
+import { classifyValueProgramOrdering } from '../../language/value/ordering.js';
+import { invalidCompiled } from '../diagnostic.js';
+import { revisionOfCompiledEntry } from './revision.js';
+import { validateCompiledSemantics } from './semantics.js';
+const MAXIMUM_COMPILED_SCHEMA_MEMBERS = 1_000_000;
+function pointer(parent, member) {
+    return `${parent}/${String(member).replaceAll('~', '~0').replaceAll('/', '~1')}`;
+}
+/** Admit one detached compiled closure before indices and declarations become executable. */
+export function acceptCompiledSchema(input) {
+    const root = object(acceptPortable(input, { limits: { maxMembers: MAXIMUM_COMPILED_SCHEMA_MEMBERS } }), 'CompiledSchema', '');
+    exact(root, ['format', 'version', 'root', 'closure'], 'CompiledSchema', '');
+    if (root.format !== 'astrale.dsl.compiled-schema')
+        invalid('format', undefined, '/format');
+    if (root.version !== 1 && root.version !== 2)
+        invalid('version', undefined, '/version');
+    const version = root.version;
+    const rootPin = dependency(root.root, 'root', '/root');
+    const closure = array(root.closure, 'closure', '/closure').map((value, index) => entry(value, index, `/closure/${index}`, version));
+    if (closure.length > dependencyLimits.closure) {
+        invalid('dependency closure limit', 'COMPILED_DEPENDENCY_LIMITS', '/closure');
+    }
+    const closureOrigins = new Set();
+    for (const [index, value] of closure.entries()) {
+        if (closureOrigins.has(value.origin))
+            invalid('closure origins', undefined, `/closure/${index}/origin`);
+        closureOrigins.add(value.origin);
+    }
+    const byOrigin = new Map(closure.map((value) => [value.origin, value]));
+    const rootEntry = byOrigin.get(rootPin.origin);
+    if (rootEntry?.revision !== rootPin.revision)
+        invalid('root pin', undefined, '/root');
+    for (const [entryIndex, owner] of closure.entries()) {
+        if (Object.keys(owner.dependencies).length > dependencyLimits.direct) {
+            invalid('direct dependency limit', 'COMPILED_DEPENDENCY_LIMITS', `/closure/${entryIndex}/dependencies`);
+        }
+        for (const [alias, pin] of Object.entries(owner.dependencies)) {
+            if (byOrigin.get(pin.origin)?.revision !== pin.revision)
+                invalid('dependency closure', undefined, pointer(`/closure/${entryIndex}/dependencies`, alias));
+        }
+    }
+    const reachable = new Set();
+    const visit = (origin) => {
+        if (reachable.has(origin))
+            return;
+        reachable.add(origin);
+        const owner = byOrigin.get(origin);
+        if (owner !== undefined) {
+            for (const { origin: dependencyOrigin } of Object.values(owner.dependencies)) {
+                visit(dependencyOrigin);
+            }
+        }
+    };
+    visit(rootPin.origin);
+    if (reachable.size !== closure.length) {
+        const unrelatedIndex = closure.findIndex(({ origin }) => !reachable.has(origin));
+        invalid('unrelated closure entry', undefined, `/closure/${unrelatedIndex}`);
+    }
+    const candidate = {
+        format: 'astrale.dsl.compiled-schema',
+        version: 2,
+        root: rootPin,
+        closure,
+    };
+    validateClosure(candidate);
+    validateCompiledSemantics(candidate);
+    return deepFreeze(candidate);
+}
+function entry(input, entryIndex, path, version) {
+    const value = object(input, `closure[${entryIndex}]`, path);
+    exact(value, [
+        'origin',
+        'revision',
+        'dependencies',
+        'definitions',
+        'facts',
+        'values',
+        ...(version === 2 ? ['patterns'] : []),
+    ], 'entry', path);
+    const origin = originValue(value.origin, 'entry origin', `${path}/origin`);
+    const revision = revisionValue(value.revision, 'entry revision', `${path}/revision`);
+    const dependenciesPath = `${path}/dependencies`;
+    const dependencies = dependencyMap(value.dependencies, dependenciesPath);
+    const dependencyOrigins = new Set();
+    for (const [alias, dependency] of Object.entries(dependencies)) {
+        if (dependencyOrigins.has(dependency.origin))
+            invalid('duplicate dependency', undefined, `${pointer(dependenciesPath, alias)}/origin`);
+        dependencyOrigins.add(dependency.origin);
+    }
+    const valuesPath = `${path}/values`;
+    const patternsPath = `${path}/patterns`;
+    const patterns = version === 2
+        ? array(value.patterns, 'entry patterns', patternsPath).map((item, index) => pattern(item, index, `${patternsPath}/${index}`, true))
+        : [];
+    const values = array(value.values, 'values', valuesPath).map((item, index) => program(item, index, `${valuesPath}/${index}`, patterns, version));
+    const bound = values.map((value) => bindValueProgram(value, patterns));
+    const definitionsPath = `${path}/definitions`;
+    const definitions = object(value.definitions, 'definitions', definitionsPath);
+    exact(definitions, ['classes', 'functions', 'policies', 'views', 'core'], 'definitions', definitionsPath);
+    const classesPath = `${definitionsPath}/classes`;
+    const classes = array(definitions.classes, 'classes', classesPath).map((item, index) => compiledClass(item, bound, `${classesPath}/${index}`));
+    const functionsPath = `${definitionsPath}/functions`;
+    const functions = array(definitions.functions, 'functions', functionsPath).map((item, index) => compiledFunction(item, bound, `${functionsPath}/${index}`));
+    const factsPath = `${path}/facts`;
+    const facts = object(value.facts, 'facts', factsPath);
+    exact(facts, ['core'], 'facts', factsPath);
+    const policiesPath = `${definitionsPath}/policies`;
+    const viewsPath = `${definitionsPath}/views`;
+    const coreDefinitionsPath = `${definitionsPath}/core`;
+    const coreFactsPath = `${factsPath}/core`;
+    const accepted = {
+        origin,
+        revision,
+        dependencies,
+        definitions: {
+            classes,
+            functions,
+            policies: array(definitions.policies, 'policies', policiesPath).map((item, index) => compiledPolicy(item, `${policiesPath}/${index}`)),
+            views: array(definitions.views, 'views', viewsPath).map((item, index) => compiledView(item, `${viewsPath}/${index}`)),
+            core: array(definitions.core, 'core definitions', coreDefinitionsPath).map((item, index) => compiledCoreDefinition(item, `${coreDefinitionsPath}/${index}`)),
+        },
+        facts: {
+            core: array(facts.core, 'core facts', coreFactsPath).map((item, index) => compiledCoreEdge(item, `${coreFactsPath}/${index}`)),
+        },
+        values,
+        patterns,
+    };
+    const collections = [
+        ['classes', accepted.definitions.classes],
+        ['functions', accepted.definitions.functions],
+        ['policies', accepted.definitions.policies],
+        ['views', accepted.definitions.views],
+        ['core', accepted.definitions.core],
+    ];
+    for (const [collection, definitions] of collections) {
+        for (const [index, definition] of definitions.entries()) {
+            if (definition.ref.origin !== origin)
+                invalid('Definition owner origin', undefined, `${definitionsPath}/${collection}/${index}/ref/origin`);
+        }
+    }
+    if (revisionOfCompiledEntry(accepted) !== revision) {
+        invalid('entry revision', 'COMPILED_CANONICAL_MISMATCH', `${path}/revision`);
+    }
+    return accepted;
+}
+function compiledClass(input, values, path) {
+    const value = object(input, 'Compiled Class', path);
+    if (value.kind !== 'node' && value.kind !== 'edge')
+        invalid('Class kind', undefined, `${path}/kind`);
+    exact(value, value.kind === 'node'
+        ? ['ref', 'kind', 'abstract', 'extends', 'properties', 'methods', 'policies']
+        : [
+            'ref',
+            'kind',
+            'abstract',
+            'extends',
+            'orientation',
+            'endpoints',
+            'constraints',
+            'properties',
+            'policies',
+        ], 'Compiled Class', path, value.kind === 'node' ? ['data', 'description', 'icon'] : ['description']);
+    definitionRef(value.ref, 'class', 'Class ref', `${path}/ref`);
+    boolean(value.abstract, 'Class abstract', `${path}/abstract`);
+    description(value.description, 'Class description', `${path}/description`);
+    const extendsPath = `${path}/extends`;
+    const parents = array(value.extends, 'Class extends', extendsPath).map((parent, index) => definitionRef(parent, 'class', 'Class parent', `${extendsPath}/${index}`));
+    unique(parents.map(Key.of), 'Class parents', extendsPath);
+    const propertiesPath = `${path}/properties`;
+    const properties = array(value.properties, 'Class properties', propertiesPath).map((property, index) => compiledProperty(property, values, value.kind === 'node', `${propertiesPath}/${index}`));
+    unique(properties.map((property) => property.name), 'Class Properties', propertiesPath);
+    if (value.kind === 'node') {
+        if (value.data !== undefined)
+            dataDefinition(value.data, `${path}/data`);
+        boundedString(value.icon, 1, 8000, 'Class icon', `${path}/icon`);
+        classPolicies(value.policies, `${path}/policies`);
+        const methodsPath = `${path}/methods`;
+        const methods = array(value.methods, 'Class methods', methodsPath);
+        for (const [index, method] of methods.entries())
+            compiledCallable(method, values, true, `${methodsPath}/${index}`);
+        unique(methods.map((method, index) => string(object(method, 'Compiled Method', `${methodsPath}/${index}`).name, 'Method name', `${methodsPath}/${index}/name`)), 'Class Methods', methodsPath);
+    }
+    else {
+        classPolicies(value.policies, `${path}/policies`);
+        edgeContract(value, path);
+    }
+    return { ...value, properties };
+}
+function compiledFunction(input, values, path) {
+    const value = object(input, 'Compiled Function', path);
+    compiledCallable(value, values, false, path);
+    definitionRef(value.ref, 'function', 'Function ref', `${path}/ref`);
+    return value;
+}
+function compiledProperty(input, values, node, path) {
+    const value = object(input, 'Compiled Property', path);
+    exact(value, ['name', 'required', 'value'], 'Compiled Property', path, [
+        'auto',
+        'description',
+        'ordering',
+        'state',
+    ]);
+    memberName(value.name, 'Property name', `${path}/name`);
+    boolean(value.required, 'Property required', `${path}/required`);
+    description(value.description, 'Property description', `${path}/description`);
+    if (value.auto !== undefined)
+        propertyAuto(value.auto, `${path}/auto`);
+    const valueIndex = index(value.value, values.length, 'Property value', `${path}/value`);
+    let state;
+    if (value.state !== undefined) {
+        if (!node)
+            invalid('Property state placement', 'COMPILED_SOURCE_INVALID', `${path}/state`);
+        let topology;
+        try {
+            topology = admitStateTopology(value.state);
+        }
+        catch {
+            invalid('Property state topology', 'COMPILED_SOURCE_INVALID', `${path}/state`);
+        }
+        const program = values[valueIndex];
+        const schema = program.nodes[program.root].schema;
+        const states = Object.keys(topology.transitions);
+        const schemaObject = schema;
+        const schemaMatches = schema !== null &&
+            typeof schema === 'object' &&
+            !Array.isArray(schema) &&
+            Object.keys(schemaObject).length === 2 &&
+            schemaObject.type === 'string' &&
+            Array.isArray(schemaObject.enum) &&
+            schemaObject.enum.length === states.length &&
+            schemaObject.enum.every((state, index) => state === states[index]);
+        if (!value.required || value.auto !== undefined || !schemaMatches) {
+            invalid('Property state contract', 'COMPILED_SOURCE_INVALID', `${path}/state`);
+        }
+        state = topology;
+    }
+    if (value.ordering !== classifyValueProgramOrdering(values[valueIndex])) {
+        invalid('Property ordering', 'COMPILED_CANONICAL_MISMATCH', `${path}/ordering`);
+    }
+    return {
+        ...value,
+        ...(state === undefined ? {} : { state }),
+    };
+}
+function compiledCallable(input, values, method, path) {
+    const value = object(input, 'Compiled Callable', path);
+    exact(value, method
+        ? ['name', 'auth', 'static', 'abstract', 'input', 'output']
+        : ['ref', 'auth', 'input', 'output'], 'Compiled Callable', path, ['policy', 'description', 'fields']);
+    if (method) {
+        memberName(value.name, 'Method name', `${path}/name`);
+        boolean(value.static, 'Method static', `${path}/static`);
+        boolean(value.abstract, 'Method abstract', `${path}/abstract`);
+    }
+    if (value.auth !== 'anonymous' && value.auth !== 'authenticated' && value.auth !== 'authorized') {
+        invalid('Callable auth', undefined, `${path}/auth`);
+    }
+    description(value.description, 'Callable description', `${path}/description`);
+    if (value.policy !== undefined) {
+        if (value.auth !== 'authorized') {
+            invalid('Callable Policy placement', undefined, `${path}/policy`);
+        }
+        policyCheck(value.policy, 0, `${path}/policy`);
+    }
+    let inputIndex;
+    if (!method && typeof value.input === 'object' && value.input !== null) {
+        const inputPath = `${path}/input`;
+        const binary = object(value.input, 'Binary input', inputPath);
+        exact(binary, ['mode', 'metadata', 'maximumBytes'], 'Binary input', inputPath);
+        if (binary.mode !== 'binary')
+            invalid('Binary input mode', undefined, `${inputPath}/mode`);
+        inputIndex = index(binary.metadata, values.length, 'Binary input metadata', `${inputPath}/metadata`);
+        const maximumBytes = integer(binary.maximumBytes, 'Binary input maximumBytes', `${inputPath}/maximumBytes`);
+        if (maximumBytes < 1)
+            invalid('Binary input maximumBytes', undefined, `${inputPath}/maximumBytes`);
+    }
+    else {
+        inputIndex = index(value.input, values.length, 'Callable input', `${path}/input`);
+    }
+    if (value.fields !== undefined) {
+        const fieldsPath = `${path}/fields`;
+        for (const [field, nodes] of Object.entries(object(value.fields, 'Callable fields', fieldsPath))) {
+            const fieldPath = pointer(fieldsPath, field);
+            const fieldNodes = array(nodes, 'Callable field nodes', fieldPath);
+            if (fieldNodes.length === 0)
+                invalid('Callable field nodes', undefined, fieldPath);
+            for (const [indexValue, node] of fieldNodes.entries()) {
+                index(node, values[inputIndex].nodes.length, 'Callable field', `${fieldPath}/${indexValue}`);
+            }
+        }
+    }
+    const outputPath = `${path}/output`;
+    const output = object(value.output, 'Callable output', outputPath);
+    if (output.mode === 'binary')
+        exact(output, ['mode'], 'binary output', outputPath);
+    else {
+        if (output.mode !== 'value' && output.mode !== 'stream')
+            invalid('Callable output mode', undefined, `${outputPath}/mode`);
+        exact(output, ['mode', 'value'], 'Callable output', outputPath);
+        index(output.value, values.length, 'Callable output value', `${outputPath}/value`);
+    }
+}
+function compiledPolicy(input, path) {
+    const value = object(input, 'Policy', path);
+    exact(value, ['ref', 'expression'], 'Policy', path, ['description']);
+    definitionRef(value.ref, 'policy', 'Policy ref', `${path}/ref`);
+    description(value.description, 'Policy description', `${path}/description`);
+    policyExpression(value.expression, 0, `${path}/expression`);
+    return value;
+}
+function compiledView(input, path) {
+    const value = object(input, 'View', path);
+    exact(value, ['ref', 'target'], 'View', path, ['description']);
+    definitionRef(value.ref, 'view', 'View ref', `${path}/ref`);
+    description(value.description, 'View description', `${path}/description`);
+    const targetPath = `${path}/target`;
+    const target = object(value.target, 'View target', targetPath);
+    if (target.kind === 'domain') {
+        exact(target, ['kind'], 'Domain View target', targetPath);
+    }
+    else if (target.kind === 'definition') {
+        exact(target, ['kind', 'definitions'], 'Definition View target', targetPath);
+        const definitionsPath = `${targetPath}/definitions`;
+        const definitions = array(target.definitions, 'View target definitions', definitionsPath).map((item, index) => definitionRef(item, 'class', 'View target Class', `${definitionsPath}/${index}`));
+        if (definitions.length === 0)
+            invalid('View target definitions', undefined, definitionsPath);
+        unique(definitions.map(Key.of), 'View target definitions', definitionsPath);
+    }
+    else {
+        invalid('View target', undefined, targetPath);
+    }
+    return value;
+}
+function compiledCoreDefinition(input, path) {
+    const value = object(input, 'Core Definition', path);
+    exact(value, ['ref', 'class', 'properties'], 'Core Definition', path);
+    definitionRef(value.ref, 'core', 'Core ref', `${path}/ref`);
+    definitionRef(value.class, 'class', 'Core Class', `${path}/class`);
+    propertyValues(value.properties, 'Core Properties', `${path}/properties`);
+    return value;
+}
+function compiledCoreEdge(input, path) {
+    const value = object(input, 'Core Edge', path);
+    exact(value, ['class', 'source', 'target', 'properties'], 'Core Edge', path);
+    definitionRef(value.class, 'class', 'Core Edge Class', `${path}/class`);
+    coreEndpoint(value.source, 'Core Edge source', `${path}/source`);
+    coreEndpoint(value.target, 'Core Edge target', `${path}/target`);
+    propertyValues(value.properties, 'Core Edge Properties', `${path}/properties`);
+    return value;
+}
+function propertyAuto(input, path) {
+    const value = object(input, 'Property auto', path);
+    exact(value, ['on', 'set'], 'Property auto', path);
+    const eventsPath = `${path}/on`;
+    const events = array(value.on, 'Property auto events', eventsPath);
+    if (events.length === 0 || events.some((event) => event !== 'create' && event !== 'update')) {
+        invalid('Property auto events', undefined, eventsPath);
+    }
+    unique(events.map(String), 'Property auto events', eventsPath);
+    if (value.set !== 'instant')
+        invalid('Property auto setter', undefined, `${path}/set`);
+}
+function classPolicies(input, path) {
+    const value = object(input, 'Class Policies', path);
+    exact(value, [], 'Class Policies', path, ['read', 'traverse']);
+    if (value.read !== undefined)
+        definitionRef(value.read, 'policy', 'Class read Policy', `${path}/read`);
+    if (value.traverse !== undefined)
+        definitionRef(value.traverse, 'policy', 'Class traverse Policy', `${path}/traverse`);
+}
+function edgeContract(value, path) {
+    const constraintsPath = `${path}/constraints`;
+    const constraints = object(value.constraints, 'Edge constraints', constraintsPath);
+    exact(constraints, [], 'Edge constraints', constraintsPath, ['noSelf', 'acyclic']);
+    if (constraints.noSelf !== undefined && constraints.noSelf !== true)
+        invalid('Edge noSelf constraint', undefined, `${constraintsPath}/noSelf`);
+    if (constraints.acyclic !== undefined && constraints.acyclic !== true)
+        invalid('Edge acyclic constraint', undefined, `${constraintsPath}/acyclic`);
+    if (value.orientation === 'directed') {
+        const endpointsPath = `${path}/endpoints`;
+        const endpoints = object(value.endpoints, 'directed Edge endpoints', endpointsPath);
+        exact(endpoints, ['source', 'target'], 'directed Edge endpoints', endpointsPath);
+        edgeEndpoint(endpoints.source, 'outgoing', 'directed Edge source', `${endpointsPath}/source`);
+        edgeEndpoint(endpoints.target, 'incoming', 'directed Edge target', `${endpointsPath}/target`);
+        if (object(endpoints.source, 'directed Edge source', `${endpointsPath}/source`).role ===
+            object(endpoints.target, 'directed Edge target', `${endpointsPath}/target`).role) {
+            invalid('Edge endpoint roles', undefined, endpointsPath);
+        }
+        return;
+    }
+    if (value.orientation !== 'undirected' || constraints.acyclic !== undefined) {
+        invalid('Edge orientation', undefined, `${path}/orientation`);
+    }
+    const endpointsPath = `${path}/endpoints`;
+    const endpoints = array(value.endpoints, 'undirected Edge endpoints', endpointsPath);
+    if (endpoints.length !== 2)
+        invalid('undirected Edge endpoints', undefined, endpointsPath);
+    edgeEndpoint(endpoints[0], 'incident', 'undirected first endpoint', `${endpointsPath}/0`);
+    edgeEndpoint(endpoints[1], 'incident', 'undirected second endpoint', `${endpointsPath}/1`);
+    if (object(endpoints[0], 'undirected first endpoint', `${endpointsPath}/0`).role ===
+        object(endpoints[1], 'undirected second endpoint', `${endpointsPath}/1`).role) {
+        invalid('Edge endpoint roles', undefined, endpointsPath);
+    }
+}
+function edgeEndpoint(input, count, label, path) {
+    const value = object(input, label, path);
+    exact(value, ['role', 'accepts', count], label, path);
+    memberName(value.role, `${label} role`, `${path}/role`);
+    const acceptsPath = `${path}/accepts`;
+    const accepts = array(value.accepts, `${label} accepts`, acceptsPath).map((item, index) => definitionRef(item, 'class', `${label} accepted Class`, `${acceptsPath}/${index}`));
+    if (accepts.length === 0)
+        invalid(`${label} accepts`, undefined, acceptsPath);
+    unique(accepts.map(Key.of), `${label} accepts`, acceptsPath);
+    if (value[count] !== '0..*' &&
+        value[count] !== '1..*' &&
+        value[count] !== '0..1' &&
+        value[count] !== '1') {
+        invalid(`${label} ${count}`, undefined, `${path}/${count}`);
+    }
+}
+function policyExpression(input, depth, path) {
+    if (depth > 64)
+        invalid('Policy expression depth', undefined, path);
+    const value = object(input, 'Policy expression', path);
+    if (Object.hasOwn(value, 'match')) {
+        exact(value, ['match'], 'Policy expression', path);
+        policyPattern(value.match, depth + 1, `${path}/match`);
+        return;
+    }
+    const member = Object.hasOwn(value, 'allOf') ? 'allOf' : 'anyOf';
+    exact(value, [member], 'Policy expression', path);
+    const memberPath = pointer(path, member);
+    const refs = array(value[member], `Policy ${member}`, memberPath).map((item, index) => definitionRef(item, 'policy', `Policy ${member} ref`, `${memberPath}/${index}`));
+    if (refs.length === 0)
+        invalid(`Policy ${member}`, undefined, memberPath);
+    unique(refs.map(Key.of), `Policy ${member}`, memberPath);
+}
+function policyPattern(input, depth, path) {
+    if (depth > 64)
+        invalid('Policy pattern depth', undefined, path);
+    const value = object(input, 'Policy pattern', path);
+    if (Object.hasOwn(value, 'sameNode')) {
+        exact(value, ['sameNode'], 'Policy equality', path);
+        const pair = object(value.sameNode, 'Policy equality', `${path}/sameNode`);
+        exact(pair, ['left', 'right'], 'Policy equality operands', `${path}/sameNode`);
+        policyTerm(pair.left, false, `${path}/sameNode/left`);
+        policyTerm(pair.right, false, `${path}/sameNode/right`);
+        return;
+    }
+    if (Object.hasOwn(value, 'exists')) {
+        exact(value, ['exists'], 'Policy exists', path);
+        const existsPath = `${path}/exists`;
+        const exists = object(value.exists, 'Policy exists', existsPath);
+        exact(exists, ['nodes', 'where'], 'Policy exists', existsPath);
+        const nodesPath = `${existsPath}/nodes`;
+        const nodes = array(exists.nodes, 'Policy variables', nodesPath);
+        if (nodes.length < 1 || nodes.length > 4)
+            invalid('Policy variables', undefined, nodesPath);
+        for (const [index, node] of nodes.entries()) {
+            const variablePath = `${nodesPath}/${index}`;
+            const variable = object(node, 'Policy variable', variablePath);
+            policyTerm(variable.variable, true, `${variablePath}/variable`);
+            if (Object.hasOwn(variable, 'class')) {
+                exact(variable, ['variable', 'class'], 'Policy variable', variablePath);
+                definitionRef(variable.class, 'class', 'Policy variable Class', `${variablePath}/class`);
+            }
+            else {
+                exact(variable, ['variable', 'selector'], 'Policy variable', variablePath);
+                const selectorPath = `${variablePath}/selector`;
+                const selector = object(variable.selector, 'Policy variable selector', selectorPath);
+                if (selector.kind === 'any') {
+                    exact(selector, ['kind'], 'Policy variable selector', selectorPath);
+                }
+                else if (selector.kind === 'satisfies') {
+                    exact(selector, ['kind', 'class'], 'Policy variable selector', selectorPath);
+                    definitionRef(selector.class, 'class', 'Policy variable selector Class', `${selectorPath}/class`);
+                }
+                else {
+                    invalid('Policy variable selector kind', undefined, `${selectorPath}/kind`);
+                }
+            }
+        }
+        policyPattern(exists.where, depth + 1, `${existsPath}/where`);
+        return;
+    }
+    if (Object.hasOwn(value, 'allOf') || Object.hasOwn(value, 'anyOf')) {
+        const member = Object.hasOwn(value, 'allOf') ? 'allOf' : 'anyOf';
+        exact(value, [member], 'Policy pattern composition', path);
+        const memberPath = pointer(path, member);
+        const expressions = array(value[member], `Policy pattern ${member}`, memberPath);
+        if (expressions.length === 0)
+            invalid(`Policy pattern ${member}`, undefined, memberPath);
+        for (const [index, expression] of expressions.entries())
+            policyPattern(expression, depth + 1, `${memberPath}/${index}`);
+        return;
+    }
+    exact(value, ['source', 'class', 'target'], 'Policy Edge pattern', path, ['repeat']);
+    policyTerm(value.source, false, `${path}/source`);
+    definitionRef(value.class, 'class', 'Policy Edge Class', `${path}/class`);
+    policyTerm(value.target, false, `${path}/target`);
+    if (value.repeat !== undefined) {
+        const repeatPath = `${path}/repeat`;
+        const repeat = object(value.repeat, 'Policy repeat', repeatPath);
+        exact(repeat, ['min', 'max'], 'Policy repeat', repeatPath);
+        const minimum = boundedInteger(repeat.min, 0, 3, 'Policy repeat minimum', `${repeatPath}/min`);
+        const maximum = boundedInteger(repeat.max, 0, 3, 'Policy repeat maximum', `${repeatPath}/max`);
+        if (minimum > maximum)
+            invalid('Policy repeat order', undefined, repeatPath);
+    }
+}
+function policyTerm(input, variableOnly, path) {
+    const value = object(input, 'Policy pattern term', path);
+    if (!variableOnly && value.kind === 'ref') {
+        exact(value, ['kind', 'ref'], 'Policy reference term', path);
+        policyObjectRef(value.ref, `${path}/ref`);
+        return;
+    }
+    if (value.kind === 'variable') {
+        exact(value, ['kind', 'id'], 'Policy variable term', path);
+        integer(value.id, 'Policy variable id', `${path}/id`);
+        return;
+    }
+    if (variableOnly ||
+        (value.kind !== 'subject' &&
+            value.kind !== 'object' &&
+            value.kind !== 'source' &&
+            value.kind !== 'target')) {
+        invalid('Policy pattern term', undefined, `${path}/kind`);
+    }
+    exact(value, ['kind'], 'Policy pattern term', path);
+}
+function policyCheck(input, depth, path) {
+    if (depth > 64)
+        invalid('Callable Policy depth', undefined, path);
+    const value = object(input, 'Callable Policy', path);
+    if (Object.hasOwn(value, 'sameNode')) {
+        exact(value, ['sameNode'], 'Callable equality', path);
+        const pair = object(value.sameNode, 'Callable equality', `${path}/sameNode`);
+        exact(pair, ['left', 'right'], 'Callable equality operands', `${path}/sameNode`);
+        policyCheckObject(pair.left, `${path}/sameNode/left`);
+        policyCheckObject(pair.right, `${path}/sameNode/right`);
+        return;
+    }
+    if (Object.hasOwn(value, 'check')) {
+        exact(value, ['check', 'object'], 'Callable Policy check', path);
+        definitionRef(value.check, 'policy', 'Callable Policy ref', `${path}/check`);
+        policyCheckObject(value.object, `${path}/object`);
+        return;
+    }
+    const member = Object.hasOwn(value, 'allOf') ? 'allOf' : 'anyOf';
+    exact(value, [member], 'Callable Policy composition', path);
+    const memberPath = pointer(path, member);
+    const expressions = array(value[member], `Callable Policy ${member}`, memberPath);
+    if (expressions.length === 0)
+        invalid(`Callable Policy ${member}`, undefined, memberPath);
+    for (const [index, expression] of expressions.entries())
+        policyCheck(expression, depth + 1, `${memberPath}/${index}`);
+}
+function policyCheckObject(input, objectPath) {
+    const target = object(input, 'Callable Policy object', objectPath);
+    if (target.kind === 'self')
+        exact(target, ['kind'], 'Callable Policy self', objectPath);
+    else if (target.kind === 'input') {
+        exact(target, ['kind', 'field'], 'Callable Policy input', objectPath);
+        memberName(target.field, 'Callable Policy input field', `${objectPath}/field`);
+    }
+    else if (target.kind === 'ref') {
+        exact(target, ['kind', 'ref'], 'Callable Policy object ref', objectPath);
+        policyObjectRef(target.ref, `${objectPath}/ref`);
+    }
+    else
+        invalid('Callable Policy object', undefined, `${objectPath}/kind`);
+}
+function coreEndpoint(input, label, path) {
+    const value = object(input, label, path);
+    if (value.kind === 'domain')
+        exact(value, ['kind'], label, path);
+    else
+        projectedMemberRef(value, label, path);
+}
+function policyObjectRef(input, path) {
+    projectedMemberRef(object(input, 'Policy object ref', path), 'Policy object ref', path);
+}
+function projectedMemberRef(ref, label, path) {
+    if (ref.kind !== 'method') {
+        definitionRef(ref, undefined, label, path);
+        return;
+    }
+    exact(ref, ['kind', 'owner', 'name'], `${label} Method`, path);
+    definitionRef(ref.owner, 'class', `${label} Method owner`, `${path}/owner`);
+    if (typeof ref.name !== 'string' || !MEMBER_NAME_PATTERN.test(ref.name))
+        invalid(`${label} Method name`, undefined, `${path}/name`);
+}
+function definitionRef(input, kind, label, path) {
+    if (!isDefinitionRef(input) || (kind !== undefined && input.kind !== kind))
+        invalid(label, undefined, path);
+    return input;
+}
+function propertyValues(input, label, path) {
+    try {
+        PropertyValues.accept(input, path);
+    }
+    catch {
+        invalid(label, undefined, path);
+    }
+}
+function dataDefinition(input, path) {
+    const value = object(input, 'Class data', path);
+    exact(value, ['mediaType'], 'Class data', path);
+    if (typeof value.mediaType !== 'string' || !MEDIA_TYPE_PATTERN.test(value.mediaType))
+        invalid('Class data mediaType', undefined, `${path}/mediaType`);
+}
+function validateClosure(candidate) {
+    validateDependencyCycles(candidate);
+    const definitions = new Map();
+    for (const [entryIndex, entry] of candidate.closure.entries()) {
+        const collections = [
+            ['classes', entry.definitions.classes],
+            ['functions', entry.definitions.functions],
+            ['policies', entry.definitions.policies],
+            ['views', entry.definitions.views],
+            ['core', entry.definitions.core],
+        ];
+        for (const [collection, values] of collections) {
+            for (const [definitionIndex, definition] of values.entries()) {
+                const path = `/closure/${entryIndex}/definitions/${collection}/${definitionIndex}`;
+                const key = Key.of(definition.ref);
+                if (definitions.has(key))
+                    invalid('duplicate Definition', undefined, `${path}/ref`);
+                definitions.set(key, { value: definition, path });
+            }
+        }
+    }
+    const requireDefinition = (ref, label, path) => {
+        const result = definitions.get(Key.of(ref));
+        if (result === undefined)
+            invalid(label, 'COMPILED_SOURCE_INVALID', path);
+        return result.value;
+    };
+    for (const [entryIndex, entry] of candidate.closure.entries()) {
+        const visibleOrigins = new Set([
+            entry.origin,
+            ...Object.values(entry.dependencies).map(({ origin }) => origin),
+        ]);
+        const collections = [
+            ['definitions/classes', entry.definitions.classes],
+            ['definitions/functions', entry.definitions.functions],
+            ['definitions/policies', entry.definitions.policies],
+            ['definitions/views', entry.definitions.views],
+            ['definitions/core', entry.definitions.core],
+            ['facts/core', entry.facts.core],
+        ];
+        for (const [collection, values] of collections) {
+            for (const [definitionIndex, definition] of values.entries()) {
+                walk(definition, `/closure/${entryIndex}/${collection}/${definitionIndex}`, (ref, path) => {
+                    const resolved = requireDefinition(ref, 'unresolved Definition ref', path);
+                    if (!visibleOrigins.has(ref.origin))
+                        invalid('non-direct dependency ref', 'COMPILED_SOURCE_INVALID', path);
+                    if (resolved.ref === undefined)
+                        invalid('resolved Definition', 'COMPILED_SOURCE_INVALID', path);
+                });
+            }
+        }
+    }
+    const classes = new Map();
+    for (const [entryIndex, entry] of candidate.closure.entries())
+        for (const [classIndex, definition] of entry.definitions.classes.entries())
+            classes.set(Key.of(definition.ref), {
+                value: definition,
+                path: `/closure/${entryIndex}/definitions/classes/${classIndex}`,
+            });
+    const visiting = new Set();
+    const visited = new Set();
+    const visitClass = (key) => {
+        if (visited.has(key))
+            return;
+        if (visiting.has(key))
+            invalid('Class inheritance cycle', 'COMPILED_SOURCE_INVALID', `${classes.get(key)?.path ?? ''}/extends`);
+        const definition = classes.get(key);
+        if (definition === undefined)
+            invalid('Class inheritance ref', 'COMPILED_SOURCE_INVALID', '/closure');
+        visiting.add(key);
+        for (const [parentIndex, parentRef] of definition.value.extends.entries()) {
+            const parent = classes.get(Key.of(parentRef));
+            if (parent === undefined || parent.value.kind !== definition.value.kind) {
+                invalid('Class inheritance kind', 'COMPILED_SOURCE_INVALID', `${definition.path}/extends/${parentIndex}`);
+            }
+            visitClass(Key.of(parentRef));
+        }
+        visiting.delete(key);
+        visited.add(key);
+    };
+    for (const key of classes.keys())
+        visitClass(key);
+    for (const definition of classes.values()) {
+        if (definition.value.kind !== 'edge')
+            continue;
+        const endpoints = definition.value.orientation === 'directed'
+            ? [
+                definition.value.endpoints.source,
+                definition.value.endpoints.target,
+            ]
+            : definition.value.endpoints;
+        for (const [endpointIndex, endpoint] of endpoints.entries()) {
+            const endpointPath = definition.value.orientation === 'directed'
+                ? `${definition.path}/endpoints/${endpointIndex === 0 ? 'source' : 'target'}`
+                : `${definition.path}/endpoints/${endpointIndex}`;
+            for (const [acceptedIndex, accepted] of endpoint.accepts.entries()) {
+                if (classes.get(Key.of(accepted))?.value.kind !== 'node') {
+                    invalid('Edge endpoint Class', 'COMPILED_SOURCE_INVALID', `${endpointPath}/accepts/${acceptedIndex}`);
+                }
+            }
+        }
+    }
+    for (const [entryIndex, entry] of candidate.closure.entries()) {
+        for (const [definitionIndex, definition] of entry.definitions.core.entries()) {
+            const owner = classes.get(Key.of(definition.class));
+            if (owner?.value.kind !== 'node' || owner.value.abstract) {
+                invalid('Core exact Class', 'COMPILED_SOURCE_INVALID', `/closure/${entryIndex}/definitions/core/${definitionIndex}/class`);
+            }
+        }
+        for (const [edgeIndex, edge] of entry.facts.core.entries()) {
+            const owner = classes.get(Key.of(edge.class));
+            if (owner?.value.kind !== 'edge' || owner.value.abstract) {
+                invalid('Core Edge exact Class', 'COMPILED_SOURCE_INVALID', `/closure/${entryIndex}/facts/core/${edgeIndex}/class`);
+            }
+        }
+    }
+}
+function validateDependencyCycles(candidate) {
+    const byOrigin = new Map(candidate.closure.map((entry, index) => [entry.origin, { entry, index }]));
+    const active = new Set();
+    const visited = new Set();
+    const frames = [];
+    const push = (origin, depth) => {
+        if (depth > dependencyLimits.depth) {
+            invalid('dependency depth limit', 'COMPILED_DEPENDENCY_LIMITS', `/closure/${byOrigin.get(origin)?.index ?? 0}/dependencies`);
+        }
+        active.add(origin);
+        frames.push({
+            origin,
+            depth,
+            dependencies: Object.values(byOrigin.get(origin)?.entry.dependencies ?? {}),
+            index: 0,
+        });
+    };
+    push(candidate.root.origin, 0);
+    while (frames.length > 0) {
+        const frame = frames.at(-1);
+        const dependency = frame.dependencies[frame.index++];
+        if (dependency === undefined) {
+            frames.pop();
+            active.delete(frame.origin);
+            visited.add(frame.origin);
+            continue;
+        }
+        if (active.has(dependency.origin)) {
+            invalid('dependency cycle', 'COMPILED_DEPENDENCY_CYCLE', `/closure/${byOrigin.get(dependency.origin)?.index ?? 0}/dependencies`);
+        }
+        if (!visited.has(dependency.origin))
+            push(dependency.origin, frame.depth + 1);
+    }
+}
+function walk(input, path, visit) {
+    if (isDefinitionRef(input)) {
+        visit(input, path);
+        return;
+    }
+    if (input === null || typeof input !== 'object')
+        return;
+    if (Array.isArray(input)) {
+        for (const [index, value] of input.entries())
+            walk(value, `${path}/${index}`, visit);
+        return;
+    }
+    for (const [key, value] of Object.entries(input))
+        walk(value, pointer(path, key), visit);
+}
+function program(input, programIndex, path, table, version) {
+    const value = object(input, `values[${programIndex}]`, path);
+    exact(value, ['root', 'nodes', 'patterns'], 'ValueProgram', path);
+    const nodesPath = `${path}/nodes`;
+    const nodes = array(value.nodes, 'ValueProgram nodes', nodesPath).map((node, index) => valueNode(node, index, `${nodesPath}/${index}`));
+    const root = index(value.root, nodes.length, 'ValueProgram root', `${path}/root`);
+    const patternsPath = `${path}/patterns`;
+    const patterns = array(value.patterns, 'ValueProgram patterns', patternsPath).map((item, position) => {
+        const patternPath = `${patternsPath}/${position}`;
+        if (version === 2)
+            return index(item, table.length, 'ValueProgram pattern', patternPath);
+        // Legacy programs can carry different machines with the same source label. Preserve each.
+        return table.push(pattern(item, position, patternPath, false)) - 1;
+    });
+    const sources = patterns.map((index) => table[index].source);
+    unique(sources, 'patterns', patternsPath);
+    const available = new Set(sources);
+    for (const [nodeIndex, node] of nodes.entries()) {
+        if (isValueObject(node.schema)) {
+            const required = [node.schema.pattern, node.schema.fullMatch];
+            if (isValueObject(node.schema.patternProperties)) {
+                required.push(...Object.keys(node.schema.patternProperties));
+            }
+            for (const source of required) {
+                if (typeof source === 'string' && !available.has(source)) {
+                    invalid('ValueProgram pattern binding', undefined, patternsPath);
+                }
+            }
+        }
+        for (const [name, child] of Object.entries(node.children))
+            index(child, nodes.length, 'ValueNode child', pointer(`${nodesPath}/${nodeIndex}/children`, name));
+        if (node.reference !== undefined)
+            index(node.reference, nodes.length, 'ValueNode reference', `${nodesPath}/${nodeIndex}/reference`);
+    }
+    return { root, nodes, patterns };
+}
+function valueNode(input, nodeIndex, path) {
+    const value = object(input, `nodes[${nodeIndex}]`, path);
+    exact(value, ['schema', 'children'], 'ValueNode', path, ['reference']);
+    const children = {};
+    const childrenPath = `${path}/children`;
+    for (const [name, child] of Object.entries(object(value.children, 'ValueNode children', childrenPath))) {
+        children[name] = integer(child, 'ValueNode child', pointer(childrenPath, name));
+    }
+    return {
+        schema: value.schema,
+        children,
+        ...(value.reference === undefined
+            ? {}
+            : { reference: integer(value.reference, 'reference', `${path}/reference`) }),
+    };
+}
+function pattern(input, patternIndex, path, counted) {
+    const value = object(input, `patterns[${patternIndex}]`, path);
+    if (counted && Object.hasOwn(value, 'runs'))
+        return runPattern(value, path);
+    exact(value, ['source', 'start', 'states'], 'Pattern', path);
+    if (typeof value.source !== 'string')
+        invalid('Pattern source', undefined, `${path}/source`);
+    const statesPath = `${path}/states`;
+    const states = array(value.states, 'Pattern states', statesPath).map((item, stateIndex) => {
+        const statePath = `${statesPath}/${stateIndex}`;
+        const state = object(item, 'Pattern state', statePath);
+        exact(state, ['epsilon', 'transitions'], 'Pattern state', statePath, ['accepting']);
+        if (state.accepting !== undefined && state.accepting !== true)
+            invalid('accepting', undefined, `${statePath}/accepting`);
+        const epsilonPath = `${statePath}/epsilon`;
+        const transitionsPath = `${statePath}/transitions`;
+        return {
+            epsilon: array(state.epsilon, 'epsilon', epsilonPath).map((target, index) => integer(target, 'epsilon', `${epsilonPath}/${index}`)),
+            transitions: array(state.transitions, 'transitions', transitionsPath).map((transitionValue, transitionIndex) => {
+                const transitionPath = `${transitionsPath}/${transitionIndex}`;
+                const transition = object(transitionValue, 'transition', transitionPath);
+                exact(transition, ['to', 'ranges'], 'transition', transitionPath);
+                const rangesPath = `${transitionPath}/ranges`;
+                return {
+                    to: integer(transition.to, 'transition target', `${transitionPath}/to`),
+                    ranges: array(transition.ranges, 'ranges', rangesPath).map((rangeValue, rangeIndex) => {
+                        const rangePath = `${rangesPath}/${rangeIndex}`;
+                        const range = array(rangeValue, 'range', rangePath);
+                        if (range.length !== 2)
+                            invalid('range', undefined, rangePath);
+                        const minimum = scalar(range[0], 'range minimum', `${rangePath}/0`);
+                        const maximum = scalar(range[1], 'range maximum', `${rangePath}/1`);
+                        if (minimum > maximum)
+                            invalid('range order', undefined, rangePath);
+                        return [minimum, maximum];
+                    }),
+                };
+            }),
+            ...(state.accepting === true ? { accepting: true } : {}),
+        };
+    });
+    const start = index(value.start, states.length, 'Pattern start', `${path}/start`);
+    for (const [stateIndex, state] of states.entries()) {
+        state.epsilon.forEach((target, indexValue) => index(target, states.length, 'epsilon', `${statesPath}/${stateIndex}/epsilon/${indexValue}`));
+        state.transitions.forEach(({ to }, transitionIndex) => index(to, states.length, 'transition', `${statesPath}/${stateIndex}/transitions/${transitionIndex}/to`));
+    }
+    return { source: value.source, start, states };
+}
+function runPattern(value, path) {
+    exact(value, ['source', 'runs'], 'RunPattern', path);
+    if (typeof value.source !== 'string')
+        invalid('Pattern source', undefined, `${path}/source`);
+    const entries = array(value.runs, 'scalar runs', `${path}/runs`);
+    if (entries.length === 0 || entries.length > 4096) {
+        invalid('scalar run count', undefined, `${path}/runs`);
+    }
+    const runs = entries.map((entry, position) => {
+        const runPath = `${path}/runs/${position}`;
+        const run = object(entry, 'scalar run', runPath);
+        exact(run, ['ranges', 'minimum'], 'scalar run', runPath, ['maximum']);
+        const minimum = boundedInteger(run.minimum, 0, 1000, 'run minimum', `${runPath}/minimum`);
+        const maximum = run.maximum === undefined
+            ? undefined
+            : boundedInteger(run.maximum, minimum, 1000, 'run maximum', `${runPath}/maximum`);
+        if (position !== entries.length - 1 && minimum !== maximum) {
+            invalid('exact scalar prefix', undefined, `${runPath}/maximum`);
+        }
+        let previous = -1;
+        const ranges = array(run.ranges, 'scalar ranges', `${runPath}/ranges`).map((entry, index) => {
+            const rangePath = `${runPath}/ranges/${index}`;
+            const range = array(entry, 'scalar range', rangePath);
+            if (range.length !== 2)
+                invalid('scalar range', undefined, rangePath);
+            const minimum = scalar(range[0], 'range minimum', `${rangePath}/0`);
+            const maximum = scalar(range[1], 'range maximum', `${rangePath}/1`);
+            if (minimum > maximum ||
+                minimum <= previous ||
+                (minimum >= 0xd800 && minimum <= 0xdfff) ||
+                (maximum >= 0xd800 && maximum <= 0xdfff))
+                invalid('ordered scalar range', undefined, rangePath);
+            previous = maximum;
+            return [minimum, maximum];
+        });
+        return { ranges, minimum, ...(maximum === undefined ? {} : { maximum }) };
+    });
+    return { source: value.source, runs };
+}
+function dependency(input, label, path) {
+    const value = object(input, label, path);
+    exact(value, ['origin', 'revision'], label, path);
+    return {
+        origin: originValue(value.origin, label, `${path}/origin`),
+        revision: revisionValue(value.revision, label, `${path}/revision`),
+    };
+}
+function dependencyMap(input, path) {
+    const value = object(input, 'dependencies', path);
+    const accepted = Object.create(null);
+    for (const [alias, inputDependency] of Object.entries(value).sort(([left], [right]) => compare(left, right))) {
+        const aliasPath = pointer(path, alias);
+        if (!DEPENDENCY_ALIAS_PATTERN.test(alias) ||
+            alias === '__proto__' ||
+            alias === 'prototype' ||
+            alias === 'constructor') {
+            invalid('dependency alias', undefined, aliasPath);
+        }
+        accepted[alias] = dependency(inputDependency, `dependency ${alias}`, aliasPath);
+    }
+    return accepted;
+}
+function originValue(input, label, path) {
+    if (typeof input !== 'string' || !DOMAIN_ORIGIN_PATTERN.test(input))
+        invalid(label, undefined, path);
+    return input;
+}
+function revisionValue(input, label, path) {
+    if (typeof input !== 'string' || !DOMAIN_REVISION_PATTERN.test(input))
+        invalid(label, undefined, path);
+    return input;
+}
+function object(input, label, path) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalid(label, undefined, path);
+    return input;
+}
+function array(input, label, path) {
+    if (!Array.isArray(input))
+        invalid(label, undefined, path);
+    return input;
+}
+function exact(value, required, label, path, optional = []) {
+    const allowed = new Set([...required, ...optional]);
+    const unknown = Object.keys(value)
+        .filter((key) => !allowed.has(key))
+        .sort(compare)[0];
+    if (unknown !== undefined)
+        invalid(label, undefined, pointer(path, unknown));
+    const missing = required.find((key) => !Object.hasOwn(value, key));
+    if (missing !== undefined)
+        invalid(label, undefined, pointer(path, missing));
+}
+function integer(input, label, path) {
+    if (!Number.isSafeInteger(input) || input < 0)
+        invalid(label, undefined, path);
+    return input;
+}
+function boundedInteger(input, minimum, maximum, label, path) {
+    const value = integer(input, label, path);
+    if (value < minimum || value > maximum)
+        invalid(label, undefined, path);
+    return value;
+}
+function boolean(input, label, path) {
+    if (typeof input !== 'boolean')
+        invalid(label, undefined, path);
+    return input;
+}
+function string(input, label, path) {
+    if (typeof input !== 'string')
+        invalid(label, undefined, path);
+    return input;
+}
+function memberName(input, label, path) {
+    const value = string(input, label, path);
+    if (!MEMBER_NAME_PATTERN.test(value))
+        invalid(label, undefined, path);
+    return value;
+}
+function boundedString(input, minimum, maximum, label, path) {
+    if (input === undefined)
+        return;
+    const value = string(input, label, path);
+    if (value.length < minimum || value.length > maximum)
+        invalid(label, undefined, path);
+}
+function description(input, label, path) {
+    boundedString(input, 1, 1000, label, path);
+}
+function unique(values, label, path) {
+    const seen = new Set();
+    for (const [indexValue, value] of values.entries()) {
+        if (seen.has(value))
+            invalid(label, undefined, `${path}/${indexValue}`);
+        seen.add(value);
+    }
+}
+function index(input, length, label, path) {
+    const value = integer(input, label, path);
+    if (value >= length)
+        invalid(label, undefined, path);
+    return value;
+}
+function scalar(input, label, path) {
+    const value = integer(input, label, path);
+    if (value > 0x10ffff)
+        invalid(label, undefined, path);
+    return value;
+}
+function invalid(label, code = 'COMPILED_STRUCTURE_INVALID', path = '') {
+    return invalidCompiled(code, `Invalid compiled Schema ${label}.`, path);
+}
+function compare(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function deepFreeze(input) {
+    if (input === null || typeof input !== 'object' || Object.isFrozen(input))
+        return input;
+    for (const value of Object.values(input))
+        deepFreeze(value);
+    return Object.freeze(input);
+}