@astrale-os/kernel-dsl 0.2.0-beta.47 → 0.2.0-beta.49

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

@@ -1,22 +1,14 @@
 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 { compilePattern } from '../../language/value/regexp/compile.js';
-import { isIRegexp } from '../../language/value/regexp/syntax.js';
-import { invalidCompiled } from '../diagnostic.js';
-import { revisionOfCompiledEntry } from './revision.js';
+import {} from '../model/schema.js';
+import { validateClosure } from './closure.js';
+import { invalid, pointer } from './diagnostic.js';
 import { validateCompiledSemantics } from './semantics.js';
+import { dependency } from './wire/dependency.js';
+import { entry } from './wire/entry.js';
+import {} from './wire/pattern.js';
+import { object, exact, array } from './wire/value.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', '');
@@ -77,996 +69,6 @@ export function acceptCompiledSchema(input) {
     validateCompiledSemantics(candidate);
     return deepFreeze(candidate);
 }
-function entry(input, entryIndex, path, machines) {
-    const value = object(input, `closure[${entryIndex}]`, path);
-    exact(value, ['origin', 'revision', 'dependencies', 'definitions', 'facts', 'values', '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 = array(value.patterns, 'entry patterns', patternsPath).map((item, index) => pattern(item, index, `${patternsPath}/${index}`, machines));
-    const values = array(value.values, 'values', valuesPath).map((item, index) => program(item, index, `${valuesPath}/${index}`, patterns));
-    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',
-        'immutable',
-        '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`);
-    if (value.immutable !== undefined && value.immutable !== 'create' && value.immutable !== 'once') {
-        invalid('Property immutability', undefined, `${path}/immutable`);
-    }
-    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', 'execution', '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`);
-    }
-    if (value.execution !== undefined) {
-        const executionPath = `${path}/execution`;
-        const execution = object(value.execution, 'Callable execution', executionPath);
-        exact(execution, ['durable'], 'Callable execution', executionPath);
-        // Ordinary execution is canonically absent; only the durable modifier is retained.
-        if (!boolean(execution.durable, 'Callable execution durable', `${executionPath}/durable`)) {
-            invalid('Callable execution', 'COMPILED_CANONICAL_MISMATCH', `${executionPath}/durable`);
-        }
-        if (value.auth === 'anonymous') {
-            invalid('durable Callable auth', 'COMPILED_SOURCE_INVALID', `${path}/auth`);
-        }
-        if (typeof value.input === 'object' && value.input !== null) {
-            invalid('durable Callable input', 'COMPILED_SOURCE_INVALID', `${path}/input`);
-        }
-        if (output.mode !== 'value') {
-            invalid('durable Callable output', 'COMPILED_SOURCE_INVALID', `${outputPath}/mode`);
-        }
-    }
-}
-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) {
-    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) => index(item, table.length, 'ValueProgram pattern', `${patternsPath}/${position}`));
-    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`) }),
-    };
-}
-/**
- * Admit one received pattern as data and return the machine compiled from its source. A received
- * machine never decides membership: it may come from another compiler, from a host with other
- * Unicode data, or from a forger, and the artifact carries no compiler version that could tell a
- * current machine from those, so it is ignored rather than compared. Its source decides, through
- * the same bounded `isIRegexp` and `compilePattern` that source resolution uses.
- */
-function pattern(input, patternIndex, path, machines) {
-    const value = object(input, `patterns[${patternIndex}]`, path);
-    const { source } = Object.hasOwn(value, 'runs')
-        ? runPattern(value, path)
-        : nfaPattern(value, path);
-    let machine = machines.get(source);
-    if (machine === undefined) {
-        if (!isIRegexp(source))
-            invalid('Pattern source', 'COMPILED_SOURCE_INVALID', `${path}/source`);
-        machine = compilePattern(source);
-        machines.set(source, machine);
-    }
-    return machine;
-}
-function nfaPattern(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;