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

package/dist/v1/bundle/codec.js

@@ -1,17 +1,15 @@
 import { accept as acceptJsonValue, BoundaryError as JsonBoundaryError, json, } from '@astrale-os/kernel-dsl/value';
-import { dependencyLimits } from '../addressing/domain-dependency.js';
 import { compareUnicode } from '../addressing/ordering.js';
+import { limits } from '../language/limits.js';
+import { escapePointerToken } from '../language/value/syntax/pointer.js';
 import { acceptDomainSchema } from '../schema/admission/accept.js';
 import { canonicalDomainSchemaAfterValidation } from '../schema/canonical/revision.js';
 import { revisionOfDomainSchema } from '../schema/canonical/revision.js';
 import { MemoryDomainSchemaLookup } from '../schema/dependency/lookup.js';
 import { SchemaError } from '../schema/diagnostic.js';
-import { BundleError, diagnostic } from './diagnostic.js';
+import { BundleError, diagnostic, schemaDiagnosticAt } from './diagnostic.js';
 import { asDomainSchemaBundle, } from './model.js';
 import { parseDomainSchemaBundleStructure } from './structure.js';
-function escapeToken(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}
 export function acceptDomainSchemaBundle(input) {
     let admitted;
     try {
@@ -48,12 +46,12 @@ function acceptBundleValue(input) {
     const closure = structure.closure.map((schema, index) => candidate(schema, `/closure/${index}`));
     const diagnostics = [];
     const candidates = new Map();
-    if (closure.length + 1 > dependencyLimits.closure) {
-        diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', '/closure', `A dependency closure may contain at most ${dependencyLimits.closure} Domains.`));
+    if (closure.length + 1 > limits.dependency.closure) {
+        diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', '/closure', `A dependency closure may contain at most ${limits.dependency.closure} Domains.`));
     }
     for (const entry of [root, ...closure]) {
-        if (Object.keys(entry.schema.dependencies).length > dependencyLimits.direct) {
-            diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', `${entry.pointer}/dependencies`, `A Domain may declare at most ${dependencyLimits.direct} direct dependency aliases.`));
+        if (Object.keys(entry.schema.dependencies).length > limits.dependency.direct) {
+            diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', `${entry.pointer}/dependencies`, `A Domain may declare at most ${limits.dependency.direct} direct dependency aliases.`));
         }
     }
     for (const entry of closure) {
@@ -101,7 +99,7 @@ function acceptBundleValue(input) {
         catch (error) {
             if (!(error instanceof SchemaError))
                 throw error;
-            throw new BundleError(error.diagnostics.map((item) => diagnostic(item.code, `${entry.pointer}${item.pointer}`, item.message, item.ref)));
+            throw new BundleError(error.diagnostics.map((item) => schemaDiagnosticAt(entry.pointer, item)));
         }
     };
     for (const entry of candidates.values()) {
@@ -130,13 +128,13 @@ function collectReachable(current, root, candidates, reachable, active, revision
         return;
     }
     active.add(current.key);
-    if (depth > dependencyLimits.depth) {
-        diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', current.pointer, `Dependency depth ${depth} exceeds the maximum ${dependencyLimits.depth}.`));
+    if (depth > limits.dependency.depth) {
+        diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', current.pointer, `Dependency depth ${depth} exceeds the maximum ${limits.dependency.depth}.`));
         active.delete(current.key);
         return;
     }
     for (const [alias, dependency] of Object.entries(current.schema.dependencies)) {
-        const pointer = `${current.pointer}/dependencies/${escapeToken(alias)}`;
+        const pointer = `${current.pointer}/dependencies/${escapePointerToken(alias)}`;
         const dependencyKey = keyOf(dependency.origin, dependency.revision);
         if (dependencyKey === root.key) {
             diagnostics.push(diagnostic('BUNDLE_CLOSURE_CYCLE', pointer, 'Bundle dependency closure returns to its root.'));

package/dist/v1/bundle/diagnostic.d.ts

@@ -4,6 +4,8 @@ export type BundleDiagnostic<Code extends BundleDiagnosticCode = BundleDiagnosti
     readonly code: Code;
 };
 export declare function diagnostic<const Code extends BundleDiagnosticCode>(code: Code, pointer: string, message: string, ref?: string): BundleDiagnostic<Code>;
+/** A refusal of one bundled schema, its pointer rebased under the schema's place in the bundle. */
+export declare function schemaDiagnosticAt(pointer: string, refusal: SchemaDiagnostic): BundleDiagnostic;
 export declare class BundleError extends Error {
     readonly diagnostics: readonly BundleDiagnostic[];
     constructor(diagnostics: readonly BundleDiagnostic[]);

package/dist/v1/bundle/diagnostic.js

@@ -1,16 +1,18 @@
-import { compareUnicode } from '../addressing/ordering.js';
+import { formatDiagnostics, orderDiagnostics } from '../language/validation/diagnostic.js';
 export function diagnostic(code, pointer, message, ref) {
     return Object.freeze({ code, pointer, message, ...(ref === undefined ? {} : { ref }) });
 }
+/** A refusal of one bundled schema, its pointer rebased under the schema's place in the bundle. */
+export function schemaDiagnosticAt(pointer, refusal) {
+    // Acceptance refuses a document with Schema codes only, never with comparison request codes.
+    const code = refusal.code;
+    return Object.freeze({ ...refusal, code, pointer: `${pointer}${refusal.pointer}` });
+}
 export class BundleError extends Error {
     diagnostics;
     constructor(diagnostics) {
-        const ordered = [...diagnostics].sort((left, right) => compareUnicode(left.pointer, right.pointer) ||
-            compareUnicode(left.code, right.code) ||
-            compareUnicode(left.message, right.message));
-        super(ordered
-            .map(({ code, pointer, message }) => `${pointer || '/'} [${code}] ${message}`)
-            .join('\n'));
+        const ordered = orderDiagnostics(diagnostics);
+        super(formatDiagnostics(ordered));
         this.name = 'BundleError';
         this.diagnostics = Object.freeze(ordered);
     }

package/dist/v1/bundle/model.js

@@ -1,4 +1,4 @@
-import { deepFreeze } from '../schema/canonical/freeze.js';
+import { deepFreeze } from '../language/freeze.js';
 export const DOMAIN_BUNDLE_FORMAT = 'astrale.dsl.bundle';
 export const DOMAIN_BUNDLE_VERSION = 'v1';
 export function asDomainSchemaBundle(root, closure) {

package/dist/v1/bundle/structure.js

@@ -1,6 +1,7 @@
+import { escapePointerToken } from '../language/value/syntax/pointer.js';
 import { SchemaError } from '../schema/diagnostic.js';
 import { routeDomainSchema } from '../schema/validation/domain.route.js';
-import { BundleError, diagnostic } from './diagnostic.js';
+import { BundleError, diagnostic, schemaDiagnosticAt } from './diagnostic.js';
 import { DOMAIN_BUNDLE_FORMAT, DOMAIN_BUNDLE_VERSION } from './model.js';
 export function parseDomainSchemaBundleStructure(input) {
     if (!isObject(input)) {
@@ -12,7 +13,7 @@ export function parseDomainSchemaBundleStructure(input) {
     const expected = new Set(['format', 'version', 'root', 'closure']);
     for (const key of Object.keys(input)) {
         if (!expected.has(key)) {
-            diagnostics.push(diagnostic('BUNDLE_STRUCTURE', `/${escapeToken(key)}`, `Unknown bundle field ${key}.`));
+            diagnostics.push(diagnostic('BUNDLE_STRUCTURE', `/${escapePointerToken(key)}`, `Unknown bundle field ${key}.`));
         }
     }
     for (const key of expected) {
@@ -56,7 +57,7 @@ function routeAt(value, pointer, diagnostics) {
     catch (error) {
         if (!(error instanceof SchemaError))
             throw error;
-        diagnostics.push(...error.diagnostics.map((entry) => diagnostic(entry.code, `${pointer}${entry.pointer}`, entry.message, entry.ref)));
+        diagnostics.push(...error.diagnostics.map((entry) => schemaDiagnosticAt(pointer, entry)));
         return undefined;
     }
 }
@@ -66,6 +67,3 @@ function isObject(value) {
 function describe(value) {
     return value === undefined ? '(missing)' : JSON.stringify(value);
 }
-function escapeToken(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}

package/dist/v1/compiled/admission/accept.js

@@ -1,5 +1,6 @@
 import { accept as acceptPortable } from '@astrale-os/kernel-dsl/value';
-import { dependencyLimits } from '../../addressing/domain-dependency.js';
+import { deepFreeze } from '../../language/freeze.js';
+import { limits } from '../../language/limits.js';
 import {} from '../model/schema.js';
 import { validateClosure } from './closure.js';
 import { invalid, pointer } from './diagnostic.js';
@@ -20,7 +21,7 @@ export function acceptCompiledSchema(input) {
     const rootPin = dependency(root.root, 'root', '/root');
     const machines = new Map();
     const closure = array(root.closure, 'closure', '/closure').map((value, index) => entry(value, index, `/closure/${index}`, machines));
-    if (closure.length > dependencyLimits.closure) {
+    if (closure.length > limits.dependency.closure) {
         invalid('dependency closure limit', 'COMPILED_DEPENDENCY_LIMITS', '/closure');
     }
     const closureOrigins = new Set();
@@ -34,7 +35,7 @@ export function acceptCompiledSchema(input) {
     if (rootEntry?.revision !== rootPin.revision)
         invalid('root pin', undefined, '/root');
     for (const [entryIndex, owner] of closure.entries()) {
-        if (Object.keys(owner.dependencies).length > dependencyLimits.direct) {
+        if (Object.keys(owner.dependencies).length > limits.dependency.direct) {
             invalid('direct dependency limit', 'COMPILED_DEPENDENCY_LIMITS', `/closure/${entryIndex}/dependencies`);
         }
         for (const [alias, pin] of Object.entries(owner.dependencies)) {
@@ -69,10 +70,3 @@ export function acceptCompiledSchema(input) {
     validateCompiledSemantics(candidate);
     return deepFreeze(candidate);
 }
-function deepFreeze(input) {
-    if (input === null || typeof input !== 'object' || Object.isFrozen(input))
-        return input;
-    for (const value of Object.values(input))
-        deepFreeze(value);
-    return Object.freeze(input);
-}

package/dist/v1/compiled/admission/closure.js

@@ -1,7 +1,7 @@
 import {} from '@astrale-os/kernel-dsl/value';
-import { dependencyLimits } from '../../addressing/domain-dependency.js';
 import { Key, isDefinitionRef } from '../../addressing/index.js';
 import {} from '../../language/class/model/edge.js';
+import { limits } from '../../language/limits.js';
 import {} from '../model/schema.js';
 import { invalid, pointer } from './diagnostic.js';
 /** Require closed direct references, acyclic inheritance and concrete Core Classes. */
@@ -128,7 +128,7 @@ function validateDependencyCycles(candidate) {
     const visited = new Set();
     const frames = [];
     const push = (origin, depth) => {
-        if (depth > dependencyLimits.depth) {
+        if (depth > limits.dependency.depth) {
             invalid('dependency depth limit', 'COMPILED_DEPENDENCY_LIMITS', `/closure/${byOrigin.get(origin)?.index ?? 0}/dependencies`);
         }
         active.add(origin);

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

@@ -1,6 +1,6 @@
 import { type CompiledDiagnosticCode } from '../diagnostic.js';
 /** Append one escaped JSON Pointer segment. */
-export declare function pointer(parent: string, member: string | number): string;
+export { appendPointer as pointer } from '../../language/value/syntax/pointer.js';
 /** Report a structural compiled-input violation with its stable diagnostic code. */
 export declare function invalid(label: string, code?: CompiledDiagnosticCode, path?: string): never;
 /** Report a contextual compiled-language violation at its original source pointer. */

package/dist/v1/compiled/admission/diagnostic.js

@@ -1,8 +1,6 @@
 import { invalidCompiled } from '../diagnostic.js';
 /** Append one escaped JSON Pointer segment. */
-export function pointer(parent, member) {
-    return `${parent}/${String(member).replaceAll('~', '~0').replaceAll('/', '~1')}`;
-}
+export { appendPointer as pointer } from '../../language/value/syntax/pointer.js';
 /** Report a structural compiled-input violation with its stable diagnostic code. */
 export function invalid(label, code = 'COMPILED_STRUCTURE_INVALID', path = '') {
     return invalidCompiled(code, `Invalid compiled Schema ${label}.`, path);

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

@@ -1,4 +1,12 @@
 import type { Revision } from '../../addressing/index.js';
-import type { CompiledSchemaEntry } from '../model/schema.js';
+import type { FunctionDefinition, MethodDefinition } from '../../language/callable/model/callable.js';
+import type { JsonSchema } from '../../language/value/model/schema.js';
+import type { CompiledFunction, CompiledMethod, CompiledSchemaEntry } from '../model/schema.js';
 /** Derive the exact canonical source-revision preimage without constructing an authored Schema. */
 export declare function revisionOfCompiledEntry(entry: CompiledSchemaEntry): Revision;
+/** The source definition of a compiled Method: its value programs back to their schemas. */
+export declare function sourceMethod(entry: CompiledSchemaEntry, method: CompiledMethod): MethodDefinition;
+/** The source definition of a compiled Function: its value programs back to their schemas. */
+export declare function sourceFunction(entry: CompiledSchemaEntry, definition: CompiledFunction): FunctionDefinition;
+/** The schema of the root node of the entry's value program `index`. */
+export declare function schemaOf(entry: CompiledSchemaEntry, index: number): JsonSchema;

package/dist/v1/compiled/admission/revision.js

@@ -44,7 +44,8 @@ function sourceClass(entry, definition) {
         methods: Object.fromEntries(methods.map((method) => [method.name, sourceMethod(entry, method)])),
     };
 }
-function sourceMethod(entry, method) {
+/** The source definition of a compiled Method: its value programs back to their schemas. */
+export function sourceMethod(entry, method) {
     const { name: _, input, fields: __, output, ...rest } = method;
     return {
         ...rest,
@@ -52,7 +53,8 @@ function sourceMethod(entry, method) {
         output: sourceOutput(entry, output),
     };
 }
-function sourceFunction(entry, definition) {
+/** The source definition of a compiled Function: its value programs back to their schemas. */
+export function sourceFunction(entry, definition) {
     const { input, fields: _, output, ...rest } = definition;
     return {
         ...rest,
@@ -72,7 +74,8 @@ function sourceOutput(entry, output) {
     const schema = schemaOf(entry, output.value);
     return output.mode === 'value' ? { mode: 'value', schema } : { mode: 'stream', item: schema };
 }
-function schemaOf(entry, index) {
+/** The schema of the root node of the entry's value program `index`. */
+export function schemaOf(entry, index) {
     const program = entry.values[index];
     const root = program?.nodes[program.root];
     if (root === undefined)

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

@@ -1,5 +1,8 @@
 import { type Located, type CompiledClass, type ClassAnalysis, type SemanticIndex } from './context.js';
-/** Compose inherited Properties, Methods and Data ownership once per Class. */
+/**
+ * Compose inherited Properties, Methods and Data ownership once per Class. The closure check has
+ * already proved every parent present and the inheritance graph acyclic.
+ */
 export declare function analyzeClasses(classes: ReadonlyMap<string, Located<CompiledClass>>): ReadonlyMap<string, ClassAnalysis>;
 /** Check automatic Properties, immutability and abstract Class obligations. */
 export declare function validateClassFacets(context: SemanticIndex): void;

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

@@ -2,26 +2,26 @@ import { json } from '@astrale-os/kernel-dsl/value';
 import { Key, PropertyKey as PropertyKeyValue, } from '../../../addressing/index.js';
 import { composeMethods } from '../../../language/callable/composition.js';
 import { isMethodExecutable } from '../../../language/callable/executable.js';
+import { keyableProperty } from '../../../language/class/unique.js';
 import { bindValueProgram } from '../../../language/value/compile/load.js';
 import {} from '../../model/schema.js';
 import { fail } from '../diagnostic.js';
 import {} from './context.js';
-/** Compose inherited Properties, Methods and Data ownership once per Class. */
+/**
+ * Compose inherited Properties, Methods and Data ownership once per Class. The closure check has
+ * already proved every parent present and the inheritance graph acyclic.
+ */
 export function analyzeClasses(classes) {
     const analyses = new Map();
-    const visiting = new Set();
     const analyze = (located) => {
         const classKey = Key.of(located.value.ref);
         const cached = analyses.get(classKey);
         if (cached !== undefined)
             return cached;
-        if (visiting.has(classKey))
-            fail(`${located.pointer}/extends`, 'Class inheritance is cyclic.');
-        visiting.add(classKey);
         const parents = located.value.extends.map((ref, index) => {
             const parent = classes.get(Key.of(ref));
-            if (parent === undefined)
-                fail(`${located.pointer}/extends/${index}`, 'Parent Class is absent.');
+            if (parent.value.inheritance === 'final')
+                fail(`${located.pointer}/extends/${index}`, 'A final Class has no subclass.');
             return analyze(parent);
         });
         const properties = new Map();
@@ -68,7 +68,6 @@ export function analyzeClasses(classes) {
             ...(dataOwner === undefined ? {} : { dataOwner }),
         };
         analyses.set(classKey, analysis);
-        visiting.delete(classKey);
         return analysis;
     };
     for (const value of classes.values())
@@ -91,9 +90,8 @@ function programKey(entry, value) {
 /** Check automatic Properties, immutability and abstract Class obligations. */
 export function validateClassFacets(context) {
     for (const located of context.classes.values()) {
-        if (located.value.abstract &&
-            (located.value.policies.read !== undefined || located.value.policies.traverse !== undefined)) {
-            fail(`${located.pointer}/policies`, 'Abstract Classes cannot declare observation Policies.');
+        if (located.value.abstract && Object.keys(located.value.policies).length > 0) {
+            fail(`${located.pointer}/policies`, 'Abstract Classes cannot declare Class Policies.');
         }
         for (const [index, property] of located.value.properties.entries()) {
             const path = `${located.pointer}/properties/${index}`;
@@ -114,11 +112,38 @@ export function validateClassFacets(context) {
                 }
             }
         }
+        if (located.value.unique !== undefined) {
+            const properties = context.analyses.get(Key.of(located.value.ref))?.properties;
+            const keyable = (key, at) => {
+                const property = properties?.get(key)?.declaration;
+                if (property === undefined || !keyableProperty(property.ordering, property.auto)) {
+                    fail(at, 'A key Property is a keyable Property of the Class.');
+                }
+            };
+            // A Node tuple names Properties only; an Edge tuple names them as `{ property }`.
+            const value = located.value;
+            if (value.kind === 'node') {
+                for (const [t, tuple] of (value.unique ?? []).entries())
+                    for (const [f, key] of tuple.entries())
+                        keyable(key, `${located.pointer}/unique/${t}/${f}`);
+            }
+            else {
+                for (const [t, tuple] of (value.unique ?? []).entries())
+                    for (const [f, field] of tuple.entries())
+                        if (typeof field !== 'string')
+                            keyable(field.property, `${located.pointer}/unique/${t}/${f}/property`);
+            }
+        }
         if (located.value.kind === 'node') {
             for (const [index, method] of located.value.methods.entries()) {
-                if (!isMethodExecutable(located.value, method) && method.policy !== undefined) {
+                if (isMethodExecutable(located.value, method))
+                    continue;
+                if (method.policy !== undefined) {
                     fail(`${located.pointer}/methods/${index}/policy`, 'An abstract Method cannot have a Policy.');
                 }
+                if (method.admission !== undefined) {
+                    fail(`${located.pointer}/methods/${index}/admission`, 'An abstract Method cannot have an admission age.');
+                }
             }
         }
     }

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

@@ -1,7 +1,5 @@
-import { type ClassRef } from '../../../addressing/index.js';
-import { type CoreEdge } from '../../../language/core/model/core.js';
 import { type CompiledSchemaEntry, type CompiledSchema } from '../../model/schema.js';
-import { type Located, type CompiledClass, type ClassAnalysis, type CompiledEdge, type SemanticIndex } from './context.js';
+import { type Located, type CompiledClass, type ClassAnalysis, type SemanticIndex } from './context.js';
 /** A local Core Node paired with its admitted Class analysis. */
 export interface CoreNode {
     readonly key: string;
@@ -10,26 +8,5 @@ export interface CoreNode {
     readonly analysis: ClassAnalysis;
     readonly pointer: string;
 }
-/**
- * A local Definition other than a Core Node, or a Class-owned Method. The Domain projects it as a
- * Kernel declaration Node, so `class` names that Kernel Class rather than an authored one.
- */
-interface CoreMemberEndpoint {
-    readonly key: string;
-    readonly class: ClassRef;
-    readonly pointer: string;
-}
-type CoreEndpoint = CoreNode | CoreMemberEndpoint | {
-    readonly key: 'domain';
-};
-/** A Core Edge paired with resolved endpoints and its exact Class. */
-export interface CoreEdgeValue {
-    readonly source: CoreEndpoint;
-    readonly target: CoreEndpoint;
-    readonly value: CoreEdge;
-    readonly class: Located<CompiledEdge>;
-    readonly pointer: string;
-}
 /** Admit local Core Nodes, Properties and Edge endpoint contracts. */
 export declare function validateCore(candidate: CompiledSchema, context: SemanticIndex): void;
-export {};

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

@@ -1,15 +1,19 @@
 import { Key } from '../../../addressing/index.js';
 import { isMethodExecutable } from '../../../language/callable/executable.js';
+import { coveringEdgeUniqueTuples, coveringNodeUniqueTuples, edgeUniqueKeys, nodeUniqueKeys, } from '../../../language/class/unique.js';
+import { checkCoreEdgeSet, checkHeldKeys, coreEndpointsSatisfy, DOMAIN_ENDPOINT_CLASS, } 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()) {
@@ -31,6 +35,9 @@ export function validateCore(candidate, context) {
                 pointer: path,
             });
         }
+        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}`;
@@ -46,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({
@@ -64,28 +64,66 @@ 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),
+        });
+    }
+}
+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) {
     if (ref.kind === 'domain')
-        return { key: 'domain' };
+        return { key: 'domain', member: { class: DOMAIN_ENDPOINT_CLASS, pointer: path } };
     const undeclared = () => fail(path, 'Core endpoint does not name a declared local Definition.');
     if (policyObjectOrigin(ref) !== entry.origin)
         return undeclared();
@@ -93,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) {
@@ -112,12 +151,5 @@ function declaresProjectedMember(context, entry, ref) {
     return declarations.some((declaration) => declaration.ref.name === ref.name);
 }
 function endpointSatisfies(context, endpoint, accepts) {
-    if ('value' in endpoint)
-        return classSatisfiesAny(context, endpoint.value.class, accepts);
-    if ('class' in endpoint)
-        return classSatisfiesAny(context, endpoint.class, accepts);
-    return true;
-}
-function escapePointer(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+    return classSatisfiesAny(context, 'value' in endpoint ? endpoint.value.class : endpoint.member.class, accepts);
 }

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];