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

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 { 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 { checksNameTheCaller, isClassRuleChecks, } from '../../../../language/policy/model/policy.js';
+import { exceededLimits, measureChecks, policyMeasurer, } from '../../../../language/policy/analysis/budgets.js';
+import { neverAdmittedClasses, } from '../../../../language/policy/analysis/checks.js';
+import {} from '../../../../language/policy/analysis/typing.js';
+import { CLASS_OPERATIONS, 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 { 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,15 +27,11 @@ export function validatePolicyParity(context, entry, entryIndex, policies, origi
                 }
             }
         }
-        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)) {
+        const measure = measurePolicy(name);
+        if (measure !== undefined && exceededLimits(measure).length > 0) {
             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);
@@ -50,33 +46,25 @@ export function validatePolicyParity(context, entry, entryIndex, policies, origi
         }
     }
     for (const [classIndex, definition] of entry.definitions.classes.entries()) {
-        for (const operation of ['read', 'traverse']) {
+        const edge = isCompiledEdge(definition) ? definition : undefined;
+        for (const operation of CLASS_OPERATIONS) {
             const policy = definition.policies[operation];
             if (typeof policy !== 'object')
                 continue;
             const path = `/closure/${entryIndex}/definitions/classes/${classIndex}/policies/${operation}`;
             if (isClassRuleChecks(policy)) {
-                // The wire admits rules only on a Node Class and only over `self` and `ref` objects.
-                if (!checksNameTheCaller(policy))
-                    fail(path, 'Every branch of a Class rule must check a Policy: sameNode alone names no caller.');
-                validatePolicyChecks(context, typing, entry, policy, -1, definition.ref, path, 'class');
+                // The wire admits rules only over `self` and `ref` objects, and `ref` alone to create a Node.
+                validatePolicyChecks(context, typing, entry, policy, -1, definition.ref, path, 'class', edge);
                 continue;
             }
-            const label = operation === 'read' ? 'Read' : 'Traverse';
+            const label = `${operation[0].toUpperCase()}${operation.slice(1)}`;
             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.`);
-                }
+            else if (edge !== undefined && !typing.policyAcceptsEdgeClass(policy.name, edge)) {
+                fail(path, `${label} Policy is incompatible with an accepted Edge endpoint pair.`);
             }
         }
         if (definition.kind === 'node') {
@@ -101,34 +89,43 @@ const SITE = {
     callable: { checks: 'Callable Policy checks', objects: 'the callable object contract' },
     class: { checks: 'Class rule checks', objects: 'the Class rule object contract' },
 };
-function validatePolicyChecks(context, typing, entry, expression, input, receiver, path, site) {
-    const measure = measureChecks(expression);
-    if (measure.depth > MAX_CHECK_DEPTH ||
-        measure.branches > MAX_BRANCHES ||
-        measure.leaves > MAX_CHECK_LEAVES) {
+function validatePolicyChecks(context, typing, entry, expression, input, receiver, path, site, edge) {
+    if (!checksNameTheCaller(expression)) {
+        fail(path, `${SITE[site].checks} must check a Policy on every branch: sameNode alone names no caller.`);
+    }
+    if (exceededLimits(measureChecks(expression)).length > 0) {
         fail(path, `${SITE[site].checks} exceed the V1 depth, branch, or leaf budget.`);
     }
     const leaves = new Map();
     const visit = (value, pointer) => {
-        if ('sameNode' in value)
+        if ('sameNode' in value) {
+            // `self` is an Edge in an Edge Class rule, and sameNode compares Nodes.
+            if (edge !== undefined &&
+                (value.sameNode.left.kind === 'self' || value.sameNode.right.kind === 'self'))
+                fail(pointer, 'sameNode compares Nodes: self is an Edge here.');
             return;
+        }
         if (!('check' in value)) {
             const children = 'allOf' in value ? value.allOf : value.anyOf;
             children.forEach((child, index) => visit(child, `${pointer}/${index}`));
             return;
         }
+        if (edge !== undefined && value.object.kind === 'self') {
+            // An Edge is checked as an Edge Class Policy is: over every concrete endpoint pair.
+            if (!typing.policyAcceptsEdgeClass(value.check.name, edge))
+                fail(pointer, 'Named Policy is incompatible with an accepted Edge endpoint pair.');
+            const name = Key.of(edge.ref);
+            leaves.set(value, { accepted: [name], admitted: new Set([name]) });
+            return;
+        }
         const contracts = callableObjectContracts(context, entry, input, receiver, value.object);
         if (contracts === undefined)
             return;
-        const typings = new Map(contracts.map((contract) => [
-            contract.kind === 'exact' ? Key.of(contract.ref) : 'default',
-            typing.policyBranchTyping(value.check.name, contract),
-        ]));
-        const admitted = admittedCheckClasses(typings);
-        if (admitted === undefined) {
+        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;