@astrale-os/kernel-dsl 0.2.0-beta.8 → 0.2.0

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

@@ -0,0 +1,139 @@
+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 { 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';
+/** 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);
+    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 (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.
+                validatePolicyChecks(context, typing, entry, policy, -1, definition.ref, path, 'class');
+                continue;
+            }
+            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 (typeof method.policy === 'object') {
+                    validatePolicyChecks(context, typing, entry, method.policy, method.input, method.static ? undefined : definition.ref, `/closure/${entryIndex}/definitions/classes/${classIndex}/methods/${methodIndex}/policy`, 'callable');
+                }
+            }
+        }
+    }
+    for (const [functionIndex, callable] of entry.definitions.functions.entries()) {
+        if (typeof callable.policy === 'object') {
+            validatePolicyChecks(context, typing, entry, callable.policy, typeof callable.input === 'number' ? callable.input : callable.input.metadata, undefined, `/closure/${entryIndex}/definitions/functions/${functionIndex}/policy`, 'callable');
+        }
+    }
+}
+function declarationIndex(entry, kind, name) {
+    return entry.definitions[kind].findIndex(({ ref }) => ref.name === name);
+}
+/** How a refusal names the checks of each site and the contract of their objects. */
+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) {
+    if (!checksNameTheCaller(expression)) {
+        fail(path, `${SITE[site].checks} must check a Policy on every branch: sameNode alone names no caller.`);
+    }
+    const measure = measureChecks(expression);
+    if (measure.depth > MAX_CHECK_DEPTH ||
+        measure.branches > MAX_BRANCHES ||
+        measure.leaves > MAX_CHECK_LEAVES) {
+        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)
+            return;
+        if (!('check' in value)) {
+            const children = 'allOf' in value ? value.allOf : value.anyOf;
+            children.forEach((child, index) => visit(child, `${pointer}/${index}`));
+            return;
+        }
+        const contracts = callableObjectContracts(context, entry, input, receiver, value.object);
+        if (contracts === undefined)
+            return;
+        const typings = new Map(contracts.map((contract) => [
+            contract.kind === 'exact' ? Key.of(contract.ref) : 'default',
+            typing.policyBranchTyping(value.check.name, contract),
+        ]));
+        const admitted = admittedCheckClasses(typings);
+        if (admitted === undefined) {
+            fail(pointer, `Named Policy is incompatible with ${SITE[site].objects}.`);
+        }
+        leaves.set(value, { accepted: [...typings.keys()], admitted });
+    };
+    visit(expression, path);
+    const [never] = neverAdmittedClasses(expression, leaves);
+    if (never !== undefined) {
+        fail(path, `${SITE[site].checks} can never admit ${never[0]} of Class ${never[1]}.`);
+    }
+}

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

@@ -0,0 +1,8 @@
+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. */
+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

@@ -0,0 +1,78 @@
+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. */
+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.');
+    }
+}
+function validatePattern(context, expression, path, scope, declared) {
+    if ('sameNode' in expression) {
+        validatePolicyTerm(context, expression.sameNode.left, `${path}/sameNode/left`, scope);
+        validatePolicyTerm(context, expression.sameNode.right, `${path}/sameNode/right`, scope);
+        return;
+    }
+    if ('source' in expression) {
+        if (context.classes.get(Key.of(expression.class))?.value.kind !== 'edge')
+            fail(`${path}/class`, 'Policy pattern Class must resolve to an Edge Class.');
+        validatePolicyTerm(context, expression.source, `${path}/source`, scope);
+        validatePolicyTerm(context, expression.target, `${path}/target`, scope);
+        if (expression.repeat !== undefined &&
+            (!Number.isInteger(expression.repeat.min) ||
+                !Number.isInteger(expression.repeat.max) ||
+                expression.repeat.min < 0 ||
+                expression.repeat.max < expression.repeat.min ||
+                expression.repeat.max > MAX_REPEAT))
+            fail(`${path}/repeat`, 'Policy repeat is outside the V1 bounds.');
+        return;
+    }
+    if ('exists' in expression) {
+        if (expression.exists.nodes.length > MAX_VARIABLES) {
+            fail(`${path}/exists/nodes`, 'Policy exists exceeds the V1 variable budget.');
+        }
+        const nested = new Set(scope);
+        for (const [index, node] of expression.exists.nodes.entries()) {
+            const id = node.variable.id;
+            if (declared.has(id) || nested.has(id))
+                fail(`${path}/exists/nodes/${index}/variable/id`, 'Policy variable IDs must be globally unique and cannot shadow.');
+            declared.add(id);
+            nested.add(id);
+            const classRef = policyVariableClass(node);
+            if (classRef !== undefined && context.classes.get(Key.of(classRef))?.value.kind !== 'node')
+                fail(`${path}/exists/nodes/${index}/${'class' in node ? 'class' : 'selector/class'}`, 'Policy variable Class must resolve to a Node Class.');
+        }
+        validatePattern(context, expression.exists.where, `${path}/exists/where`, nested, declared);
+        return;
+    }
+    const values = 'allOf' in expression ? expression.allOf : expression.anyOf;
+    if (values.length === 0)
+        fail(path, 'Policy pattern composition must be non-empty.');
+    values.forEach((value, index) => validatePattern(context, value, `${path}/${index}`, scope, declared));
+}
+function validatePolicyTerm(context, term, path, scope) {
+    if (term.kind === 'ref' && term.ref.kind === 'method')
+        validatePolicyMethod(context, term.ref, `${path}/ref`);
+    if (term.kind === 'variable' && !scope.has(term.id))
+        fail(path, 'Policy variable is outside its declaring scope.');
+}
+/** Require an exact executable Method declaration for a Policy reference. */
+export function validatePolicyMethod(context, ref, path) {
+    const owner = context.classes.get(Key.of(ref.owner))?.value;
+    const method = owner?.kind === 'node' ? owner.methods.find((method) => method.name === ref.name) : undefined;
+    if (method === undefined || !isMethodExecutable(owner, method))
+        fail(path, 'Policy Method ref must name an exact concrete Method declaration.');
+}

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

@@ -0,0 +1,28 @@
+import { type ClassRef } from '../../../../addressing/index.js';
+import { type PatternBranch } from '../../../../language/policy/analysis/branches.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;
+}

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

@@ -0,0 +1,206 @@
+import { Key } from '../../../../addressing/index.js';
+import { compareUnicode } from '../../../../addressing/ordering.js';
+import { branchesOf, branchProduct, capBranches, targetMode, termKey, } from '../../../../language/policy/analysis/branches.js';
+import {} from '../../../../language/policy/model/policy.js';
+import {} from '../../../model/schema.js';
+import { classSatisfiesAny } from '../context.js';
+import { compiledTargetContract, callableObjectContracts, } from './contracts.js';
+import { CompiledUnionFind } from './equality.js';
+import { compiledEdgeAlternatives } from './variants.js';
+/** Types one entry's Policies against the Node Classes of its own closure, as source admission. */
+export class CompiledPolicyTyping {
+    context;
+    entry;
+    normalized;
+    allNodeClasses;
+    concreteNodeClasses;
+    constructor(context, entry, normalized, origins) {
+        this.context = context;
+        this.entry = entry;
+        this.normalized = normalized;
+        const nodeClasses = [...context.classes.values()].filter(({ value }) => value.kind === 'node' && origins.has(value.ref.origin));
+        this.allNodeClasses = nodeClasses.map(({ value }) => value.ref);
+        this.concreteNodeClasses = nodeClasses
+            .filter(({ value }) => !value.abstract)
+            .map(({ value }) => value.ref);
+    }
+    expandedBranches(name, visiting, namespace) {
+        if (visiting.has(name))
+            return undefined;
+        const declaration = this.normalized.get(name);
+        if (declaration === undefined)
+            return undefined;
+        if ('match' in declaration)
+            return branchesOf(declaration.match, namespace);
+        const nested = new Set(visiting);
+        nested.add(name);
+        const refs = 'allOf' in declaration ? declaration.allOf : declaration.anyOf;
+        const children = [];
+        for (const [index, ref] of refs.entries()) {
+            if (ref.origin !== this.entry.origin || ref.kind !== 'policy')
+                return undefined;
+            const expanded = this.expandedBranches(ref.name, nested, `${namespace}/${index}:${ref.name}`);
+            if (expanded === undefined)
+                return undefined;
+            children.push(expanded);
+        }
+        return 'allOf' in declaration ? branchProduct(children) : capBranches(children.flat());
+    }
+    policyAccepts(name, object) {
+        return this.policyBranchTyping(name, object)?.every(Boolean) ?? false;
+    }
+    policyBranchTyping(name, object) {
+        const branches = this.expandedBranches(name, new Set(), `$use:${name}`);
+        return branches?.map((branch) => this.branchIsTyped(branch, { kind: 'object', object }));
+    }
+    policyAcceptsEdge(name, source, target) {
+        const branches = this.expandedBranches(name, new Set(), `$edge-use:${name}`);
+        return (branches !== undefined &&
+            branches.every((branch) => this.branchIsTyped(branch, { kind: 'edge', source, target })));
+    }
+    concreteEndpointClasses(accepts) {
+        return this.concreteNodeClasses.filter((candidate) => classSatisfiesAny(this.context, candidate, accepts));
+    }
+    endpointsOverlap(left, right) {
+        const seed = [{ kind: 'open', requirements: [] }];
+        return this.applyEndpoint(this.applyEndpoint(seed, left), right).length > 0;
+    }
+    branchIsTyped(branch, use) {
+        if (targetMode(branch) !== use.kind)
+            return false;
+        return compiledEdgeAlternatives(branch.edges, this).some((variants) => this.constraintsSatisfiable(branch, variants, use));
+    }
+    constraintsSatisfiable(branch, variants, use) {
+        const terms = new Set(use.kind === 'object' ? ['subject', 'object'] : ['subject', 'source', 'target']);
+        for (const key of branch.variables.keys())
+            terms.add(key);
+        for (const key of branch.terms.keys())
+            terms.add(key);
+        for (const edge of branch.edges) {
+            terms.add(termKey(edge.pattern.source, edge.namespace));
+            terms.add(termKey(edge.pattern.target, edge.namespace));
+        }
+        const union = new CompiledUnionFind(terms);
+        for (const [left, right] of branch.equalities)
+            union.join(left, right);
+        for (const variant of variants)
+            for (const [left, right] of variant.equalities)
+                union.join(left, right);
+        const constraints = new Map();
+        for (const variant of variants) {
+            for (const [term, accepts] of variant.constraints) {
+                const root = union.find(term);
+                const values = constraints.get(root) ?? [];
+                values.push(accepts);
+                constraints.set(root, values);
+            }
+        }
+        const groups = new Map();
+        for (const term of terms) {
+            const root = union.find(term);
+            const values = groups.get(root) ?? [];
+            values.push(term);
+            groups.set(root, values);
+        }
+        for (const [root, members] of groups) {
+            let candidates = [{ kind: 'open', requirements: [] }];
+            for (const member of members) {
+                candidates = this.applyInitial(candidates, member, branch, use);
+                if (candidates.length === 0)
+                    return false;
+            }
+            for (const endpoint of constraints.get(root) ?? []) {
+                candidates = this.applyEndpoint(candidates, endpoint);
+                if (candidates.length === 0)
+                    return false;
+            }
+        }
+        return true;
+    }
+    applyInitial(candidates, term, branch, use) {
+        if (term === 'subject')
+            return this.applyAnyNodeClass(candidates);
+        const contract = compiledTargetContract(term, use);
+        if (contract !== undefined) {
+            return contract.kind === 'exact'
+                ? this.applyExact(candidates, contract.ref)
+                : uniqueCompiledCandidates(this.allNodeClasses.flatMap((ref) => this.applyExact(candidates, ref)));
+        }
+        const referenced = branch.terms.get(term);
+        if (referenced?.kind === 'ref') {
+            const contract = callableObjectContracts(this.context, this.entry, 0, undefined, referenced)?.[0];
+            return contract?.kind === 'exact' ? this.applyExact(candidates, contract.ref) : [];
+        }
+        const selector = branch.variables.get(term);
+        if (selector === undefined)
+            return [];
+        if (selector.kind === 'exact')
+            return this.applyExact(candidates, selector.class);
+        if (selector.kind === 'any')
+            return candidates;
+        return this.applyRequirement(candidates, selector.class);
+    }
+    applyExact(candidates, exact) {
+        return uniqueCompiledCandidates(candidates.flatMap((candidate) => {
+            if (candidate.kind === 'exact')
+                return Key.of(candidate.ref) === Key.of(exact) ? [candidate] : [];
+            return candidate.requirements.every((required) => classSatisfiesAny(this.context, exact, [required]))
+                ? [{ kind: 'exact', ref: exact }]
+                : [];
+        }));
+    }
+    applyAnyNodeClass(candidates) {
+        return uniqueCompiledCandidates(candidates.flatMap((candidate) => candidate.kind === 'exact'
+            ? [candidate]
+            : this.allNodeClasses
+                .filter((ref) => candidate.requirements.every((required) => classSatisfiesAny(this.context, ref, [required])))
+                .map((ref) => ({ kind: 'exact', ref }))));
+    }
+    applyRequirement(candidates, required) {
+        const result = [];
+        for (const candidate of candidates) {
+            if (candidate.kind === 'exact') {
+                if (classSatisfiesAny(this.context, candidate.ref, [required]))
+                    result.push(candidate);
+            }
+            else {
+                result.push({
+                    kind: 'open',
+                    requirements: uniqueClassRefs([...candidate.requirements, required]),
+                });
+            }
+        }
+        return uniqueCompiledCandidates(result);
+    }
+    applyEndpoint(candidates, accepts) {
+        const result = [];
+        for (const candidate of candidates) {
+            if (candidate.kind === 'exact') {
+                if (classSatisfiesAny(this.context, candidate.ref, accepts))
+                    result.push(candidate);
+            }
+            else {
+                for (const accept of accepts) {
+                    result.push({
+                        kind: 'open',
+                        requirements: uniqueClassRefs([...candidate.requirements, accept]),
+                    });
+                }
+            }
+        }
+        return uniqueCompiledCandidates(result);
+    }
+}
+function 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()];
+}

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

@@ -0,0 +1,10 @@
+import type { CompiledPolicyTyping } from './typing.js';
+import { type ClassRef } from '../../../../addressing/index.js';
+import { type PatternEdgeUse } from '../../../../language/policy/analysis/branches.js';
+/** One possible combination of endpoint constraints and term equalities. */
+export interface CompiledEdgeVariant {
+    readonly constraints: readonly (readonly [string, readonly ClassRef[]])[];
+    readonly equalities: readonly (readonly [string, string])[];
+}
+/** Enumerate satisfiable endpoint variants for a branch’s Edge uses. */
+export declare function compiledEdgeAlternatives(edges: readonly PatternEdgeUse[], typing: CompiledPolicyTyping): readonly (readonly CompiledEdgeVariant[])[];

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

@@ -0,0 +1,65 @@
+import { Key } from '../../../../addressing/index.js';
+import { compareUnicode } from '../../../../addressing/ordering.js';
+import {} from '../../../../language/class/model/edge.js';
+import { termKey } from '../../../../language/policy/analysis/branches.js';
+import { isCompiledEdge } from '../context.js';
+/** Enumerate satisfiable endpoint variants for a branch’s Edge uses. */
+export 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()];
+}

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

@@ -1,4 +1,4 @@
-import type { CompiledSchema } from '../model/schema.js';
+import { type CompiledSchema } from '../model/schema.js';
 /**
  * Re-admit contextual Language laws after the portable compiled grammar and
  * exact closure have been established. This module deliberately depends only