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

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

@@ -0,0 +1,123 @@
+import { Key } from '../../../addressing/index.js';
+import { isMethodExecutable } from '../../../language/callable/executable.js';
+import {} from '../../../language/core/model/core.js';
+import { policyObjectOrigin, policyObjectKey, projectedMemberClass, } from '../../../language/index.js';
+import { bindValueProgram } from '../../../language/value/compile/load.js';
+import { validateValueProgram } from '../../../language/value/evaluate/program.js';
+import {} from '../../model/schema.js';
+import { fail } from '../diagnostic.js';
+import { validateCoreEdgeSet } from './cardinality.js';
+import { isCompiledEdge, classSatisfiesAny, } from './context.js';
+/** Admit local Core Nodes, Properties and Edge endpoint contracts. */
+export 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 escapePointer(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}

package/dist/v1/compiled/admission/semantics/edge.d.ts

@@ -0,0 +1,8 @@
+import { type EdgeCount, type IncidentEndpoint } from '../../../language/class/model/edge.js';
+import { type SemanticIndex } from './context.js';
+/** Check Edge endpoint contracts and safe inheritance refinement. */
+export declare function validateEdges(context: SemanticIndex): void;
+/** Compare undirected endpoint acceptance and cardinality contracts. */
+export declare function sameIncidentEndpoint(left: IncidentEndpoint, right: IncidentEndpoint): boolean;
+/** Interpret an Edge count as inclusive degree bounds. */
+export declare function countBounds(value: EdgeCount): readonly [number, number];

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

@@ -0,0 +1,89 @@
+import { Key } from '../../../addressing/index.js';
+import { compareUnicode } from '../../../addressing/ordering.js';
+import { isGraphRoot } from '../../../language/class/inheritance.js';
+import {} from '../../../language/class/model/edge.js';
+import { fail } from '../diagnostic.js';
+import { isCompiledEdge, classSatisfiesAny, } from './context.js';
+/** Check Edge endpoint contracts and safe inheritance refinement. */
+export 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.');
+            }
+        }
+        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 (isGraphRoot(parent))
+        return true;
+    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;
+}
+/** Compare undirected endpoint acceptance and cardinality contracts. */
+export 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]));
+}
+/** Interpret an Edge count as inclusive degree bounds. */
+export 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];
+    }
+}

package/dist/v1/compiled/admission/semantics/policy/admit.d.ts

@@ -0,0 +1,4 @@
+import { type CompiledSchema } from '../../../model/schema.js';
+import { type SemanticIndex } from '../context.js';
+/** Admit each entry’s Policy graph and all of its Policy uses. */
+export declare function validatePolicies(candidate: CompiledSchema, context: SemanticIndex, admitted: ReadonlyMap<string, ReadonlySet<string>>): void;

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

@@ -0,0 +1,57 @@
+import { Key } from '../../../../addressing/index.js';
+import {} from '../../../model/schema.js';
+import { fail } from '../../diagnostic.js';
+import {} from '../context.js';
+import { validateCallablePolicy } from './callable.js';
+import { validatePolicyParity } from './parity.js';
+import { validatePolicyExpression } from './pattern.js';
+/** Admit each entry’s Policy graph and all of its Policy uses. */
+export 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 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);
+}

package/dist/v1/compiled/admission/semantics/policy/callable.d.ts

@@ -0,0 +1,5 @@
+import { type PolicyCheckExpression } from '../../../../language/policy/model/policy.js';
+import { type CompiledSchemaEntry } from '../../../model/schema.js';
+import { type SemanticIndex } from '../context.js';
+/** Check callable Policy references, receiver access and input Path placement. */
+export declare function validateCallablePolicy(context: SemanticIndex, entry: CompiledSchemaEntry, expression: PolicyCheckExpression, inputIndex: number, fields: Readonly<Record<string, readonly number[]>> | undefined, instanceMethod: boolean, path: string): void;

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

@@ -0,0 +1,72 @@
+import { Key } from '../../../../addressing/index.js';
+import {} from '../../../../language/policy/model/policy.js';
+import { GRAPH_NODE_PATH_SCHEMA_ID } from '../../../../language/value/syntax/node-path/schema.js';
+import {} from '../../../model/schema.js';
+import { fail } from '../../diagnostic.js';
+import {} from '../context.js';
+import { validatePolicyMethod } from './pattern.js';
+/** Check callable Policy references, receiver access and input Path placement. */
+export 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';
+}

package/dist/v1/compiled/admission/semantics/policy/contracts.d.ts

@@ -0,0 +1,24 @@
+import type { PolicyCheckObject } from '../../../../language/policy/model/policy.js';
+import { type ClassRef } from '../../../../addressing/index.js';
+import { type CompiledSchemaEntry } from '../../../model/schema.js';
+import { type SemanticIndex } from '../context.js';
+/** The default protected object contract or one exact Class. */
+export type CompiledObjectContract = {
+    readonly kind: 'default';
+} | {
+    readonly kind: 'exact';
+    readonly ref: ClassRef;
+};
+/** The protected object or endpoint contracts of one Policy use. */
+export type CompiledPolicyUse = {
+    readonly kind: 'object';
+    readonly object: CompiledObjectContract;
+} | {
+    readonly kind: 'edge';
+    readonly source: CompiledObjectContract;
+    readonly target: CompiledObjectContract;
+};
+/** Resolve callable Policy objects to their protected Class contracts. */
+export declare function callableObjectContracts(context: SemanticIndex, entry: CompiledSchemaEntry, input: number, receiver: ClassRef | undefined, object: PolicyCheckObject): readonly CompiledObjectContract[] | undefined;
+/** Select the protected contract for an object or Edge endpoint term. */
+export declare function compiledTargetContract(term: string, use: CompiledPolicyUse): CompiledObjectContract | undefined;

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

@@ -0,0 +1,45 @@
+import { Key } from '../../../../addressing/index.js';
+import {} from '../../../model/schema.js';
+import {} from '../context.js';
+/** Resolve callable Policy objects to their protected Class contracts. */
+export 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
+        : [];
+}
+/** Select the protected contract for an object or Edge endpoint term. */
+export function compiledTargetContract(term, use) {
+    if (use.kind === 'object')
+        return term === 'object' ? use.object : undefined;
+    return term === 'source' ? use.source : term === 'target' ? use.target : undefined;
+}

package/dist/v1/compiled/admission/semantics/policy/equality.d.ts

@@ -0,0 +1,8 @@
+/** Retain and merge term equalities while typing one Policy branch. */
+export declare class CompiledUnionFind {
+    #private;
+    constructor(values: Iterable<string>);
+    add(value: string): void;
+    find(value: string): string;
+    join(left: string, right: string): void;
+}

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

@@ -0,0 +1,27 @@
+/** Retain and merge term equalities while typing one Policy branch. */
+export 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);
+    }
+}

package/dist/v1/compiled/admission/semantics/policy/measure.d.ts

@@ -0,0 +1,9 @@
+import { type PolicyExpression } from '../../../../language/policy/model/policy.js';
+interface CompiledPatternMeasure {
+    readonly depth: number;
+    readonly edgeCounts: readonly number[];
+    readonly domains: ReadonlySet<string>;
+}
+/** Measure expanded Policy branches, depth and referenced Domains. */
+export declare function measureCompiledPolicy(origin: string, name: string, normalized: ReadonlyMap<string, PolicyExpression>, visiting: Set<string>): CompiledPatternMeasure | undefined;
+export {};

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

@@ -0,0 +1,81 @@
+import { policyObjectOrigin, policyVariableClass } from '../../../../language/index.js';
+import { BRANCH_OVERFLOW } from '../../../../language/policy/analysis/budgets.js';
+import {} from '../../../../language/policy/model/policy.js';
+/** Measure expanded Policy branches, depth and referenced Domains. */
+export 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 };
+}

package/dist/v1/compiled/admission/semantics/policy/parity.d.ts

@@ -0,0 +1,4 @@
+import { type CompiledSchemaEntry } from '../../../model/schema.js';
+import { type SemanticIndex, type CompiledPolicy } from '../context.js';
+/** Check Policy typing and expansion budgets against the entry’s own closure. */
+export declare function validatePolicyParity(context: SemanticIndex, entry: CompiledSchemaEntry, entryIndex: number, policies: ReadonlyMap<string, CompiledPolicy>, origins: ReadonlySet<string>): void;