@astrale-os/kernel-dsl 0.2.0-beta.2 → 0.2.0-beta.20

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

@@ -0,0 +1,1114 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+import { Key, PropertyKey as PropertyKeyValue } from '../../addressing/index.js';
+import { compareUnicode } from '../../addressing/ordering.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 { normalizePolicyChecks, normalizePolicyExpression, } from '../../language/policy/normalization/normalize.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';
+/**
+ * Re-admit contextual Language laws after the portable compiled grammar and
+ * exact closure have been established. This module deliberately depends only
+ * on compiled and Language runtime machinery; it is safe in the load graph.
+ */
+export function validateCompiledSemantics(candidate) {
+    const partial = index(candidate);
+    const analyses = analyzeClasses(partial.classes);
+    const context = { ...partial, analyses };
+    validateClassFacets(context);
+    validateEdges(context);
+    validateViews(candidate, context);
+    validatePolicies(candidate, context);
+    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 inherited = new Map();
+        for (const parent of parents) {
+            for (const [name, method] of parent.methods) {
+                const values = inherited.get(name) ?? [];
+                if (!values.some(({ key }) => key === method.key))
+                    values.push(method);
+                inherited.set(name, values);
+            }
+        }
+        const methods = new Map();
+        for (const [name, values] of inherited)
+            if (values.length === 1)
+                methods.set(name, values[0]);
+        if (located.value.kind === 'node') {
+            for (const own of located.value.methods) {
+                const inheritedMethods = inherited.get(own.name) ?? [];
+                for (const parent of inheritedMethods) {
+                    if (parent.declaration.inheritance === 'sealed') {
+                        fail(`${located.pointer}/methods`, `Method ${own.name} overrides a sealed Method.`);
+                    }
+                    if (!sameMethodSignature(located.entry, own, parent.entry, parent.declaration)) {
+                        fail(`${located.pointer}/methods`, `Method ${own.name} changes its inherited signature.`);
+                    }
+                    if (parent.declaration.inheritance !== 'abstract' &&
+                        policyKey(parent.declaration.policy) !== policyKey(own.policy)) {
+                        fail(`${located.pointer}/methods`, `Method ${own.name} changes an executable inherited Policy.`);
+                    }
+                }
+                methods.set(own.name, {
+                    key: `${Key.of(located.value.ref)}.method.${own.name}`,
+                    owner: located.value.ref,
+                    declaration: own,
+                    entry: located.entry,
+                });
+                inherited.delete(own.name);
+            }
+            for (const [name, values] of inherited) {
+                if (values.length > 1)
+                    fail(`${located.pointer}/methods`, `Inherited Method ${name} is ambiguous.`);
+            }
+            if (!located.value.abstract) {
+                for (const [name, method] of methods) {
+                    if (method.declaration.inheritance === 'abstract') {
+                        fail(`${located.pointer}/methods`, `Concrete Class leaves Method ${name} abstract.`);
+                    }
+                }
+            }
+        }
+        const analysis = { properties, methods, ...(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);
+}
+function outputKey(entry, output) {
+    return output.mode === 'binary' ? 'binary' : `${output.mode}:${programKey(entry, output.value)}`;
+}
+function programKey(entry, value) {
+    return json.serialize(entry.values[value]);
+}
+function policyKey(value) {
+    return json.serialize((value === undefined ? null : normalizePolicyChecks(value)));
+}
+function validateClassFacets(context) {
+    for (const located of context.classes.values()) {
+        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 (method.inheritance === 'abstract' && method.policy !== undefined) {
+                    fail(`${located.pointer}/methods/${index}/policy`, 'An abstract Method cannot have a Policy.');
+                }
+            }
+        }
+    }
+}
+function validateEdges(context) {
+    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)) {
+            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;
+    const reverse = refine(0, 1) && refine(1, 0);
+    return reverse && !hasEffectiveEdgePolicy(context, parent, new Set());
+}
+function hasEffectiveEdgePolicy(context, declaration, visited) {
+    if (declaration.policies.read !== undefined || declaration.policies.traverse !== undefined) {
+        return true;
+    }
+    for (const parentRef of declaration.extends) {
+        const key = Key.of(parentRef);
+        if (visited.has(key))
+            continue;
+        visited.add(key);
+        const parent = context.classes.get(key)?.value;
+        if (parent !== undefined &&
+            isCompiledEdge(parent) &&
+            hasEffectiveEdgePolicy(context, parent, visited)) {
+            return true;
+        }
+    }
+    return false;
+}
+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) {
+    return [...context.classes.values()].some(({ value }) => 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) {
+    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);
+        for (const [functionIndex, callable] of entry.definitions.functions.entries()) {
+            if (callable.policy !== undefined)
+                validateCallablePolicy(context, entry, callable.policy, callable.input, 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 ('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(expression.source, `${path}/source`, scope);
+        validatePolicyTerm(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);
+            if (context.classes.get(Key.of(node.class))?.value.kind !== 'node')
+                fail(`${path}/exists/nodes/${index}/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(term, path, scope) {
+    if (term.kind === 'variable' && !scope.has(term.id))
+        fail(path, 'Policy variable is outside its declaring scope.');
+}
+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) {
+        if (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 object = expression.object;
+        if (object.kind === 'self' && !instanceMethod)
+            fail(`${path}/object`, 'self is valid only for an instance Method.');
+        if (object.kind === 'input') {
+            if (fields === undefined ||
+                fields[object.field] === undefined ||
+                !isSingleNodePathField(context, entry, inputIndex, object.field))
+                fail(`${path}/object`, 'Callable Policy input target must be a direct required single-Node Path field.');
+        }
+        if (object.kind === 'ref') {
+            if (object.ref.origin !== entry.origin ||
+                context.definitions.get(Key.of(object.ref)) === undefined)
+                fail(`${path}/object/ref`, 'Callable Policy object refs must name an exact local Definition.');
+        }
+        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) {
+    const normalized = new Map([...policies].map(([name, policy]) => [name, normalizePolicyExpression(policy.expression)]));
+    const typing = new CompiledPolicyTyping(context, entry, normalized);
+    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, callable.input, 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 visit = (value, pointer) => {
+        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 &&
+            contracts.some((contract) => !typing.policyAccepts(value.check.name, contract))) {
+            fail(pointer, 'Named Policy is incompatible with the callable object contract.');
+        }
+    };
+    visit(expression, path);
+}
+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'
+            ? '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
+        : [];
+}
+class CompiledPolicyTyping {
+    context;
+    entry;
+    normalized;
+    allNodeClasses;
+    concreteNodeClasses;
+    constructor(context, entry, normalized) {
+        this.context = context;
+        this.entry = entry;
+        this.normalized = normalized;
+        this.allNodeClasses = [...context.classes.values()]
+            .filter(({ value }) => value.kind === 'node')
+            .map(({ value }) => value.ref);
+        this.concreteNodeClasses = [...context.classes.values()]
+            .filter(({ value }) => value.kind === 'node' && !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) {
+        const branches = this.expandedBranches(name, new Set(), `$use:${name}`);
+        return (branches !== undefined &&
+            branches.every((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 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 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 exact = branch.variables.get(term);
+        return exact === undefined ? [] : this.applyExact(candidates, exact);
+    }
+    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 }))));
+    }
+    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 ('source' in pattern)
+        return { depth: 1, edgeCounts: [1], domains: new Set([origin, pattern.class.origin]) };
+    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.map(({ class: ref }) => 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(value.source, nodes, `${path}/source`);
+            const target = resolveCoreEndpoint(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(property.entry.values[property.declaration.value], values[property.key])
+            .length > 0)
+            fail(`${path}/${escapePointer(property.key)}`, 'Core Property value does not satisfy its exact contract.');
+    }
+}
+function resolveCoreEndpoint(ref, nodes, path) {
+    if (ref.kind === 'domain')
+        return { key: 'domain' };
+    const node = nodes.get(Key.of(ref));
+    if (node === undefined)
+        fail(path, 'Core endpoint does not name a declared local Core Node.');
+    return node;
+}
+function endpointSatisfies(context, endpoint, accepts) {
+    return !('value' in endpoint) || classSatisfiesAny(context, endpoint.value.class, accepts);
+}
+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 node of nodes.values()) {
+        if (declaration.orientation === 'directed') {
+            if (classSatisfiesAny(context, node.value.class, declaration.endpoints.source.accepts))
+                checkCount(declaration.endpoints.source.outgoing, edges.filter(({ source }) => source.key === node.key).length, node.pointer);
+            if (classSatisfiesAny(context, node.value.class, declaration.endpoints.target.accepts))
+                checkCount(declaration.endpoints.target.incoming, edges.filter(({ target }) => target.key === node.key).length, node.pointer);
+        }
+        else {
+            const degree = edges.filter(({ source, target }) => source.key === node.key || target.key === node.key).length;
+            const [first, second] = declaration.endpoints;
+            if (classSatisfiesAny(context, node.value.class, first.accepts))
+                checkCount(first.incident, degree, node.pointer);
+            if (!sameIncidentEndpoint(first, second) &&
+                classSatisfiesAny(context, node.value.class, second.accepts))
+                checkCount(second.incident, degree, node.pointer);
+        }
+    }
+}
+function checkCount(count, degree, path) {
+    const [minimum, maximum] = countBounds(count);
+    if (degree < minimum || degree > maximum)
+        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);
+}