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

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

@@ -1,206 +1,24 @@
 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 { PolicyTyping } from '../../../../language/policy/analysis/typing.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';
+import { classSatisfiesAny, isCompiledEdge } from '../context.js';
+import { referenceContract } from './contracts.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()];
+export function compiledPolicyTyping(context, entry, normalized, origins) {
+    const nodeClasses = [...context.classes.values()]
+        .map(({ value }) => value)
+        .filter((value) => value.kind === 'node' && origins.has(value.ref.origin));
+    return new PolicyTyping({
+        normalized,
+        allNodeClasses: nodeClasses.map((value) => value.ref),
+        concreteNodeClasses: nodeClasses.filter((value) => !value.abstract).map((value) => value.ref),
+        isLocalPolicy: (ref) => ref.origin === entry.origin && ref.kind === 'policy',
+        classExtends: (candidate, required) => classSatisfiesAny(context, candidate, [required]),
+        edgeDeclaration: (ref) => {
+            const value = context.classes.get(Key.of(ref))?.value;
+            return value !== undefined && isCompiledEdge(value) ? value : undefined;
+        },
+        referenceContract: (ref) => referenceContract(context, ref),
+    });
 }

package/dist/v1/compiled/compiler/compile.js

@@ -1,3 +1,4 @@
+import { compareCodeUnits } from '../../addressing/ordering.js';
 import { isBinaryInput } from '../../language/callable/model/callable.js';
 import { inputFieldNodes } from '../../language/value/compile/fields.js';
 import { prepareValueSchema } from '../../language/value/evaluate/preparation.js';
@@ -13,7 +14,7 @@ export function compile(schema) {
         ...requireDomainClosure(schema).map(({ schema: dependency }) => dependency),
     ]
         .filter((value, index, all) => all.findIndex(({ origin }) => origin === value.origin) === index)
-        .sort((left, right) => compare(left.origin, right.origin));
+        .sort((left, right) => compareCodeUnits(left.origin, right.origin));
     const closure = Object.freeze(sources.map((source) => compileEntry(source, lookup)));
     return Object.freeze({
         format: 'astrale.dsl.compiled-schema',
@@ -46,7 +47,7 @@ function compileEntry(schema, lookup) {
     };
     const add = (contract, pointer) => addProgram(prepare(contract, pointer).program());
     const properties = (definition, pointer) => Object.entries(definition.properties)
-        .sort(([left], [right]) => compare(left, right))
+        .sort(([left], [right]) => compareCodeUnits(left, right))
         .map(([name, property]) => {
         const prepared = prepare(property.schema, `${pointer}/properties/${name}/schema`);
         const ordering = classifyPreparedOrdering(prepared);
@@ -68,7 +69,7 @@ function compileEntry(schema, lookup) {
             value: add(value.mode === 'value' ? value.schema : value.item, pointer),
         };
     const classes = Object.values(schema.classes)
-        .sort((left, right) => compare(left.ref.name, right.ref.name))
+        .sort((left, right) => compareCodeUnits(left.ref.name, right.ref.name))
         .map((definition) => {
         const pointer = `/classes/${definition.ref.name}`;
         if (definition.kind === 'edge') {
@@ -77,7 +78,7 @@ function compileEntry(schema, lookup) {
         }
         const { properties: _, methods: __, ...rest } = definition;
         const methods = Object.entries(definition.methods)
-            .sort(([left], [right]) => compare(left, right))
+            .sort(([left], [right]) => compareCodeUnits(left, right))
             .map(([name, method]) => {
             const input = add(method.input, `${pointer}/methods/${name}/input`);
             const fields = inputFieldNodes(values[input]);
@@ -98,7 +99,7 @@ function compileEntry(schema, lookup) {
         return { ...rest, properties: properties(definition, pointer), methods };
     });
     const functions = Object.values(schema.functions)
-        .sort((left, right) => compare(left.ref.name, right.ref.name))
+        .sort((left, right) => compareCodeUnits(left.ref.name, right.ref.name))
         .map((definition) => {
         const binary = isBinaryInput(definition.input);
         const inputIndex = add(binary ? definition.input.metadata : definition.input, binary
@@ -142,6 +143,3 @@ function compileEntry(schema, lookup) {
         patterns: Object.freeze([...patternIndices.keys()]),
     });
 }
-function compare(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}

package/dist/v1/compiled/diagnostic.js

@@ -1,9 +1,8 @@
+import { formatDiagnostics } from '../language/validation/diagnostic.js';
 export class CompiledSchemaError extends Error {
     diagnostics;
     constructor(diagnostics, options) {
-        super(diagnostics
-            .map(({ code, pointer, message }) => `${pointer || '/'} [${code}] ${message}`)
-            .join('\n'), options);
+        super(formatDiagnostics(diagnostics), options);
         this.name = 'CompiledSchemaError';
         this.diagnostics = Object.freeze([...diagnostics]);
     }

package/dist/v1/compiled/loader/load.d.ts

@@ -1,9 +1,10 @@
+import type { Domain } from '../../domain/model/domain.js';
 import type { CompiledSchema, DomainOfCompiled } from '../model/schema.js';
 /** Load admitted compiled data through the one resolved Domain constructor. */
 export declare function load<const Input extends CompiledSchema>(input: Input): DomainOfCompiled<Input>;
-export declare function load(input: unknown): import('../../domain/model/domain.js').Domain;
+export declare function load(input: unknown): Domain;
 /**
  * Realize compiled material whose exact embedded bytes were already proven by generated build code.
  * External bytes and caller-provided values must continue through {@link load}.
  */
-export declare function realize(compiled: CompiledSchema): import('../../domain/model/domain.js').Domain;
+export declare function realize(compiled: CompiledSchema): Domain;

package/dist/v1/compiled/loader/load.js

@@ -1,10 +1,11 @@
 import { Key, MethodKey, PropertyKey as PropertyKeyValue } from '../../addressing/index.js';
 import { compareUnicode } from '../../addressing/ordering.js';
 import { createDomain } from '../../domain/create.js';
-import { combineDomainValidation, createDomainValidation, unknownInputField, } from '../../domain/validation/create.js';
+import { createDomainValidation, unknownInputField } from '../../domain/validation/create.js';
 import { bindValueProgram } from '../../language/value/compile/load.js';
 import { validateValueProgram } from '../../language/value/evaluate/program.js';
 import { acceptCompiledSchema } from '../admission/accept.js';
+import { schemaOf, sourceFunction, sourceMethod } from '../admission/revision.js';
 export function load(input) {
     return realize(acceptCompiledSchema(input));
 }
@@ -14,13 +15,14 @@ export function load(input) {
  */
 export function realize(compiled) {
     const entries = new Map(compiled.closure.map((entry) => [entry.origin, loadEntry(entry)]));
+    const loaded = [...entries.values()];
     const root = entries.get(compiled.root.origin);
     if (root === undefined || root.entry.revision !== compiled.root.revision) {
         throw new TypeError('Compiled root is absent or has the wrong revision.');
     }
     return createDomain({
         root: compiled.root,
-        entries: Object.freeze([...entries.values()]
+        entries: Object.freeze(loaded
             .map(({ entry, definitions }) => Object.freeze({
             origin: entry.origin,
             revision: entry.revision,
@@ -29,7 +31,8 @@ export function realize(compiled) {
             coreEdges: entry.facts.core,
         }))
             .sort((left, right) => compareUnicode(left.origin, right.origin))),
-        validation: combineDomainValidation([...entries.values()].map(({ validation }) => validation)),
+        // Closure admission refuses a duplicate Definition, so no two entries share a key.
+        validation: createDomainValidation(new Map(loaded.flatMap(({ properties }) => [...properties])), new Map(loaded.flatMap(({ callables }) => [...callables]))),
     });
 }
 function loadEntry(entry) {
@@ -52,13 +55,13 @@ function loadEntry(entry) {
         const methods = Object.fromEntries(compiled.methods.map((method) => {
             const key = MethodKey.of(compiled.ref, method.name);
             callablePrograms.set(key, callableProgram(method));
-            return [method.name, loadMethod(entry, method)];
+            return [method.name, Object.freeze(sourceMethod(entry, method))];
         }));
         return Object.freeze({ ...definition, properties, methods });
     });
     const functions = entry.definitions.functions.map((compiled) => {
         callablePrograms.set(Key.of(compiled.ref), callableProgram(compiled));
-        return loadFunction(entry, compiled);
+        return Object.freeze(sourceFunction(entry, compiled));
     });
     return {
         entry,
@@ -69,46 +72,9 @@ function loadEntry(entry) {
             ...entry.definitions.views,
             ...entry.definitions.core,
         ]),
-        validation: programValidation(entry.values.map((value) => bindValueProgram(value, entry.patterns)), propertyPrograms, propertyOrdering, callablePrograms),
+        ...programValidation(entry.values.map((value) => bindValueProgram(value, entry.patterns)), propertyPrograms, propertyOrdering, callablePrograms),
     };
 }
-function loadMethod(entry, value) {
-    const { name: _, input, fields: __, output, ...definition } = value;
-    return Object.freeze({
-        ...definition,
-        input: schemaOf(entry, input),
-        output: loadOutput(entry, output),
-    });
-}
-function loadFunction(entry, value) {
-    const { input, fields: _, output, ...definition } = value;
-    return Object.freeze({
-        ...definition,
-        input: typeof input === 'number'
-            ? schemaOf(entry, input)
-            : {
-                mode: 'binary',
-                metadata: schemaOf(entry, input.metadata),
-                maximumBytes: input.maximumBytes,
-            },
-        output: loadOutput(entry, output),
-    });
-}
-function loadOutput(entry, output) {
-    if (output.mode === 'binary')
-        return output;
-    const schema = schemaOf(entry, output.value);
-    return output.mode === 'value'
-        ? { mode: 'value', schema }
-        : { mode: 'stream', item: schema };
-}
-function schemaOf(entry, index) {
-    const program = entry.values[index];
-    const root = program?.nodes[program.root];
-    if (root === undefined)
-        throw new TypeError(`Compiled Value program ${index} is absent.`);
-    return root.schema;
-}
 function callableProgram(value) {
     return {
         input: typeof value.input === 'number' ? value.input : value.input.metadata,
@@ -151,5 +117,5 @@ function programValidation(programs, properties, propertyOrdering, callables) {
             validateOutput: (value) => output === undefined ? [] : validateValueProgram(output, value),
         }));
     }
-    return createDomainValidation(propertyValidation, callableValidation);
+    return { properties: propertyValidation, callables: callableValidation };
 }

package/dist/v1/domain/create.js

@@ -1,4 +1,5 @@
 import { Key, MethodKey } from '../addressing/index.js';
+import { compareCodeUnits } from '../addressing/ordering.js';
 import { frozenRecord } from './namespace/member-collection.js';
 import { createClasses } from './projection/classes.js';
 const admittedDomains = new WeakSet();
@@ -43,7 +44,7 @@ export function createDomain(input) {
         const visibleOrigins = new Set(visibleEntries.map(({ origin }) => origin));
         const local = [...definitionsByKey.values()]
             .filter(({ ref }) => ref.origin === entry.origin)
-            .sort((left, right) => compare(left.key, right.key));
+            .sort((left, right) => compareCodeUnits(left.key, right.key));
         const classes = namespace(local, 'class');
         const functions = namespace(local, 'function');
         const policies = namespace(local, 'policy');
@@ -86,7 +87,7 @@ export function createDomain(input) {
             revision: entry.revision,
             closure: Object.freeze(visibleEntries
                 .map(({ origin, revision }) => Object.freeze({ origin, revision }))
-                .sort((left, right) => compare(left.origin, right.origin))),
+                .sort((left, right) => compareCodeUnits(left.origin, right.origin))),
             dependencies,
             classes,
             functions,
@@ -250,6 +251,3 @@ function isViewDefinition(value) {
 function isCoreDefinition(value) {
     return value.ref.kind === 'core';
 }
-function compare(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}

package/dist/v1/domain/namespace/member-collection.js

@@ -1,9 +1,10 @@
 import { PropertyKey as PropertyKeyValue } from '../../addressing/index.js';
+import { compareCodeUnits } from '../../addressing/ordering.js';
 import { createPropertyValues } from '../../language/class/property-values.js';
 const PROPERTY_OPERATIONS = new Set(['byKey', 'get', 'from']);
 const METHOD_OPERATIONS = new Set(['byKey', 'get']);
 export function createPropertyCollection(values) {
-    const ordered = [...values].sort((left, right) => compare(left.key, right.key));
+    const ordered = [...values].sort((left, right) => compareCodeUnits(left.key, right.key));
     const byKey = frozenRecord(ordered.map((value) => [value.key, value]));
     const named = uniqueNames(ordered);
     const collection = {
@@ -39,7 +40,7 @@ export function createPropertyCollection(values) {
     return Object.freeze(collection);
 }
 export function createMethodCollection(values) {
-    const ordered = [...values].sort((left, right) => compare(left.key, right.key));
+    const ordered = [...values].sort((left, right) => compareCodeUnits(left.key, right.key));
     const byKey = frozenRecord(ordered.map((value) => [value.key, value]));
     const named = uniqueNames(ordered);
     const collection = {
@@ -71,11 +72,8 @@ function installShortcuts(target, named, reserved) {
 }
 export function frozenRecord(entries) {
     const output = Object.create(null);
-    for (const [key, value] of [...entries].sort(([left], [right]) => compare(left, right))) {
+    for (const [key, value] of [...entries].sort(([left], [right]) => compareCodeUnits(left, right))) {
         Object.defineProperty(output, key, { enumerable: true, value });
     }
     return Object.freeze(output);
 }
-function compare(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}

package/dist/v1/domain/validation/create.d.ts

@@ -16,5 +16,4 @@ export interface CallableValidation {
 }
 /** Build the one Domain-level router shared by source resolution and compiled loading. */
 export declare function createDomainValidation(properties: ReadonlyMap<PropertyKey, PropertyValidation>, callables: ReadonlyMap<Key.Callable, CallableValidation>): DomainValidation;
-export declare function combineDomainValidation(values: readonly DomainValidation[]): DomainValidation;
 export declare function unknownInputField(field: string): readonly Diagnostic[];

package/dist/v1/domain/validation/create.js

@@ -32,41 +32,6 @@ export function createDomainValidation(properties, callables) {
     };
     return Object.freeze(validation);
 }
-export function combineDomainValidation(values) {
-    const validation = {
-        propertyExists: (key) => values.some((value) => value.propertyExists(key)),
-        property(key, input) {
-            const owner = values.find((value) => value.propertyExists(key));
-            return owner === undefined ? unknownTarget('Property', key) : owner.property(key, input);
-        },
-        propertyProgram(key) {
-            const owner = values.find((value) => value.propertyExists(key));
-            if (owner === undefined)
-                throw new TypeError(`Property ${key} is absent.`);
-            return owner.propertyProgram(key);
-        },
-        propertyOrdering: (key) => values.find((value) => value.propertyExists(key))?.propertyOrdering(key),
-        callableExists: (key) => values.some((value) => value.callableExists(key)),
-        callableInput(key, input) {
-            const owner = values.find((value) => value.callableExists(key));
-            return owner === undefined ? unknownTarget('Callable', key) : owner.callableInput(key, input);
-        },
-        callableFields: (key) => values.find((value) => value.callableExists(key))?.callableFields(key),
-        callableInputField(key, field, input) {
-            const owner = values.find((value) => value.callableExists(key));
-            return owner === undefined
-                ? unknownTarget('Callable', key)
-                : owner.callableInputField(key, field, input);
-        },
-        callableOutput(key, output) {
-            const owner = values.find((value) => value.callableExists(key));
-            return owner === undefined
-                ? unknownTarget('Callable', key)
-                : owner.callableOutput(key, output);
-        },
-    };
-    return Object.freeze(validation);
-}
 export function unknownInputField(field) {
     return [
         Object.freeze({

package/dist/v1/language/class/inheritance.d.ts

@@ -1,5 +1,6 @@
 import type { ClassRef } from '../../addressing/index.js';
 import type { ClassKind, Inheritance } from './model/class.js';
+import type { EdgeContract, EdgeCount } from './model/edge.js';
 /** A Class as satisfaction reads it, shared by source, compiled and resolved Class admission. */
 export interface ClassAncestry {
     readonly ref: ClassRef;
@@ -23,3 +24,20 @@ export declare function inheritanceOf(declaration: {
 export declare function admitsForeignSubclass(declaration: {
     readonly inheritance?: Inheritance;
 }): boolean;
+/**
+ * Whether `child` safely refines its parent Edge contract `parent`: same orientation, at least the
+ * parent's constraints, and endpoints whose accepted Classes `satisfies` one the paired parent
+ * endpoint accepts, within its count. Undirected endpoints may pair in either order.
+ */
+export declare function edgeContractRefines(child: EdgeContract, parent: EdgeContract & Pick<ClassAncestry, 'ref' | 'kind'>, satisfies: (candidate: ClassRef, accepts: readonly ClassRef[]) => boolean): boolean;
+/** Interpret an Edge count as inclusive degree bounds. */
+export declare function countBounds(value: EdgeCount): readonly [number, number];
+/** Whether Edges of one Class, read from source to target, close a cycle (`acyclic` forbids it). */
+export declare function hasDirectedCycle(edges: readonly {
+    readonly source: {
+        readonly key: string;
+    };
+    readonly target: {
+        readonly key: string;
+    };
+}[]): boolean;

package/dist/v1/language/class/inheritance.js

@@ -36,3 +36,76 @@ export function inheritanceOf(declaration) {
 export function admitsForeignSubclass(declaration) {
     return inheritanceOf(declaration) === 'open';
 }
+/**
+ * Whether `child` safely refines its parent Edge contract `parent`: same orientation, at least the
+ * parent's constraints, and endpoints whose accepted Classes `satisfies` one the paired parent
+ * endpoint accepts, within its count. Undirected endpoints may pair in either order.
+ */
+export function edgeContractRefines(child, parent, satisfies) {
+    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;
+    const endpointRefines = (childEndpoint, parentEndpoint) => childEndpoint.accepts.every((accepted) => satisfies(accepted, parentEndpoint.accepts));
+    if (child.orientation === 'directed' && parent.orientation === 'directed') {
+        return (endpointRefines(child.endpoints.source, parent.endpoints.source) &&
+            countRefines(child.endpoints.source.outgoing, parent.endpoints.source.outgoing) &&
+            endpointRefines(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 refines = (childIndex, parentIndex) => endpointRefines(child.endpoints[childIndex], parent.endpoints[parentIndex]) &&
+        countRefines(child.endpoints[childIndex].incident, parent.endpoints[parentIndex].incident);
+    const direct = refines(0, 0) && refines(1, 1);
+    if (direct)
+        return true;
+    return refines(0, 1) && refines(1, 0);
+}
+function countRefines(child, parent) {
+    const [childMinimum, childMaximum] = countBounds(child);
+    const [parentMinimum, parentMaximum] = countBounds(parent);
+    return childMinimum >= parentMinimum && childMaximum <= parentMaximum;
+}
+/** 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];
+    }
+}
+/** Whether Edges of one Class, read from source to target, close a cycle (`acyclic` forbids it). */
+export function hasDirectedCycle(edges) {
+    const outgoing = new Map();
+    for (const edge of edges) {
+        const targets = outgoing.get(edge.source.key) ?? [];
+        targets.push(edge.target.key);
+        outgoing.set(edge.source.key, targets);
+    }
+    const visiting = new Set();
+    const visited = new Set();
+    const visit = (key) => {
+        if (visiting.has(key))
+            return true;
+        if (visited.has(key))
+            return false;
+        visiting.add(key);
+        for (const target of outgoing.get(key) ?? [])
+            if (visit(target))
+                return true;
+        visiting.delete(key);
+        visited.add(key);
+        return false;
+    };
+    return [...outgoing.keys()].some(visit);
+}

package/dist/v1/language/class/property-values.js

@@ -1,6 +1,7 @@
 import { acceptPropertyRoot } from '../../../value/accept.js';
 import { isImmutableSnapshot } from '../../../value/immutable.optimization.js';
 import { PropertyKey as admitPropertyKey } from '../../addressing/index.js';
+import { compareCodeUnits } from '../../addressing/ordering.js';
 export function acceptPropertyValues(input, pointer = '') {
     const admitted = acceptPropertyRoot(input);
     if (admitted === null || typeof admitted !== 'object' || Array.isArray(admitted)) {
@@ -10,7 +11,7 @@ export function acceptPropertyValues(input, pointer = '') {
 }
 export function createPropertyValues(entries) {
     const output = Object.create(null);
-    for (const [key, value] of [...entries].sort(([left], [right]) => compare(left, right))) {
+    for (const [key, value] of [...entries].sort(([left], [right]) => compareCodeUnits(left, right))) {
         Object.defineProperty(output, key, { enumerable: true, value: freeze(value) });
     }
     return Object.freeze(output);
@@ -28,6 +29,3 @@ function freeze(value) {
         freeze(member);
     return Object.freeze(value);
 }
-function compare(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}