@astrale-os/kernel-dsl 1.0.0-beta.12 → 1.0.0-beta.13

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

@@ -1,16 +1,19 @@
 import { Key } from '../../../addressing/index.js';
 import { isMethodExecutable } from '../../../language/callable/executable.js';
-import { coveringNodeUniqueTuples, nodeUniqueKeys } from '../../../language/class/unique.js';
+import { coveringEdgeUniqueTuples, coveringNodeUniqueTuples, edgeUniqueKeys, nodeUniqueKeys, } from '../../../language/class/unique.js';
+import { checkCoreEdgeSet, checkHeldKeys, coreEndpointsSatisfy, } from '../../../language/core/facts.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 { escapePointerToken } from '../../../language/value/syntax/pointer.js';
 import {} from '../../model/schema.js';
 import { fail } from '../diagnostic.js';
-import { validateCoreEdgeSet } from './cardinality.js';
 import { isCompiledEdge, classSatisfiesAny, } from './context.js';
+import { sameIncidentEndpoint } from './edge.js';
 /** Admit local Core Nodes, Properties and Edge endpoint contracts. */
 export function validateCore(candidate, context) {
+    const resolve = (ref) => context.classes.get(Key.of(ref))?.value;
     for (const [entryIndex, entry] of candidate.closure.entries()) {
         const nodes = new Map();
         for (const [index, value] of entry.definitions.core.entries()) {
@@ -32,7 +35,9 @@ export function validateCore(candidate, context) {
                 pointer: path,
             });
         }
-        validateCoreNodeKeys(context, nodes);
+        checkHeldKeys(nodes.values(), (node) => nodeUniqueKeys(coveringNodeUniqueTuples(node.class.value, resolve), {
+            props: node.value.properties,
+        }), (node) => fail(node.pointer, 'Core Node holds a key another Core Node holds.'));
         const edges = [];
         for (const [index, value] of entry.facts.core.entries()) {
             const path = `/closure/${entryIndex}/facts/core/${index}`;
@@ -48,14 +53,7 @@ export function validateCore(candidate, context) {
             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));
+            const satisfies = coreEndpointsSatisfy(classValue.value, source, target, (endpoint, accepts) => endpointSatisfies(context, endpoint, accepts));
             if (!satisfies)
                 fail(path, 'Core Edge endpoints do not satisfy its exact Class.');
             edges.push({
@@ -66,37 +64,61 @@ export function validateCore(candidate, context) {
                 pointer: path,
             });
         }
-        validateCoreEdgeSet(context, entry, entryIndex, nodes, edges);
+        checkCoreEdgeSet({
+            edges: edges.map((edge) => ({
+                edge,
+                class: Key.of(edge.value.class),
+                contract: edge.class.value,
+                source: edge.source,
+                target: edge.target,
+            })),
+            classes: entry.definitions.classes
+                .filter(isCompiledEdge)
+                .map((value) => ({ key: Key.of(value.ref), contract: value })),
+            nodes: [...nodes.values()].map(({ key, value, pointer }) => ({
+                key,
+                class: value.class,
+                pointer,
+            })),
+            satisfies: (ref, accepts) => classSatisfiesAny(context, ref, accepts),
+            keys: ({ edge }) => edgeUniqueKeys(coveringEdgeUniqueTuples(edge.class.value, resolve), {
+                source: edge.source.key,
+                target: edge.target.key,
+                props: edge.value.properties,
+            }),
+            sameIncident: sameIncidentEndpoint,
+            report: (issue) => coreEdgeFailure(issue, entryIndex),
+        });
     }
 }
-/** No two Core Nodes hold one key under a tuple covering their Classes (DV-NODE-UNIQUE). */
-function validateCoreNodeKeys(context, nodes) {
-    const resolve = (ref) => context.classes.get(Key.of(ref))?.value;
-    const holders = new Set();
-    for (const node of nodes.values()) {
-        const keys = nodeUniqueKeys(coveringNodeUniqueTuples(node.class.value, resolve), {
-            props: node.value.properties,
-        });
-        if (keys.some((key) => holders.has(key)))
-            fail(node.pointer, 'Core Node holds a key another Core Node holds.');
-        for (const key of keys)
-            holders.add(key);
+function coreEdgeFailure(issue, entryIndex) {
+    switch (issue.kind) {
+        case 'identity':
+            return fail(issue.edge.pointer, 'Core Edge duplicates an exact normalized Edge identity.');
+        case 'no-self':
+            return fail(issue.edge.pointer, 'Core Edge violates noSelf.');
+        case 'key':
+            return fail(issue.edge.pointer, 'Core Edge holds a key another Core Edge holds.');
+        case 'acyclic':
+            return fail(`/closure/${entryIndex}/facts/core`, 'Core Edge set violates exact-Class acyclicity.');
+        case 'degree':
+            return fail(issue.pointer, `Core degree ${issue.degree} violates Edge count ${issue.count}.`);
     }
 }
 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.');
+            fail(`${path}/${escapePointerToken(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.');
+                fail(`${path}/${escapePointerToken(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.');
+            fail(`${path}/${escapePointerToken(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.');
+            fail(`${path}/${escapePointerToken(property.key)}`, 'Core Property value does not satisfy its exact contract.');
     }
 }
 function resolveCoreEndpoint(context, entry, ref, nodes, path) {
@@ -109,7 +131,8 @@ function resolveCoreEndpoint(context, entry, ref, nodes, path) {
         return nodes.get(Key.of(ref)) ?? undeclared();
     if (!declaresProjectedMember(context, entry, ref))
         return undeclared();
-    return { key: policyObjectKey(ref), class: projectedMemberClass(ref), pointer: path };
+    // A projected member's degree is reported at the endpoint that names it.
+    return { key: policyObjectKey(ref), member: { 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) {
@@ -130,10 +153,7 @@ function declaresProjectedMember(context, entry, ref) {
 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);
+    if ('member' in endpoint)
+        return classSatisfiesAny(context, endpoint.member.class, accepts);
     return true;
 }
-function escapePointer(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}

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

@@ -1,8 +1,6 @@
-import { type EdgeCount, type IncidentEndpoint } from '../../../language/class/model/edge.js';
+import { type IncidentEndpoint } from '../../../language/class/model/edge.js';
 import { type SemanticIndex } from './context.js';
-/** Check Edge endpoint contracts and safe inheritance refinement. */
+/** Check safe Edge inheritance refinement; the wire and closure checks own the endpoints. */
 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

@@ -1,71 +1,25 @@
 import { Key } from '../../../addressing/index.js';
 import { compareUnicode } from '../../../addressing/ordering.js';
-import { isGraphRoot } from '../../../language/class/inheritance.js';
+import { edgeContractRefines } 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. */
+import { isCompiledEdge, classSatisfiesAny } from './context.js';
+/** Check safe Edge inheritance refinement; the wire and closure checks own the endpoints. */
 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)) {
+            if (parent !== undefined &&
+                isCompiledEdge(parent) &&
+                !edgeContractRefines(edge, parent, (candidate, accepts) => classSatisfiesAny(context, candidate, accepts))) {
                 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);
@@ -74,16 +28,3 @@ export function sameIncidentEndpoint(left, right) {
         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/callable.js

@@ -28,8 +28,6 @@ export function validateCallablePolicy(context, entry, expression, inputIndex, f
         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) {

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

@@ -1,24 +1,9 @@
-import type { PolicyCheckObject } from '../../../../language/policy/model/policy.js';
+import type { ObjectContract } from '../../../../language/policy/analysis/typing.js';
 import { type ClassRef } from '../../../../addressing/index.js';
+import { type PolicyCheckObject, type PolicyObjectRef } from '../../../../language/policy/model/policy.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;
+export declare function callableObjectContracts(context: SemanticIndex, entry: CompiledSchemaEntry, input: number, receiver: ClassRef | undefined, object: PolicyCheckObject): readonly ObjectContract[] | undefined;
+/** Resolve a referenced Policy object to its protected Class contract. */
+export declare function referenceContract(context: SemanticIndex, ref: PolicyObjectRef): ObjectContract | undefined;

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

@@ -1,4 +1,5 @@
 import { Key } from '../../../../addressing/index.js';
+import { projectedMemberClass, } from '../../../../language/policy/model/policy.js';
 import {} from '../../../model/schema.js';
 import {} from '../context.js';
 /** Resolve callable Policy objects to their protected Class contracts. */
@@ -9,24 +10,16 @@ export function callableObjectContracts(context, entry, input, receiver, object)
     if (object.kind === 'input') {
         return nodePathAccepts(entry, input, object.field).map((ref) => ({ kind: 'exact', ref }));
     }
-    const ref = object.ref;
+    const contract = referenceContract(context, object.ref);
+    return contract === undefined ? undefined : [contract];
+}
+/** Resolve a referenced Policy object to its protected Class contract. */
+export function referenceContract(context, ref) {
     if (ref.kind === 'core') {
         const node = context.core.get(Key.of(ref))?.value;
-        return node === undefined ? undefined : [{ kind: 'exact', ref: node.class }];
+        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 },
-        },
-    ];
+    return { kind: 'exact', ref: projectedMemberClass(ref) };
 }
 function nodePathAccepts(entry, input, field) {
     const root = entry.values[input]?.nodes[entry.values[input].root]?.schema;
@@ -37,9 +30,3 @@ function nodePathAccepts(entry, input, field) {
         ? 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/parity.js

@@ -1,20 +1,20 @@
-import { Key } from '../../../../addressing/index.js';
-import {} from '../../../../language/class/model/edge.js';
+import {} from '../../../../addressing/index.js';
 import { branchesOf, targetMode, isConnected, } from '../../../../language/policy/analysis/branches.js';
-import { MAX_PATTERN_DEPTH, MAX_BRANCHES, MAX_EDGES, MAX_DOMAINS, measureChecks, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, } from '../../../../language/policy/analysis/budgets.js';
-import { admittedCheckClasses, neverAdmittedClasses, } from '../../../../language/policy/analysis/checks.js';
+import { MAX_PATTERN_DEPTH, MAX_BRANCHES, MAX_EDGES, MAX_DOMAINS, measureChecks, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, policyMeasurer, } from '../../../../language/policy/analysis/budgets.js';
+import { neverAdmittedClasses, } from '../../../../language/policy/analysis/checks.js';
+import {} from '../../../../language/policy/analysis/typing.js';
 import { checksNameTheCaller, isClassRuleChecks, } from '../../../../language/policy/model/policy.js';
 import { normalizePolicyExpression } from '../../../../language/policy/normalization/normalize.js';
 import {} from '../../../model/schema.js';
 import { fail } from '../../diagnostic.js';
 import { isCompiledEdge } from '../context.js';
 import { callableObjectContracts } from './contracts.js';
-import { measureCompiledPolicy } from './measure.js';
-import { CompiledPolicyTyping } from './typing.js';
+import { compiledPolicyTyping } from './typing.js';
 /** Check Policy typing and expansion budgets against the entry’s own closure. */
 export 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);
+    const typing = compiledPolicyTyping(context, entry, normalized, origins);
+    const measurePolicy = policyMeasurer(entry.origin, normalized, (ref) => ref.origin === entry.origin);
     for (const [name, declaration] of policies) {
         const path = `/closure/${entryIndex}/definitions/policies/${declarationIndex(entry, 'policies', name)}`;
         if ('match' in declaration.expression) {
@@ -27,7 +27,7 @@ export function validatePolicyParity(context, entry, entryIndex, policies, origi
                 }
             }
         }
-        const measure = measureCompiledPolicy(entry.origin, name, normalized, new Set());
+        const measure = measurePolicy(name);
         if (measure !== undefined &&
             (measure.depth > MAX_PATTERN_DEPTH ||
                 measure.edgeCounts.length > MAX_BRANCHES ||
@@ -35,7 +35,7 @@ export function validatePolicyParity(context, entry, entryIndex, policies, origi
                 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}`);
+        const branches = typing.expandedBranches(name, `$${name}`);
         if (branches !== undefined) {
             for (const branch of branches) {
                 const mode = targetMode(branch);
@@ -67,12 +67,7 @@ export function validatePolicyParity(context, entry, entryIndex, policies, origi
                 }
             }
             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 })))) {
+                if (!typing.policyAcceptsEdgeClass(policy.name, definition)) {
                     fail(path, `${label} Policy is incompatible with an accepted Edge endpoint pair.`);
                 }
             }
@@ -121,15 +116,11 @@ function validatePolicyChecks(context, typing, entry, expression, input, receive
         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) {
+        const classes = typing.checkLeafClasses(value.check.name, contracts);
+        if (classes === undefined) {
             fail(pointer, `Named Policy is incompatible with ${SITE[site].objects}.`);
         }
-        leaves.set(value, { accepted: [...typings.keys()], admitted });
+        leaves.set(value, classes);
     };
     visit(expression, path);
     const [never] = neverAdmittedClasses(expression, leaves);

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

@@ -2,7 +2,10 @@ import { type MethodAddress } from '../../../../addressing/index.js';
 import { type PolicyExpression } from '../../../../language/policy/model/policy.js';
 import { type CompiledSchemaEntry } from '../../../model/schema.js';
 import { type SemanticIndex, type CompiledPolicy } from '../context.js';
-/** Check named Policy composition and scoped pattern references. */
+/**
+ * Check named Policy composition and scoped pattern references. The wire grammar already bounds
+ * repeats and variables and refuses empty compositions.
+ */
 export declare function validatePolicyExpression(context: SemanticIndex, entry: CompiledSchemaEntry, expression: PolicyExpression, path: string, local: ReadonlyMap<string, CompiledPolicy>): void;
 /** Require an exact executable Method declaration for a Policy reference. */
 export declare function validatePolicyMethod(context: SemanticIndex, ref: MethodAddress, path: string): void;

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

@@ -1,20 +1,20 @@
 import { Key } from '../../../../addressing/index.js';
 import { isMethodExecutable } from '../../../../language/callable/executable.js';
 import { policyVariableClass } from '../../../../language/index.js';
-import { MAX_REPEAT, MAX_VARIABLES } from '../../../../language/policy/analysis/budgets.js';
 import {} from '../../../../language/policy/model/policy.js';
 import {} from '../../../model/schema.js';
 import { fail } from '../../diagnostic.js';
 import {} from '../context.js';
-/** Check named Policy composition and scoped pattern references. */
+/**
+ * Check named Policy composition and scoped pattern references. The wire grammar already bounds
+ * repeats and variables and refuses empty compositions.
+ */
 export 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.');
@@ -31,19 +31,9 @@ function validatePattern(context, expression, path, scope, declared) {
             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;
@@ -59,8 +49,6 @@ function validatePattern(context, expression, path, scope, 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) {

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

@@ -1,28 +1,6 @@
-import { type ClassRef } from '../../../../addressing/index.js';
-import { type PatternBranch } from '../../../../language/policy/analysis/branches.js';
+import { PolicyTyping } from '../../../../language/policy/analysis/typing.js';
 import { type PolicyExpression } from '../../../../language/policy/model/policy.js';
 import { type CompiledSchemaEntry } from '../../../model/schema.js';
 import { type SemanticIndex } from '../context.js';
-import { type CompiledObjectContract, type CompiledPolicyUse } from './contracts.js';
 /** Types one entry's Policies against the Node Classes of its own closure, as source admission. */
-export declare class CompiledPolicyTyping {
-    readonly context: SemanticIndex;
-    readonly entry: CompiledSchemaEntry;
-    readonly normalized: ReadonlyMap<string, PolicyExpression>;
-    readonly allNodeClasses: readonly ClassRef[];
-    readonly concreteNodeClasses: readonly ClassRef[];
-    constructor(context: SemanticIndex, entry: CompiledSchemaEntry, normalized: ReadonlyMap<string, PolicyExpression>, origins: ReadonlySet<string>);
-    expandedBranches(name: string, visiting: Set<string>, namespace: string): readonly PatternBranch[] | undefined;
-    policyAccepts(name: string, object: CompiledObjectContract): boolean;
-    policyBranchTyping(name: string, object: CompiledObjectContract): readonly boolean[] | undefined;
-    policyAcceptsEdge(name: string, source: CompiledObjectContract, target: CompiledObjectContract): boolean;
-    concreteEndpointClasses(accepts: readonly ClassRef[]): readonly ClassRef[];
-    endpointsOverlap(left: readonly ClassRef[], right: readonly ClassRef[]): boolean;
-    branchIsTyped(branch: PatternBranch, use: CompiledPolicyUse): boolean;
-    private constraintsSatisfiable;
-    private applyInitial;
-    private applyExact;
-    private applyAnyNodeClass;
-    private applyRequirement;
-    private applyEndpoint;
-}
+export declare function compiledPolicyTyping(context: SemanticIndex, entry: CompiledSchemaEntry, normalized: ReadonlyMap<string, PolicyExpression>, origins: ReadonlySet<string>): PolicyTyping;