@astrale-os/kernel-dsl 0.2.0-beta.46 → 0.2.0-beta.48

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

@@ -1,17 +1,9 @@
-import { json } from '@astrale-os/kernel-dsl/value';
-import { Key, PropertyKey as PropertyKeyValue } from '../../addressing/index.js';
-import { compareUnicode } from '../../addressing/ordering.js';
-import { composeMethods } from '../../language/callable/composition.js';
-import { isMethodExecutable } from '../../language/callable/executable.js';
-import { policyObjectKey, policyObjectOrigin, policyVariableClass, projectedMemberClass, } from '../../language/index.js';
-import { branchesOf, branchProduct, capBranches, isConnected, targetMode, termKey, } from '../../language/policy/analysis/branches.js';
-import { BRANCH_OVERFLOW, MAX_BRANCHES, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, MAX_DOMAINS, MAX_EDGES, MAX_PATTERN_DEPTH, MAX_REPEAT, MAX_VARIABLES, measureChecks, } from '../../language/policy/analysis/budgets.js';
-import { admittedCheckClasses, neverAdmittedClasses, } from '../../language/policy/analysis/checks.js';
-import { normalizePolicyExpression } from '../../language/policy/normalization/normalize.js';
-import { bindValueProgram } from '../../language/value/compile/load.js';
-import { validateValueProgram } from '../../language/value/evaluate/program.js';
-import { GRAPH_NODE_PATH_SCHEMA_ID } from '../../language/value/syntax/node-path/schema.js';
-import { invalidCompiled } from '../diagnostic.js';
+import {} from '../model/schema.js';
+import { analyzeClasses, validateClassFacets } from './semantics/class.js';
+import { index, admittedOrigins } from './semantics/context.js';
+import { validateCore } from './semantics/core.js';
+import { validateEdges } from './semantics/edge.js';
+import { validatePolicies } from './semantics/policy/admit.js';
 /**
  * Re-admit contextual Language laws after the portable compiled grammar and
  * exact closure have been established. This module deliberately depends only
@@ -21,1207 +13,9 @@ export function validateCompiledSemantics(candidate) {
     const partial = index(candidate);
     const analyses = analyzeClasses(partial.classes);
     const context = { ...partial, analyses };
-    const admitted = admittedOrigins(candidate);
     validateClassFacets(context);
-    validateEdges(context, admitted);
-    validateViews(candidate, context);
+    const admitted = admittedOrigins(candidate);
+    validateEdges(context);
     validatePolicies(candidate, context, admitted);
     validateCore(candidate, context);
 }
-function index(candidate) {
-    const definitions = new Map();
-    const classes = new Map();
-    const policies = new Map();
-    const core = 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 [valueIndex, value] of values.entries()) {
-                const located = {
-                    value,
-                    entry,
-                    entryIndex,
-                    index: valueIndex,
-                    pointer: `/closure/${entryIndex}/definitions/${collection}/${valueIndex}`,
-                };
-                definitions.set(Key.of(value.ref), {
-                    ...located,
-                    value: value.ref,
-                });
-                if (value.ref.kind === 'class')
-                    classes.set(Key.of(value.ref), located);
-                if (value.ref.kind === 'policy')
-                    policies.set(Key.of(value.ref), located);
-                if (value.ref.kind === 'core')
-                    core.set(Key.of(value.ref), located);
-            }
-        }
-    }
-    return { definitions, classes, policies, core };
-}
-function analyzeClasses(classes) {
-    const analyses = new Map();
-    const visiting = new Set();
-    const analyze = (located) => {
-        const classKey = Key.of(located.value.ref);
-        const cached = analyses.get(classKey);
-        if (cached !== undefined)
-            return cached;
-        if (visiting.has(classKey))
-            fail(`${located.pointer}/extends`, 'Class inheritance is cyclic.');
-        visiting.add(classKey);
-        const parents = located.value.extends.map((ref, index) => {
-            const parent = classes.get(Key.of(ref));
-            if (parent === undefined)
-                fail(`${located.pointer}/extends/${index}`, 'Parent Class is absent.');
-            return analyze(parent);
-        });
-        const properties = new Map();
-        for (const parent of parents)
-            for (const [key, value] of parent.properties)
-                properties.set(key, value);
-        for (const property of located.value.properties) {
-            const key = PropertyKeyValue.of(located.value.ref, property.name);
-            properties.set(key, {
-                key,
-                owner: located.value.ref,
-                declaration: property,
-                entry: located.entry,
-            });
-        }
-        let dataOwner;
-        for (const parent of parents) {
-            if (parent.dataOwner === undefined)
-                continue;
-            if (dataOwner !== undefined && Key.of(dataOwner) !== Key.of(parent.dataOwner)) {
-                fail(located.pointer, 'Data has distinct inherited declaring owners.');
-            }
-            dataOwner = parent.dataOwner;
-        }
-        if (located.value.kind === 'node' && located.value.data !== undefined) {
-            if (dataOwner !== undefined)
-                fail(`${located.pointer}/data`, 'Data cannot redeclare an inherited contract.');
-            dataOwner = located.value.ref;
-        }
-        const own = new Map((located.value.kind === 'node' ? located.value.methods : []).map((method) => [
-            method.name,
-            {
-                key: `${classKey}.method.${method.name}`,
-                name: method.name,
-                owner: located.value.ref,
-                declaration: method,
-                entry: located.entry,
-            },
-        ]));
-        const composition = composeMethods(parents, own, located.value.abstract, (left, right) => sameMethodSignature(left.entry, left.declaration, right.entry, right.declaration), (message) => fail(`${located.pointer}/methods`, message));
-        const analysis = {
-            properties,
-            ...composition,
-            ...(dataOwner === undefined ? {} : { dataOwner }),
-        };
-        analyses.set(classKey, analysis);
-        visiting.delete(classKey);
-        return analysis;
-    };
-    for (const value of classes.values())
-        analyze(value);
-    return analyses;
-}
-function sameMethodSignature(leftEntry, left, rightEntry, right) {
-    return (programKey(leftEntry, left.input) === programKey(rightEntry, right.input) &&
-        outputKey(leftEntry, left.output) === outputKey(rightEntry, right.output) &&
-        left.auth === right.auth &&
-        left.static === right.static &&
-        left.execution?.durable === right.execution?.durable);
-}
-function outputKey(entry, output) {
-    return output.mode === 'binary' ? 'binary' : `${output.mode}:${programKey(entry, output.value)}`;
-}
-function programKey(entry, value) {
-    return json.serialize(bindValueProgram(entry.values[value], entry.patterns));
-}
-function validateClassFacets(context) {
-    for (const located of context.classes.values()) {
-        if (located.value.abstract &&
-            (located.value.policies.read !== undefined || located.value.policies.traverse !== undefined)) {
-            fail(`${located.pointer}/policies`, 'Abstract Classes cannot declare observation Policies.');
-        }
-        for (const [index, property] of located.value.properties.entries()) {
-            const path = `${located.pointer}/properties/${index}`;
-            if (property.auto !== undefined) {
-                if (property.required && !property.auto.on.includes('create')) {
-                    fail(`${path}/auto/on`, 'A required auto Property must run on create.');
-                }
-                if (property.auto.set === 'instant' && property.ordering !== 'instant') {
-                    fail(`${path}/auto/set`, 'The instant setter requires an Instant value program.');
-                }
-            }
-        }
-        if (located.value.kind === 'node') {
-            for (const [index, method] of located.value.methods.entries()) {
-                if (!isMethodExecutable(located.value, method) && method.policy !== undefined) {
-                    fail(`${located.pointer}/methods/${index}/policy`, 'An abstract Method cannot have a Policy.');
-                }
-            }
-        }
-    }
-}
-/**
- * The origins each closure entry was admitted against: itself and its transitive dependencies.
- * Source admission decides undirected overlap and types Policies within that closure alone, so a
- * dependent's Class extending a dependency's Classes never reaches the dependency's own decisions.
- */
-function admittedOrigins(candidate) {
-    const entries = new Map(candidate.closure.map((entry) => [entry.origin, entry]));
-    const scopes = new Map();
-    const scope = (origin) => {
-        const known = scopes.get(origin);
-        if (known !== undefined)
-            return known;
-        const origins = new Set([origin]);
-        for (const dependency of Object.values(entries.get(origin)?.dependencies ?? {}))
-            for (const reached of scope(dependency.origin))
-                origins.add(reached);
-        scopes.set(origin, origins);
-        return origins;
-    };
-    for (const entry of candidate.closure)
-        scope(entry.origin);
-    return scopes;
-}
-function validateEdges(context, admitted) {
-    for (const located of context.classes.values()) {
-        if (!isCompiledEdge(located.value))
-            continue;
-        const edge = located.value;
-        const endpoints = edge.orientation === 'directed'
-            ? [edge.endpoints.source, edge.endpoints.target]
-            : edge.endpoints;
-        if (endpoints[0].role === endpoints[1].role)
-            fail(`${located.pointer}/endpoints`, 'Edge endpoint roles must differ.');
-        for (const [endpointIndex, endpoint] of endpoints.entries()) {
-            const seen = new Set();
-            for (const [acceptIndex, ref] of endpoint.accepts.entries()) {
-                const key = Key.of(ref);
-                if (seen.has(key))
-                    fail(`${located.pointer}/endpoints/${endpointIndex}/accepts/${acceptIndex}`, 'Edge endpoint repeats an accepted Class.');
-                seen.add(key);
-                if (context.classes.get(key)?.value.kind !== 'node')
-                    fail(`${located.pointer}/endpoints/${endpointIndex}/accepts/${acceptIndex}`, 'Edge endpoint must accept a Node Class.');
-            }
-        }
-        if (edge.orientation === 'undirected' &&
-            !sameIncidentEndpoint(edge.endpoints[0], edge.endpoints[1]) &&
-            undirectedOverlap(context, edge.endpoints, admitted.get(located.entry.origin))) {
-            fail(`${located.pointer}/endpoints`, 'Unequal undirected endpoint contracts overlap.');
-        }
-        for (const [parentIndex, parentRef] of edge.extends.entries()) {
-            const parent = context.classes.get(Key.of(parentRef))?.value;
-            if (parent !== undefined && isCompiledEdge(parent) && !edgeRefines(context, edge, parent)) {
-                fail(`${located.pointer}/extends/${parentIndex}`, 'Edge Class does not safely refine its parent.');
-            }
-        }
-    }
-}
-function edgeRefines(context, child, parent) {
-    if (child.orientation !== parent.orientation)
-        return false;
-    if (parent.constraints.noSelf === true && child.constraints.noSelf !== true)
-        return false;
-    if (parent.constraints.acyclic === true && child.constraints.acyclic !== true)
-        return false;
-    if (child.orientation === 'directed' && parent.orientation === 'directed') {
-        return (endpointRefines(context, child.endpoints.source, parent.endpoints.source) &&
-            countRefines(child.endpoints.source.outgoing, parent.endpoints.source.outgoing) &&
-            endpointRefines(context, child.endpoints.target, parent.endpoints.target) &&
-            countRefines(child.endpoints.target.incoming, parent.endpoints.target.incoming));
-    }
-    if (child.orientation !== 'undirected' || parent.orientation !== 'undirected')
-        return false;
-    const refine = (a, b) => endpointRefines(context, child.endpoints[a], parent.endpoints[b]) &&
-        countRefines(child.endpoints[a].incident, parent.endpoints[b].incident);
-    const direct = refine(0, 0) && refine(1, 1);
-    if (direct)
-        return true;
-    return refine(0, 1) && refine(1, 0);
-}
-function endpointRefines(context, child, parent) {
-    return child.accepts.every((accepted) => classSatisfiesAny(context, accepted, parent.accepts));
-}
-function countRefines(child, parent) {
-    const [childMin, childMax] = countBounds(child);
-    const [parentMin, parentMax] = countBounds(parent);
-    return childMin >= parentMin && childMax <= parentMax;
-}
-function sameIncidentEndpoint(left, right) {
-    const a = left.accepts.map(Key.of).sort(compareUnicode);
-    const b = right.accepts.map(Key.of).sort(compareUnicode);
-    return (left.incident === right.incident &&
-        a.length === b.length &&
-        a.every((value, index) => value === b[index]));
-}
-function undirectedOverlap(context, endpoints, origins) {
-    return [...context.classes.values()].some(({ value }) => origins.has(value.ref.origin) &&
-        value.kind === 'node' &&
-        !value.abstract &&
-        classSatisfiesAny(context, value.ref, endpoints[0].accepts) &&
-        classSatisfiesAny(context, value.ref, endpoints[1].accepts));
-}
-function classSatisfiesAny(context, candidate, accepted) {
-    const targets = new Set(accepted.map(Key.of));
-    const visit = (ref, seen) => {
-        const key = Key.of(ref);
-        if (targets.has(key))
-            return true;
-        if (seen.has(key))
-            return false;
-        seen.add(key);
-        return context.classes.get(key)?.value.extends.some((parent) => visit(parent, seen)) ?? false;
-    };
-    return visit(candidate, new Set());
-}
-function validateViews(candidate, context) {
-    for (const [entryIndex, entry] of candidate.closure.entries()) {
-        for (const [viewIndex, view] of entry.definitions.views.entries()) {
-            if (view.target.kind !== 'definition')
-                continue;
-            for (const [targetIndex, ref] of view.target.definitions.entries()) {
-                if (context.classes.get(Key.of(ref))?.value.kind !== 'node') {
-                    fail(`/closure/${entryIndex}/definitions/views/${viewIndex}/target/definitions/${targetIndex}`, 'A View Definition target must resolve to a Node Class.');
-                }
-            }
-        }
-    }
-}
-function validatePolicies(candidate, context, admitted) {
-    for (const [entryIndex, entry] of candidate.closure.entries()) {
-        const localPolicies = new Map(entry.definitions.policies.map((value) => [value.ref.name, value]));
-        for (const [policyIndex, policy] of entry.definitions.policies.entries()) {
-            validatePolicyExpression(context, entry, policy.expression, `/closure/${entryIndex}/definitions/policies/${policyIndex}/expression`, localPolicies);
-        }
-        validatePolicyCycles(entry, localPolicies, entryIndex);
-        validatePolicyParity(context, entry, entryIndex, localPolicies, admitted.get(entry.origin));
-        for (const [functionIndex, callable] of entry.definitions.functions.entries()) {
-            if (callable.policy !== undefined)
-                validateCallablePolicy(context, entry, callable.policy, typeof callable.input === 'number' ? callable.input : callable.input.metadata, callable.fields, false, `/closure/${entryIndex}/definitions/functions/${functionIndex}/policy`);
-        }
-        for (const [classIndex, definition] of entry.definitions.classes.entries()) {
-            for (const [kind, ref] of Object.entries(definition.policies)) {
-                if (ref !== undefined &&
-                    (ref.origin !== entry.origin || context.policies.get(Key.of(ref)) === undefined)) {
-                    fail(`/closure/${entryIndex}/definitions/classes/${classIndex}/policies/${kind}`, 'Class Policies must name a local Policy Definition.');
-                }
-            }
-            if (definition.kind !== 'node')
-                continue;
-            for (const [methodIndex, callable] of definition.methods.entries()) {
-                if (callable.policy !== undefined)
-                    validateCallablePolicy(context, entry, callable.policy, callable.input, callable.fields, !callable.static, `/closure/${entryIndex}/definitions/classes/${classIndex}/methods/${methodIndex}/policy`);
-            }
-        }
-    }
-}
-function validatePolicyExpression(context, entry, expression, path, local) {
-    if ('match' in expression) {
-        validatePattern(context, expression.match, `${path}/match`, new Set(), new Set());
-        return;
-    }
-    const values = 'allOf' in expression ? expression.allOf : expression.anyOf;
-    if (values.length === 0)
-        fail(path, 'Named Policy composition must be non-empty.');
-    for (const [index, ref] of values.entries()) {
-        if (ref.origin !== entry.origin || ref.kind !== 'policy' || !local.has(ref.name))
-            fail(`${path}/${index}`, 'Named Policy composition must reference a local Policy.');
-    }
-}
-function validatePattern(context, expression, path, scope, declared) {
-    if ('sameNode' in expression) {
-        validatePolicyTerm(context, expression.sameNode.left, `${path}/sameNode/left`, scope);
-        validatePolicyTerm(context, expression.sameNode.right, `${path}/sameNode/right`, scope);
-        return;
-    }
-    if ('source' in expression) {
-        if (context.classes.get(Key.of(expression.class))?.value.kind !== 'edge')
-            fail(`${path}/class`, 'Policy pattern Class must resolve to an Edge Class.');
-        validatePolicyTerm(context, expression.source, `${path}/source`, scope);
-        validatePolicyTerm(context, expression.target, `${path}/target`, scope);
-        if (expression.repeat !== undefined &&
-            (!Number.isInteger(expression.repeat.min) ||
-                !Number.isInteger(expression.repeat.max) ||
-                expression.repeat.min < 0 ||
-                expression.repeat.max < expression.repeat.min ||
-                expression.repeat.max > MAX_REPEAT))
-            fail(`${path}/repeat`, 'Policy repeat is outside the V1 bounds.');
-        return;
-    }
-    if ('exists' in expression) {
-        if (expression.exists.nodes.length > MAX_VARIABLES) {
-            fail(`${path}/exists/nodes`, 'Policy exists exceeds the V1 variable budget.');
-        }
-        const nested = new Set(scope);
-        for (const [index, node] of expression.exists.nodes.entries()) {
-            const id = node.variable.id;
-            if (declared.has(id) || nested.has(id))
-                fail(`${path}/exists/nodes/${index}/variable/id`, 'Policy variable IDs must be globally unique and cannot shadow.');
-            declared.add(id);
-            nested.add(id);
-            const classRef = policyVariableClass(node);
-            if (classRef !== undefined && context.classes.get(Key.of(classRef))?.value.kind !== 'node')
-                fail(`${path}/exists/nodes/${index}/${'class' in node ? 'class' : 'selector/class'}`, 'Policy variable Class must resolve to a Node Class.');
-        }
-        validatePattern(context, expression.exists.where, `${path}/exists/where`, nested, declared);
-        return;
-    }
-    const values = 'allOf' in expression ? expression.allOf : expression.anyOf;
-    if (values.length === 0)
-        fail(path, 'Policy pattern composition must be non-empty.');
-    values.forEach((value, index) => validatePattern(context, value, `${path}/${index}`, scope, declared));
-}
-function validatePolicyTerm(context, term, path, scope) {
-    if (term.kind === 'ref' && term.ref.kind === 'method')
-        validatePolicyMethod(context, term.ref, `${path}/ref`);
-    if (term.kind === 'variable' && !scope.has(term.id))
-        fail(path, 'Policy variable is outside its declaring scope.');
-}
-function validatePolicyMethod(context, ref, path) {
-    const owner = context.classes.get(Key.of(ref.owner))?.value;
-    const method = owner?.kind === 'node' ? owner.methods.find((method) => method.name === ref.name) : undefined;
-    if (method === undefined || !isMethodExecutable(owner, method))
-        fail(path, 'Policy Method ref must name an exact concrete Method declaration.');
-}
-function validatePolicyCycles(entry, local, entryIndex) {
-    const visiting = new Set();
-    const visited = new Set();
-    const visit = (name) => {
-        if (visiting.has(name))
-            fail(`/closure/${entryIndex}/definitions/policies`, `Named Policy composition cycle reaches ${name}.`);
-        if (visited.has(name))
-            return;
-        visiting.add(name);
-        const expression = local.get(name)?.expression;
-        if (expression !== undefined && !('match' in expression)) {
-            for (const ref of 'allOf' in expression ? expression.allOf : expression.anyOf)
-                if (ref.origin === entry.origin && ref.kind === 'policy')
-                    visit(ref.name);
-        }
-        visiting.delete(name);
-        visited.add(name);
-    };
-    for (const name of local.keys())
-        visit(name);
-}
-function validateCallablePolicy(context, entry, expression, inputIndex, fields, instanceMethod, path) {
-    if ('check' in expression || 'sameNode' in expression) {
-        if ('check' in expression &&
-            (expression.check.origin !== entry.origin ||
-                context.policies.get(Key.of(expression.check)) === undefined))
-            fail(`${path}/check`, 'Callable Policy must reference a local named Policy.');
-        const objects = 'check' in expression ? { object: expression.object } : expression.sameNode;
-        for (const [side, object] of Object.entries(objects)) {
-            if (object.kind === 'ref' && object.ref.kind === 'method')
-                validatePolicyMethod(context, object.ref, `${path}/${side}/ref`);
-            if (object.kind === 'self' && !instanceMethod)
-                fail(`${path}/${side}`, 'self is valid only for an instance Method.');
-            if (object.kind === 'input' &&
-                (fields === undefined ||
-                    fields[object.field] === undefined ||
-                    !isSingleNodePathField(context, entry, inputIndex, object.field))) {
-                fail(`${path}/${side}`, 'Callable Policy input target must be a direct required single-Node Path field.');
-            }
-        }
-        return;
-    }
-    const children = 'allOf' in expression ? expression.allOf : expression.anyOf;
-    if (children.length === 0)
-        fail(path, 'Callable Policy composition must be non-empty.');
-    children.forEach((child, index) => validateCallablePolicy(context, entry, child, inputIndex, fields, instanceMethod, `${path}/${index}`));
-}
-function isSingleNodePathField(context, entry, inputIndex, field) {
-    const rootValue = entry.values[inputIndex]?.nodes[entry.values[inputIndex].root]?.schema;
-    if (rootValue === null || typeof rootValue !== 'object' || Array.isArray(rootValue))
-        return false;
-    const root = rootValue;
-    const properties = root.properties;
-    if (properties === null || typeof properties !== 'object' || Array.isArray(properties))
-        return false;
-    const schemaValue = properties[field];
-    if (schemaValue === null || typeof schemaValue !== 'object' || Array.isArray(schemaValue))
-        return false;
-    const schema = schemaValue;
-    const annotationValue = schema['x-astrale-path'];
-    if (annotationValue === null ||
-        typeof annotationValue !== 'object' ||
-        Array.isArray(annotationValue))
-        return false;
-    const annotation = annotationValue;
-    return (root.type === 'object' &&
-        root.additionalProperties === false &&
-        Array.isArray(root.required) &&
-        root.required.includes(field) &&
-        schema.$ref === GRAPH_NODE_PATH_SCHEMA_ID &&
-        annotation.target === 'node' &&
-        annotation.cardinality === 'one' &&
-        Array.isArray(annotation.accepts) &&
-        annotation.accepts.length > 0 &&
-        annotation.accepts.every((ref) => isNodeClassRef(context, ref)));
-}
-function isNodeClassRef(context, value) {
-    if (value === null || typeof value !== 'object' || Array.isArray(value))
-        return false;
-    const ref = value;
-    if (typeof ref.origin !== 'string' || ref.kind !== 'class' || typeof ref.name !== 'string') {
-        return false;
-    }
-    return context.classes.get(Key.of(ref))?.value.kind === 'node';
-}
-function validatePolicyParity(context, entry, entryIndex, policies, origins) {
-    const normalized = new Map([...policies].map(([name, policy]) => [name, normalizePolicyExpression(policy.expression)]));
-    const typing = new CompiledPolicyTyping(context, entry, normalized, origins);
-    for (const [name, declaration] of policies) {
-        const path = `/closure/${entryIndex}/definitions/policies/${declarationIndex(entry, 'policies', name)}`;
-        if ('match' in declaration.expression) {
-            for (const branch of branchesOf(declaration.expression.match, name)) {
-                if (targetMode(branch) === undefined) {
-                    fail(`${path}/expression/match`, 'A Policy branch must target object or at least one of source and target.');
-                }
-                if (!isConnected(branch)) {
-                    fail(`${path}/expression/match`, 'A Policy branch must connect subject, every referenced protected term, and every scoped variable.');
-                }
-            }
-        }
-        const measure = measureCompiledPolicy(entry.origin, name, normalized, new Set());
-        if (measure !== undefined &&
-            (measure.depth > MAX_PATTERN_DEPTH ||
-                measure.edgeCounts.length > MAX_BRANCHES ||
-                Math.max(0, ...measure.edgeCounts) > MAX_EDGES ||
-                measure.domains.size > MAX_DOMAINS)) {
-            fail(path, 'Policy expansion exceeds the V1 depth, branch, Edge, or Domain budget.');
-        }
-        const branches = typing.expandedBranches(name, new Set(), `$${name}`);
-        if (branches !== undefined) {
-            for (const branch of branches) {
-                const mode = targetMode(branch);
-                if (mode === undefined)
-                    fail(path, 'Expanded Policy branches must use one coherent target mode.');
-                const use = mode === 'object'
-                    ? { kind: 'object', object: { kind: 'default' } }
-                    : { kind: 'edge', source: { kind: 'default' }, target: { kind: 'default' } };
-                if (!typing.branchIsTyped(branch, use))
-                    fail(path, 'A Policy branch has contradictory endpoint or repeat contracts.');
-            }
-        }
-    }
-    for (const [classIndex, definition] of entry.definitions.classes.entries()) {
-        for (const operation of ['read', 'traverse']) {
-            const policy = definition.policies[operation];
-            if (policy === undefined)
-                continue;
-            const path = `/closure/${entryIndex}/definitions/classes/${classIndex}/policies/${operation}`;
-            const label = operation === 'read' ? 'Read' : 'Traverse';
-            if (definition.kind === 'node') {
-                if (!typing.policyAccepts(policy.name, { kind: 'exact', ref: definition.ref })) {
-                    fail(path, `${label} Policy is incompatible with its protected Node Class.`);
-                }
-            }
-            else if (isCompiledEdge(definition)) {
-                const endpoints = definition.orientation === 'directed'
-                    ? [definition.endpoints.source, definition.endpoints.target]
-                    : definition.endpoints;
-                const sources = typing.concreteEndpointClasses(endpoints[0].accepts);
-                const targets = typing.concreteEndpointClasses(endpoints[1].accepts);
-                if (sources.some((source) => targets.some((target) => !typing.policyAcceptsEdge(policy.name, { kind: 'exact', ref: source }, { kind: 'exact', ref: target })))) {
-                    fail(path, `${label} Policy is incompatible with an accepted Edge endpoint pair.`);
-                }
-            }
-        }
-        if (definition.kind === 'node') {
-            for (const [methodIndex, method] of definition.methods.entries()) {
-                if (method.policy !== undefined) {
-                    validateCallablePolicyTyping(context, typing, entry, method.policy, method.input, method.static ? undefined : definition.ref, `/closure/${entryIndex}/definitions/classes/${classIndex}/methods/${methodIndex}/policy`);
-                }
-            }
-        }
-    }
-    for (const [functionIndex, callable] of entry.definitions.functions.entries()) {
-        if (callable.policy !== undefined) {
-            validateCallablePolicyTyping(context, typing, entry, callable.policy, typeof callable.input === 'number' ? callable.input : callable.input.metadata, undefined, `/closure/${entryIndex}/definitions/functions/${functionIndex}/policy`);
-        }
-    }
-}
-function declarationIndex(entry, kind, name) {
-    return entry.definitions[kind].findIndex(({ ref }) => ref.name === name);
-}
-function validateCallablePolicyTyping(context, typing, entry, expression, input, receiver, path) {
-    const measure = measureChecks(expression);
-    if (measure.depth > MAX_CHECK_DEPTH ||
-        measure.branches > MAX_BRANCHES ||
-        measure.leaves > MAX_CHECK_LEAVES) {
-        fail(path, 'Callable Policy checks exceed the V1 depth, branch, or leaf budget.');
-    }
-    const leaves = new Map();
-    const visit = (value, pointer) => {
-        if ('sameNode' in value)
-            return;
-        if (!('check' in value)) {
-            const children = 'allOf' in value ? value.allOf : value.anyOf;
-            children.forEach((child, index) => visit(child, `${pointer}/${index}`));
-            return;
-        }
-        const contracts = callableObjectContracts(context, entry, input, receiver, value.object);
-        if (contracts === undefined)
-            return;
-        const typings = new Map(contracts.map((contract) => [
-            contract.kind === 'exact' ? Key.of(contract.ref) : 'default',
-            typing.policyBranchTyping(value.check.name, contract),
-        ]));
-        const admitted = admittedCheckClasses(typings);
-        if (admitted === undefined) {
-            fail(pointer, 'Named Policy is incompatible with the callable object contract.');
-        }
-        leaves.set(value, { accepted: [...typings.keys()], admitted });
-    };
-    visit(expression, path);
-    const [never] = neverAdmittedClasses(expression, leaves);
-    if (never !== undefined) {
-        fail(path, `Callable Policy checks can never admit ${never[0]} of Class ${never[1]}.`);
-    }
-}
-function callableObjectContracts(context, entry, input, receiver, object) {
-    if (object.kind === 'self') {
-        return receiver === undefined ? undefined : [{ kind: 'exact', ref: receiver }];
-    }
-    if (object.kind === 'input') {
-        return nodePathAccepts(entry, input, object.field).map((ref) => ({ kind: 'exact', ref }));
-    }
-    const ref = object.ref;
-    if (ref.kind === 'core') {
-        const node = context.core.get(Key.of(ref))?.value;
-        return node === undefined ? undefined : [{ kind: 'exact', ref: node.class }];
-    }
-    const projection = ref.kind === 'class'
-        ? 'Class'
-        : ref.kind === 'function' || ref.kind === 'method'
-            ? 'Function'
-            : ref.kind === 'policy'
-                ? 'Policy'
-                : 'View';
-    return [
-        {
-            kind: 'exact',
-            ref: { origin: 'kernel.astrale.ai', kind: 'class', name: projection },
-        },
-    ];
-}
-function nodePathAccepts(entry, input, field) {
-    const root = entry.values[input]?.nodes[entry.values[input].root]?.schema;
-    const properties = root?.properties;
-    const fieldSchema = properties?.[field];
-    const annotation = fieldSchema?.['x-astrale-path'];
-    return Array.isArray(annotation?.accepts)
-        ? annotation.accepts
-        : [];
-}
-/** Types one entry's Policies against the Node Classes of its own closure, as source admission. */
-class CompiledPolicyTyping {
-    context;
-    entry;
-    normalized;
-    allNodeClasses;
-    concreteNodeClasses;
-    constructor(context, entry, normalized, origins) {
-        this.context = context;
-        this.entry = entry;
-        this.normalized = normalized;
-        const nodeClasses = [...context.classes.values()].filter(({ value }) => value.kind === 'node' && origins.has(value.ref.origin));
-        this.allNodeClasses = nodeClasses.map(({ value }) => value.ref);
-        this.concreteNodeClasses = nodeClasses
-            .filter(({ value }) => !value.abstract)
-            .map(({ value }) => value.ref);
-    }
-    expandedBranches(name, visiting, namespace) {
-        if (visiting.has(name))
-            return undefined;
-        const declaration = this.normalized.get(name);
-        if (declaration === undefined)
-            return undefined;
-        if ('match' in declaration)
-            return branchesOf(declaration.match, namespace);
-        const nested = new Set(visiting);
-        nested.add(name);
-        const refs = 'allOf' in declaration ? declaration.allOf : declaration.anyOf;
-        const children = [];
-        for (const [index, ref] of refs.entries()) {
-            if (ref.origin !== this.entry.origin || ref.kind !== 'policy')
-                return undefined;
-            const expanded = this.expandedBranches(ref.name, nested, `${namespace}/${index}:${ref.name}`);
-            if (expanded === undefined)
-                return undefined;
-            children.push(expanded);
-        }
-        return 'allOf' in declaration ? branchProduct(children) : capBranches(children.flat());
-    }
-    policyAccepts(name, object) {
-        return this.policyBranchTyping(name, object)?.every(Boolean) ?? false;
-    }
-    policyBranchTyping(name, object) {
-        const branches = this.expandedBranches(name, new Set(), `$use:${name}`);
-        return branches?.map((branch) => this.branchIsTyped(branch, { kind: 'object', object }));
-    }
-    policyAcceptsEdge(name, source, target) {
-        const branches = this.expandedBranches(name, new Set(), `$edge-use:${name}`);
-        return (branches !== undefined &&
-            branches.every((branch) => this.branchIsTyped(branch, { kind: 'edge', source, target })));
-    }
-    concreteEndpointClasses(accepts) {
-        return this.concreteNodeClasses.filter((candidate) => classSatisfiesAny(this.context, candidate, accepts));
-    }
-    endpointsOverlap(left, right) {
-        const seed = [{ kind: 'open', requirements: [] }];
-        return this.applyEndpoint(this.applyEndpoint(seed, left), right).length > 0;
-    }
-    branchIsTyped(branch, use) {
-        if (targetMode(branch) !== use.kind)
-            return false;
-        return compiledEdgeAlternatives(branch.edges, this).some((variants) => this.constraintsSatisfiable(branch, variants, use));
-    }
-    constraintsSatisfiable(branch, variants, use) {
-        const terms = new Set(use.kind === 'object' ? ['subject', 'object'] : ['subject', 'source', 'target']);
-        for (const key of branch.variables.keys())
-            terms.add(key);
-        for (const key of branch.terms.keys())
-            terms.add(key);
-        for (const edge of branch.edges) {
-            terms.add(termKey(edge.pattern.source, edge.namespace));
-            terms.add(termKey(edge.pattern.target, edge.namespace));
-        }
-        const union = new CompiledUnionFind(terms);
-        for (const [left, right] of branch.equalities)
-            union.join(left, right);
-        for (const variant of variants)
-            for (const [left, right] of variant.equalities)
-                union.join(left, right);
-        const constraints = new Map();
-        for (const variant of variants) {
-            for (const [term, accepts] of variant.constraints) {
-                const root = union.find(term);
-                const values = constraints.get(root) ?? [];
-                values.push(accepts);
-                constraints.set(root, values);
-            }
-        }
-        const groups = new Map();
-        for (const term of terms) {
-            const root = union.find(term);
-            const values = groups.get(root) ?? [];
-            values.push(term);
-            groups.set(root, values);
-        }
-        for (const [root, members] of groups) {
-            let candidates = [{ kind: 'open', requirements: [] }];
-            for (const member of members) {
-                candidates = this.applyInitial(candidates, member, branch, use);
-                if (candidates.length === 0)
-                    return false;
-            }
-            for (const endpoint of constraints.get(root) ?? []) {
-                candidates = this.applyEndpoint(candidates, endpoint);
-                if (candidates.length === 0)
-                    return false;
-            }
-        }
-        return true;
-    }
-    applyInitial(candidates, term, branch, use) {
-        if (term === 'subject')
-            return this.applyAnyNodeClass(candidates);
-        const contract = compiledTargetContract(term, use);
-        if (contract !== undefined) {
-            return contract.kind === 'exact'
-                ? this.applyExact(candidates, contract.ref)
-                : uniqueCompiledCandidates(this.allNodeClasses.flatMap((ref) => this.applyExact(candidates, ref)));
-        }
-        const referenced = branch.terms.get(term);
-        if (referenced?.kind === 'ref') {
-            const contract = callableObjectContracts(this.context, this.entry, 0, undefined, referenced)?.[0];
-            return contract?.kind === 'exact' ? this.applyExact(candidates, contract.ref) : [];
-        }
-        const selector = branch.variables.get(term);
-        if (selector === undefined)
-            return [];
-        if (selector.kind === 'exact')
-            return this.applyExact(candidates, selector.class);
-        if (selector.kind === 'any')
-            return candidates;
-        return this.applyRequirement(candidates, selector.class);
-    }
-    applyExact(candidates, exact) {
-        return uniqueCompiledCandidates(candidates.flatMap((candidate) => {
-            if (candidate.kind === 'exact')
-                return Key.of(candidate.ref) === Key.of(exact) ? [candidate] : [];
-            return candidate.requirements.every((required) => classSatisfiesAny(this.context, exact, [required]))
-                ? [{ kind: 'exact', ref: exact }]
-                : [];
-        }));
-    }
-    applyAnyNodeClass(candidates) {
-        return uniqueCompiledCandidates(candidates.flatMap((candidate) => candidate.kind === 'exact'
-            ? [candidate]
-            : this.allNodeClasses
-                .filter((ref) => candidate.requirements.every((required) => classSatisfiesAny(this.context, ref, [required])))
-                .map((ref) => ({ kind: 'exact', ref }))));
-    }
-    applyRequirement(candidates, required) {
-        const result = [];
-        for (const candidate of candidates) {
-            if (candidate.kind === 'exact') {
-                if (classSatisfiesAny(this.context, candidate.ref, [required]))
-                    result.push(candidate);
-            }
-            else {
-                result.push({
-                    kind: 'open',
-                    requirements: uniqueClassRefs([...candidate.requirements, required]),
-                });
-            }
-        }
-        return uniqueCompiledCandidates(result);
-    }
-    applyEndpoint(candidates, accepts) {
-        const result = [];
-        for (const candidate of candidates) {
-            if (candidate.kind === 'exact') {
-                if (classSatisfiesAny(this.context, candidate.ref, accepts))
-                    result.push(candidate);
-            }
-            else {
-                for (const accept of accepts) {
-                    result.push({
-                        kind: 'open',
-                        requirements: uniqueClassRefs([...candidate.requirements, accept]),
-                    });
-                }
-            }
-        }
-        return uniqueCompiledCandidates(result);
-    }
-}
-function compiledTargetContract(term, use) {
-    if (use.kind === 'object')
-        return term === 'object' ? use.object : undefined;
-    return term === 'source' ? use.source : term === 'target' ? use.target : undefined;
-}
-function compiledEdgeAlternatives(edges, typing) {
-    let result = [[]];
-    for (const edge of edges) {
-        const variants = compiledVariantsForEdge(edge, typing);
-        if (variants.length === 0)
-            return [];
-        result = result.flatMap((prefix) => variants.map((variant) => [...prefix, variant]));
-    }
-    return result;
-}
-function compiledVariantsForEdge(use, typing) {
-    const declaration = typing.context.classes.get(Key.of(use.pattern.class))?.value;
-    if (declaration === undefined || !isCompiledEdge(declaration))
-        return [];
-    const endpoints = declaration.orientation === 'directed'
-        ? [declaration.endpoints.source, declaration.endpoints.target]
-        : declaration.endpoints;
-    const repeat = use.pattern.repeat ?? { min: 1, max: 1 };
-    const sourceKey = termKey(use.pattern.source, use.namespace);
-    const targetKey = termKey(use.pattern.target, use.namespace);
-    const variants = [];
-    for (let length = repeat.min; length <= repeat.max; length++) {
-        if (length === 0) {
-            variants.push({ constraints: [], equalities: [[sourceKey, targetKey]] });
-            continue;
-        }
-        const orientationCount = declaration.orientation === 'undirected' ? 2 ** length : 1;
-        for (let mask = 0; mask < orientationCount; mask++) {
-            const reversed = Array.from({ length }, (_, index) => declaration.orientation === 'undirected' && (mask & (1 << index)) !== 0);
-            let valid = true;
-            for (let index = 0; index + 1 < length; index++) {
-                const incoming = reversed[index] ? endpoints[0] : endpoints[1];
-                const outgoing = reversed[index + 1] ? endpoints[1] : endpoints[0];
-                if (!typing.endpointsOverlap(incoming.accepts, outgoing.accepts))
-                    valid = false;
-            }
-            if (!valid)
-                continue;
-            const first = reversed[0] ? endpoints[1] : endpoints[0];
-            const last = reversed[length - 1] ? endpoints[0] : endpoints[1];
-            variants.push({
-                constraints: [
-                    [sourceKey, first.accepts],
-                    [targetKey, last.accepts],
-                ],
-                equalities: [],
-            });
-        }
-    }
-    return uniqueCompiledEdgeVariants(variants);
-}
-function uniqueCompiledEdgeVariants(values) {
-    const result = new Map();
-    for (const value of values) {
-        const key = `${value.constraints.map(([term, accepts]) => `${term}:${accepts.map(Key.of).sort(compareUnicode).join(',')}`).join('|')}=${value.equalities.map(([left, right]) => `${left}:${right}`).join('|')}`;
-        result.set(key, value);
-    }
-    return [...result.values()];
-}
-function uniqueCompiledCandidates(values) {
-    const result = new Map();
-    for (const value of values) {
-        const key = value.kind === 'exact'
-            ? `exact:${Key.of(value.ref)}`
-            : `open:${value.requirements.map(Key.of).sort(compareUnicode).join('|')}`;
-        result.set(key, value);
-    }
-    return [...result.values()];
-}
-function uniqueClassRefs(values) {
-    return [...new Map(values.map((value) => [Key.of(value), value])).values()];
-}
-function measureCompiledPolicy(origin, name, normalized, visiting) {
-    if (visiting.has(name))
-        return undefined;
-    const expression = normalized.get(name);
-    if (expression === undefined)
-        return undefined;
-    if ('match' in expression)
-        return measureCompiledPattern(expression.match, origin);
-    const nested = new Set(visiting);
-    nested.add(name);
-    const refs = 'allOf' in expression ? expression.allOf : expression.anyOf;
-    const children = refs.map((ref) => ref.origin === origin ? measureCompiledPolicy(origin, ref.name, normalized, nested) : undefined);
-    if (children.some((value) => value === undefined))
-        return undefined;
-    return combineCompiledMeasures('allOf' in expression ? 'allOf' : 'anyOf', children);
-}
-function measureCompiledPattern(pattern, origin) {
-    if ('sameNode' in pattern)
-        return {
-            depth: 1,
-            edgeCounts: [1],
-            domains: new Set([
-                origin,
-                ...[pattern.sameNode.left, pattern.sameNode.right].flatMap((term) => term.kind === 'ref' ? [policyObjectOrigin(term.ref)] : []),
-            ]),
-        };
-    if ('source' in pattern)
-        return {
-            depth: 1,
-            edgeCounts: [1],
-            domains: new Set([
-                origin,
-                pattern.class.origin,
-                ...[pattern.source, pattern.target].flatMap((term) => term.kind === 'ref' ? [policyObjectOrigin(term.ref)] : []),
-            ]),
-        };
-    if ('exists' in pattern) {
-        const child = measureCompiledPattern(pattern.exists.where, origin);
-        return {
-            depth: child.depth + 1,
-            edgeCounts: child.edgeCounts,
-            domains: new Set([
-                ...child.domains,
-                ...pattern.exists.nodes.flatMap((node) => {
-                    const ref = policyVariableClass(node);
-                    return ref === undefined ? [] : [ref.origin];
-                }),
-            ]),
-        };
-    }
-    return combineCompiledMeasures('allOf' in pattern ? 'allOf' : 'anyOf', ('allOf' in pattern ? pattern.allOf : pattern.anyOf).map((child) => measureCompiledPattern(child, origin)));
-}
-function combineCompiledMeasures(kind, children) {
-    const depth = 1 + Math.max(0, ...children.map((child) => child.depth));
-    const domains = new Set(children.flatMap((child) => [...child.domains]));
-    if (kind === 'anyOf')
-        return {
-            depth,
-            edgeCounts: children.flatMap((child) => child.edgeCounts).slice(0, BRANCH_OVERFLOW),
-            domains,
-        };
-    let edgeCounts = [0];
-    for (const child of children) {
-        const next = [];
-        for (const left of edgeCounts) {
-            for (const right of child.edgeCounts) {
-                next.push(left + right);
-                if (next.length >= BRANCH_OVERFLOW)
-                    break;
-            }
-            if (next.length >= BRANCH_OVERFLOW)
-                break;
-        }
-        edgeCounts = next;
-    }
-    return { depth, edgeCounts, domains };
-}
-class CompiledUnionFind {
-    #parents = new Map();
-    constructor(values) {
-        for (const value of values)
-            this.add(value);
-    }
-    add(value) {
-        if (!this.#parents.has(value))
-            this.#parents.set(value, value);
-    }
-    find(value) {
-        this.add(value);
-        const parent = this.#parents.get(value);
-        if (parent === value)
-            return value;
-        const root = this.find(parent);
-        this.#parents.set(value, root);
-        return root;
-    }
-    join(left, right) {
-        const a = this.find(left);
-        const b = this.find(right);
-        if (a !== b)
-            this.#parents.set(b, a);
-    }
-}
-function validateCore(candidate, context) {
-    for (const [entryIndex, entry] of candidate.closure.entries()) {
-        const nodes = new Map();
-        for (const [index, value] of entry.definitions.core.entries()) {
-            const path = `/closure/${entryIndex}/definitions/core/${index}`;
-            const classValue = context.classes.get(Key.of(value.class));
-            if (value.class.origin !== entry.origin ||
-                classValue?.value.kind !== 'node' ||
-                classValue.value.abstract)
-                fail(`${path}/class`, 'A Core Node requires a local concrete Node Class.');
-            const analysis = context.analyses.get(Key.of(value.class));
-            if (analysis === undefined)
-                fail(`${path}/class`, 'Core Node Class analysis is absent.');
-            validateCoreProperties(value.properties, analysis, `${path}/properties`);
-            nodes.set(Key.of(value.ref), {
-                key: Key.of(value.ref),
-                value,
-                class: classValue,
-                analysis,
-                pointer: path,
-            });
-        }
-        const edges = [];
-        for (const [index, value] of entry.facts.core.entries()) {
-            const path = `/closure/${entryIndex}/facts/core/${index}`;
-            const classValue = context.classes.get(Key.of(value.class));
-            if (value.class.origin !== entry.origin ||
-                classValue === undefined ||
-                !isCompiledEdge(classValue.value) ||
-                classValue.value.abstract)
-                fail(`${path}/class`, 'A Core Edge requires a local concrete Edge Class.');
-            const analysis = context.analyses.get(Key.of(value.class));
-            if (analysis === undefined)
-                fail(`${path}/class`, 'Core Edge Class analysis is absent.');
-            validateCoreProperties(value.properties, analysis, `${path}/properties`);
-            const source = resolveCoreEndpoint(context, entry, value.source, nodes, `${path}/source`);
-            const target = resolveCoreEndpoint(context, entry, value.target, nodes, `${path}/target`);
-            const declaration = classValue.value;
-            const satisfies = declaration.orientation === 'directed'
-                ? endpointSatisfies(context, source, declaration.endpoints.source.accepts) &&
-                    endpointSatisfies(context, target, declaration.endpoints.target.accepts)
-                : (endpointSatisfies(context, source, declaration.endpoints[0].accepts) &&
-                    endpointSatisfies(context, target, declaration.endpoints[1].accepts)) ||
-                    (endpointSatisfies(context, source, declaration.endpoints[1].accepts) &&
-                        endpointSatisfies(context, target, declaration.endpoints[0].accepts));
-            if (!satisfies)
-                fail(path, 'Core Edge endpoints do not satisfy its exact Class.');
-            edges.push({
-                source,
-                target,
-                value,
-                class: classValue,
-                pointer: path,
-            });
-        }
-        validateCoreEdgeSet(context, entry, entryIndex, nodes, edges);
-    }
-}
-function validateCoreProperties(values, analysis, path) {
-    for (const key of Object.keys(values))
-        if (!analysis.properties.has(key))
-            fail(`${path}/${escapePointer(key)}`, 'Core properties contain an unknown Property key.');
-    for (const property of analysis.properties.values()) {
-        if (!Object.hasOwn(values, property.key)) {
-            if (property.declaration.required && property.declaration.auto === undefined)
-                fail(`${path}/${escapePointer(property.key)}`, 'Core properties omit a required Property.');
-            continue;
-        }
-        if (property.declaration.auto !== undefined)
-            fail(`${path}/${escapePointer(property.key)}`, 'Core properties cannot author an automatic Property.');
-        if (validateValueProgram(bindValueProgram(property.entry.values[property.declaration.value], property.entry.patterns), values[property.key]).length > 0)
-            fail(`${path}/${escapePointer(property.key)}`, 'Core Property value does not satisfy its exact contract.');
-    }
-}
-function resolveCoreEndpoint(context, entry, ref, nodes, path) {
-    if (ref.kind === 'domain')
-        return { key: 'domain' };
-    const undeclared = () => fail(path, 'Core endpoint does not name a declared local Definition.');
-    if (policyObjectOrigin(ref) !== entry.origin)
-        return undeclared();
-    if (ref.kind === 'core')
-        return nodes.get(Key.of(ref)) ?? undeclared();
-    if (!declaresProjectedMember(context, entry, ref))
-        return undeclared();
-    return { key: policyObjectKey(ref), class: projectedMemberClass(ref), pointer: path };
-}
-/** Only a projected declaration can carry a Core fact; an abstract Method is never projected. */
-function declaresProjectedMember(context, entry, ref) {
-    if (ref.kind === 'method') {
-        const owner = context.classes.get(Key.of(ref.owner))?.value;
-        const method = owner?.kind === 'node' ? owner.methods.find((value) => value.name === ref.name) : undefined;
-        return method !== undefined && isMethodExecutable(owner, method);
-    }
-    const declarations = ref.kind === 'class'
-        ? entry.definitions.classes
-        : ref.kind === 'function'
-            ? entry.definitions.functions
-            : ref.kind === 'policy'
-                ? entry.definitions.policies
-                : entry.definitions.views;
-    return declarations.some((declaration) => declaration.ref.name === ref.name);
-}
-function endpointSatisfies(context, endpoint, accepts) {
-    if ('value' in endpoint)
-        return classSatisfiesAny(context, endpoint.value.class, accepts);
-    if ('class' in endpoint)
-        return classSatisfiesAny(context, endpoint.class, accepts);
-    return true;
-}
-function validateCoreEdgeSet(context, entry, entryIndex, nodes, edges) {
-    const seen = new Set();
-    const slices = new Map();
-    for (const edge of edges) {
-        const classKey = Key.of(edge.value.class);
-        const [source, target] = edge.class.value.orientation === 'undirected' &&
-            compareUnicode(edge.source.key, edge.target.key) > 0
-            ? [edge.target.key, edge.source.key]
-            : [edge.source.key, edge.target.key];
-        const key = `${classKey}\u0000${source}\u0000${target}`;
-        if (seen.has(key))
-            fail(edge.pointer, 'Core Edge duplicates an exact normalized Edge identity.');
-        seen.add(key);
-        const values = slices.get(classKey) ?? [];
-        values.push(edge);
-        slices.set(classKey, values);
-        if (edge.class.value.constraints.noSelf === true && edge.source.key === edge.target.key)
-            fail(edge.pointer, 'Core Edge violates noSelf.');
-    }
-    for (const edgeClass of entry.definitions.classes) {
-        if (!isCompiledEdge(edgeClass))
-            continue;
-        const classEdges = slices.get(Key.of(edgeClass.ref)) ?? [];
-        if (edgeClass.constraints.acyclic === true && hasCycle(classEdges))
-            fail(`/closure/${entryIndex}/facts/core`, 'Core Edge set violates exact-Class acyclicity.');
-        validateCardinality(context, edgeClass, classEdges, nodes);
-    }
-}
-function validateCardinality(context, declaration, edges, nodes) {
-    for (const subject of cardinalitySubjects(edges, nodes)) {
-        if (declaration.orientation === 'directed') {
-            if (classSatisfiesAny(context, subject.class, declaration.endpoints.source.accepts))
-                checkCount(declaration.endpoints.source.outgoing, edges.filter(({ source }) => source.key === subject.key).length, subject.pointer, subject.minimum);
-            if (classSatisfiesAny(context, subject.class, declaration.endpoints.target.accepts))
-                checkCount(declaration.endpoints.target.incoming, edges.filter(({ target }) => target.key === subject.key).length, subject.pointer, subject.minimum);
-        }
-        else {
-            const degree = edges.filter(({ source, target }) => source.key === subject.key || target.key === subject.key).length;
-            const [first, second] = declaration.endpoints;
-            if (classSatisfiesAny(context, subject.class, first.accepts))
-                checkCount(first.incident, degree, subject.pointer, subject.minimum);
-            if (!sameIncidentEndpoint(first, second) &&
-                classSatisfiesAny(context, subject.class, second.accepts))
-                checkCount(second.incident, degree, subject.pointer, subject.minimum);
-        }
-    }
-}
-/**
- * Every declared Core Node proves its own complete degree, so both bounds hold. A Definition
- * endpoint is only named by the Edges that reach it: the Domain may also create ordinary Edges of
- * the same Class against it, so a minimum is unprovable here and only the maximum is enforced.
- */
-function cardinalitySubjects(edges, nodes) {
-    const subjects = new Map();
-    for (const node of nodes.values()) {
-        subjects.set(node.key, {
-            key: node.key,
-            class: node.value.class,
-            pointer: node.pointer,
-            minimum: true,
-        });
-    }
-    for (const edge of edges) {
-        for (const endpoint of [edge.source, edge.target]) {
-            if ('value' in endpoint || !('class' in endpoint) || subjects.has(endpoint.key))
-                continue;
-            subjects.set(endpoint.key, {
-                key: endpoint.key,
-                class: endpoint.class,
-                pointer: endpoint.pointer,
-                minimum: false,
-            });
-        }
-    }
-    return Object.freeze([...subjects.values()]);
-}
-function checkCount(count, degree, path, enforceMinimum) {
-    const [minimum, maximum] = countBounds(count);
-    if (degree > maximum || (degree < minimum && enforceMinimum))
-        fail(path, `Core degree ${degree} violates Edge count ${count}.`);
-}
-function countBounds(value) {
-    switch (value) {
-        case '0..*':
-            return [0, Number.POSITIVE_INFINITY];
-        case '1..*':
-            return [1, Number.POSITIVE_INFINITY];
-        case '0..1':
-            return [0, 1];
-        case '1':
-            return [1, 1];
-    }
-}
-function hasCycle(edges) {
-    const outgoing = new Map();
-    for (const edge of edges) {
-        const values = outgoing.get(edge.source.key) ?? [];
-        values.push(edge.target.key);
-        outgoing.set(edge.source.key, values);
-    }
-    const visiting = new Set();
-    const visited = new Set();
-    const visit = (key) => {
-        if (visiting.has(key))
-            return true;
-        if (visited.has(key))
-            return false;
-        visiting.add(key);
-        if ((outgoing.get(key) ?? []).some(visit))
-            return true;
-        visiting.delete(key);
-        visited.add(key);
-        return false;
-    };
-    return [...outgoing.keys()].some(visit);
-}
-function escapePointer(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}
-function isCompiledEdge(value) {
-    return value.kind === 'edge';
-}
-function fail(pointer, message) {
-    return invalidCompiled('COMPILED_SOURCE_INVALID', message, pointer);
-}