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

package/dist/v1/schema/validation/class.js

@@ -1,48 +1,63 @@
+import { equalDefinitionRefs } from '../../addressing/definition-ref.js';
 import { Key } from '../../addressing/key.js';
 import { definitionRefIndex } from '../../addressing/ordering.js';
 import { isMethodExecutable } from '../../language/callable/executable.js';
-import { classSatisfies as satisfiesClass, isGraphRoot } from '../../language/class/inheritance.js';
+import { classSatisfies as satisfiesClass, edgeContractRefines as refinesEdgeContract, } from '../../language/class/inheritance.js';
+import { lifetimeBreaches, lifetimeScope } from '../../language/class/lifetime.js';
+import { keyableProperty } from '../../language/class/unique.js';
 import { admitStateTopology } from '../../language/state/topology.js';
 import { isBlobValueSchema } from '../../language/value/model/blob.js';
 import { classifyOrdering } from '../../language/value/ordering.js';
+import { escapePointerToken } from '../../language/value/syntax/pointer.js';
 import { diagnostic } from '../diagnostic.js';
-import { createValueSchemaRegistry } from '../resolution/value.registry.js';
+import { createDomainValueSchemaRegistry } from '../resolution/value.registry.js';
 const formatDefinitionRef = Key.of;
-/** Validate the semantic contracts owned by Class declarations. */
-export function validateDefinitions(environment, analysis) {
+/**
+ * Validate the semantic contracts owned by Class declarations. `registry` is the candidate's value
+ * registry; each dependency's is built at most once, so the Classes share them.
+ */
+export function validateDefinitions(environment, analysis, registry) {
     const diagnostics = [...analysis.diagnostics];
     const schema = environment.candidate;
+    let scope;
+    const registries = new Map([[schema.origin, registry]]);
+    const registryOf = (origin) => {
+        if (!registries.has(origin)) {
+            const dependency = environment.dependencies.get(origin);
+            registries.set(origin, dependency === undefined ? undefined : createDomainValueSchemaRegistry(dependency));
+        }
+        return registries.get(origin);
+    };
     for (const [name, declaration] of Object.entries(schema.classes)) {
-        const ref = localRef(schema.origin, name);
-        const pointer = `/classes/${escapePointer(name)}`;
-        if (!sameRef(declaration.ref, ref)) {
+        const ref = { origin: schema.origin, kind: 'class', name };
+        const pointer = `/classes/${escapePointerToken(name)}`;
+        if (!equalDefinitionRefs(declaration.ref, ref)) {
             diagnostics.push(diagnostic('DV_REF_RESOLVES', `${pointer}/ref`, `Class ref must be exactly ${formatDefinitionRef(ref)}.`, formatDefinitionRef(declaration.ref)));
         }
-        if (declaration.abstract &&
-            (declaration.policies.read !== undefined || declaration.policies.traverse !== undefined)) {
-            diagnostics.push(diagnostic('DV_CLASS_ABSTRACT', `${pointer}/policies`, 'Abstract Classes cannot declare observation Policies.'));
+        if (declaration.abstract && Object.keys(declaration.policies).length > 0) {
+            diagnostics.push(diagnostic('DV_CLASS_ABSTRACT', `${pointer}/policies`, 'Abstract Classes cannot declare Class Policies.'));
         }
-        validateFacet(environment, declaration, pointer, diagnostics);
+        validateFacet(registry, declaration, pointer, diagnostics);
         validateParents(environment, ref, declaration.kind, declaration.extends, diagnostics);
         if (declaration.kind === 'edge') {
-            validateEdgeContract(environment, ref, declaration, diagnostics);
+            validateEdgeContract(environment, ref, declaration, pointer, diagnostics);
+            scope ??= lifetimeScope([...environment.definitions.values()].map(({ declaration }) => declaration));
+            validateEdgeLifetimes(scope, ref, declaration, pointer, diagnostics);
+            validateEdgeClassComposition(environment, ref, declaration, pointer, diagnostics);
         }
+        validateUniqueProperties(registryOf, analysis, ref, declaration, pointer, diagnostics);
     }
-    validateEdgeClassComposition(environment, diagnostics);
     return Object.freeze(diagnostics);
 }
-function validateFacet(environment, declaration, pointer, diagnostics) {
-    const valueRegistry = createValueSchemaRegistry(environment);
+function validateFacet(valueRegistry, declaration, pointer, diagnostics) {
     for (const [name, property] of Object.entries(declaration.properties)) {
-        const propertyPointer = `${pointer}/properties/${escapePointer(name)}`;
+        const propertyPointer = `${pointer}/properties/${escapePointerToken(name)}`;
+        // The structure refuses a blob on an Edge Property and a State Property on an Edge Class.
         if (isBlobValueSchema(property.schema) &&
-            (declaration.kind !== 'node' || property.auto !== undefined || property.state !== undefined)) {
+            (property.auto !== undefined || property.state !== undefined)) {
             diagnostics.push(diagnostic('DV_VALUE_SCHEMA', `${propertyPointer}/schema/x-astrale-value-kind`, 'Blob values are allowed only on non-automatic, non-state Node properties.'));
         }
         if (property.state !== undefined) {
-            if (declaration.kind !== 'node') {
-                diagnostics.push(diagnostic('DV_PROPERTY_STATE', `${propertyPointer}/state`, 'A State Property may be declared only on a Node Class.'));
-            }
             try {
                 const topology = admitStateTopology(property.state);
                 const expected = Object.keys(topology.transitions).sort();
@@ -86,16 +101,22 @@ function validateFacet(environment, declaration, pointer, diagnostics) {
     if (declaration.kind !== 'node')
         return;
     for (const [name, method] of Object.entries(declaration.methods)) {
-        const methodPointer = `${pointer}/methods/${escapePointer(name)}`;
-        if (!isMethodExecutable(declaration, method) && method.policy !== undefined) {
+        const methodPointer = `${pointer}/methods/${escapePointerToken(name)}`;
+        if (isMethodExecutable(declaration, method))
+            continue;
+        if (method.policy !== undefined) {
             diagnostics.push(diagnostic('DV_METHOD_ABSTRACT', `${methodPointer}/policy`, 'Abstract Methods cannot have a Policy.'));
         }
+        // An admission age qualifies the admission of an executable declaration, like its Policy.
+        if (method.admission !== undefined) {
+            diagnostics.push(diagnostic('DV_METHOD_ABSTRACT', `${methodPointer}/admission`, 'Abstract Methods cannot have an admission age.'));
+        }
     }
 }
 function validateParents(environment, owner, ownerKind, parents, diagnostics) {
     for (const [index, parent] of parents.entries()) {
         const target = environment.resolve(parent);
-        const pointer = `/classes/${escapePointer(owner.name)}/extends/${index}`;
+        const pointer = `/classes/${escapePointerToken(owner.name)}/extends/${index}`;
         if (target === undefined) {
             diagnostics.push(diagnostic('DV_REF_RESOLVES', pointer, `Parent ${formatDefinitionRef(parent)} does not resolve exactly.`, formatDefinitionRef(parent)));
             continue;
@@ -103,105 +124,116 @@ function validateParents(environment, owner, ownerKind, parents, diagnostics) {
         if (target.ref.kind !== 'class' || target.declaration.kind !== ownerKind) {
             diagnostics.push(diagnostic('DV_CLASS_KIND', pointer, `${formatDefinitionRef(owner)} cannot extend different-kind Class ${formatDefinitionRef(parent)}.`, formatDefinitionRef(parent)));
         }
+        else if (target.declaration.inheritance === 'final') {
+            diagnostics.push(diagnostic('DV_CLASS_INHERITANCE', pointer, `${formatDefinitionRef(owner)} cannot extend final Class ${formatDefinitionRef(parent)}.`, formatDefinitionRef(parent)));
+        }
     }
 }
-function validateEdgeContract(environment, owner, declaration, diagnostics) {
-    const endpoints = declaration.orientation === 'directed'
+function validateEdgeContract(environment, owner, declaration, pointer, diagnostics) {
+    const directed = declaration.orientation === 'directed';
+    const endpoints = directed
         ? [declaration.endpoints.source, declaration.endpoints.target]
         : declaration.endpoints;
+    const keys = directed ? ['source', 'target'] : ['0', '1'];
     if (endpoints[0].role === endpoints[1].role) {
-        diagnostics.push(diagnostic('DV_EDGE_ROLE', '', `${formatDefinitionRef(owner)} has equal endpoint roles.`));
+        diagnostics.push(diagnostic('DV_EDGE_ROLE', `${pointer}/endpoints/${keys[1]}/role`, `${formatDefinitionRef(owner)} has equal endpoint roles.`));
     }
-    const counts = declaration.orientation === 'directed'
-        ? [declaration.endpoints.source.outgoing, declaration.endpoints.target.incoming]
-        : [declaration.endpoints[0].incident, declaration.endpoints[1].incident];
-    validateEndpoint(environment, owner, endpoints[0], counts[0], declaration.orientation === 'directed' ? 'source' : 'first endpoint', diagnostics);
-    validateEndpoint(environment, owner, endpoints[1], counts[1], declaration.orientation === 'directed' ? 'target' : 'second endpoint', diagnostics);
-    if (declaration.orientation === 'undirected') {
-        if (declaration.constraints.acyclic === true) {
-            diagnostics.push(diagnostic('DV_EDGE_CONSTRAINT', '', 'acyclic is valid only for directed Edge contracts.'));
+    const counts = directed
+        ? [
+            ['outgoing', declaration.endpoints.source.outgoing],
+            ['incoming', declaration.endpoints.target.incoming],
+        ]
+        : [
+            ['incident', declaration.endpoints[0].incident],
+            ['incident', declaration.endpoints[1].incident],
+        ];
+    validateEndpoint(environment, owner, endpoints[0], counts[0], directed ? 'source' : 'first endpoint', `${pointer}/endpoints/${keys[0]}`, diagnostics);
+    validateEndpoint(environment, owner, endpoints[1], counts[1], directed ? 'target' : 'second endpoint', `${pointer}/endpoints/${keys[1]}`, diagnostics);
+}
+/**
+ * Each Property a key tuple names is one of the Class's own or inherited Properties, and keyable:
+ * a single-kind scalar by its ordering facet that no automatic program writes (D-S1). Properties
+ * inherit without redefinition, so the key reads one meaning on every descendant it covers. A Node
+ * tuple names Properties only; an Edge tuple names them as `{ property }` beside its other fields.
+ */
+function validateUniqueProperties(registryOf, analysis, owner, declaration, pointer, diagnostics) {
+    if (declaration.kind === 'edge' && declaration.orientation !== 'directed')
+        return;
+    if (declaration.unique === undefined)
+        return;
+    const properties = analysis.definitions.get(definitionRefIndex(owner))?.properties;
+    if (properties === undefined)
+        return;
+    const code = declaration.kind === 'node' ? 'DV_NODE_UNIQUE' : 'DV_EDGE_UNIQUE';
+    const check = (key, at) => {
+        const property = properties.get(key);
+        if (property === undefined) {
+            diagnostics.push(diagnostic(code, at, `${key} is not a Property of the Class.`));
+            return;
         }
+        const registry = registryOf(property.owner.origin);
+        const ordering = registry === undefined ? undefined : classifyOrdering(property.schema, registry);
+        if (!keyableProperty(ordering, property.auto)) {
+            diagnostics.push(diagnostic(code, at, 'A key Property is a string, number, boolean or instant that no automatic program writes.'));
+        }
+    };
+    if (declaration.kind === 'node') {
+        declaration.unique.forEach((tuple, t) => tuple.forEach((key, f) => check(key, `${pointer}/unique/${t}/${f}`)));
+        return;
     }
+    declaration.unique.forEach((tuple, t) => tuple.forEach((field, f) => {
+        if (typeof field !== 'string')
+            check(field.property, `${pointer}/unique/${t}/${f}/property`);
+    }));
 }
-function validateEndpoint(environment, owner, endpoint, count, side, diagnostics) {
+// The structure refuses a repeated accepted Class before semantics: `accepts` is a set.
+function validateEndpoint(environment, owner, endpoint, [countField, count], side, pointer, diagnostics) {
     // An Edge Class binds only the Nodes of its Domain and its dependents: it cannot oblige the
     // Nodes of a Class another Domain owns to carry its Edges.
     const foreign = endpoint.accepts.find((ref) => ref.origin !== owner.origin);
     if (foreign !== undefined && (count === '1' || count === '1..*')) {
-        diagnostics.push(diagnostic('DV_EDGE_FOREIGN_MINIMUM', '', `${formatDefinitionRef(owner)} ${side} accepts ${formatDefinitionRef(foreign)} of another Domain and cannot require ${count} Edges.`));
+        diagnostics.push(diagnostic('DV_EDGE_FOREIGN_MINIMUM', `${pointer}/${countField}`, `${formatDefinitionRef(owner)} ${side} accepts ${formatDefinitionRef(foreign)} of another Domain and cannot require ${count} Edges.`));
     }
-    const seen = new Set();
-    for (const ref of endpoint.accepts) {
-        const key = definitionRefIndex(ref);
-        if (seen.has(key)) {
-            diagnostics.push(diagnostic('DV_EDGE_ACCEPTS', '', `${formatDefinitionRef(owner)} ${side} repeats ${formatDefinitionRef(ref)}.`));
-        }
-        seen.add(key);
+    for (const [index, ref] of endpoint.accepts.entries()) {
         const resolved = environment.resolve(ref);
         if (resolved === undefined ||
             resolved.ref.kind !== 'class' ||
             resolved.declaration.kind !== 'node') {
-            diagnostics.push(diagnostic('DV_EDGE_ACCEPTS', '', `${formatDefinitionRef(owner)} ${side} ref ${formatDefinitionRef(ref)} does not resolve to a Node Class.`));
+            diagnostics.push(diagnostic('DV_EDGE_ACCEPTS', `${pointer}/accepts/${index}`, `${formatDefinitionRef(owner)} ${side} ref ${formatDefinitionRef(ref)} does not resolve to a Node Class.`));
         }
     }
 }
-/** Edge inheritance is refinement, not a second interface composition mechanism. */
-function validateEdgeClassComposition(environment, diagnostics) {
-    for (const resolved of environment.definitions.values()) {
-        if (resolved.ref.kind !== 'class' || resolved.declaration.kind !== 'edge')
+/**
+ * The lifetime laws over the lifetimes a Schema declares. What an endpoint derives where it
+ * declares nothing is never refused here: a stored Registry decoded again keeps it.
+ */
+function validateEdgeLifetimes(scope, owner, declaration, pointer, diagnostics) {
+    const sides = declaration.orientation === 'directed'
+        ? ['source', 'target']
+        : ['first endpoint', 'second endpoint'];
+    const keys = declaration.orientation === 'directed' ? ['source', 'target'] : ['0', '1'];
+    for (const { index, reason } of lifetimeBreaches(declaration, scope)) {
+        diagnostics.push(diagnostic('DV_EDGE_LIFETIME', `${pointer}/endpoints/${keys[index]}/onDelete`, `${formatDefinitionRef(owner)} ${sides[index]} ${reason}`));
+    }
+}
+/**
+ * Edge inheritance is refinement, not a second interface composition mechanism. A dependency
+ * Edge Class was judged against this same exact closure when it was accepted.
+ */
+function validateEdgeClassComposition(environment, owner, child, pointer, diagnostics) {
+    for (const [index, parentRef] of child.extends.entries()) {
+        const parent = environment.resolveAny(parentRef);
+        if (parent === undefined || parent.ref.kind !== 'class' || parent.declaration.kind !== 'edge') {
             continue;
-        const child = resolved.declaration;
-        for (const parentRef of child.extends) {
-            const parent = environment.resolveAny(parentRef);
-            if (parent === undefined ||
-                parent.ref.kind !== 'class' ||
-                parent.declaration.kind !== 'edge') {
-                continue;
-            }
-            if (!edgeContractRefines(environment, child, parent.declaration)) {
-                diagnostics.push(diagnostic('DV_EDGE_CLASS_COMPOSITION', '', `${formatDefinitionRef(resolved.ref)} does not safely refine ${formatDefinitionRef(parentRef)}.`));
-            }
+        }
+        if (!edgeContractRefines(environment, child, parent.declaration)) {
+            diagnostics.push(diagnostic('DV_EDGE_CLASS_COMPOSITION', `${pointer}/extends/${index}`, `${formatDefinitionRef(owner)} does not safely refine ${formatDefinitionRef(parentRef)}.`));
         }
     }
 }
 /** Whether `child` safely refines its parent Edge contract `parent`. */
 export function edgeContractRefines(environment, child, parent) {
-    if (isGraphRoot(parent))
-        return true;
-    if (child.orientation !== parent.orientation)
-        return false;
-    if (parent.constraints.noSelf === true && child.constraints.noSelf !== true)
-        return false;
-    if (parent.constraints.acyclic === true && child.constraints.acyclic !== true)
-        return false;
-    if (child.orientation === 'directed' && parent.orientation === 'directed') {
-        return (endpointRefines(environment, child.endpoints.source, parent.endpoints.source) &&
-            countRefines(child.endpoints.source.outgoing, parent.endpoints.source.outgoing) &&
-            endpointRefines(environment, 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(environment, 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 endpointRefines(environment, child, parent) {
-    return child.accepts.every((accepted) => classSatisfies(environment, accepted, parent.accepts));
-}
-function countRefines(child, parent) {
-    const bounds = {
-        '0..*': [0, Number.POSITIVE_INFINITY],
-        '1..*': [1, Number.POSITIVE_INFINITY],
-        '0..1': [0, 1],
-        '1': [1, 1],
-    };
-    const [childMinimum, childMaximum] = bounds[child];
-    const [parentMinimum, parentMaximum] = bounds[parent];
-    return childMinimum >= parentMinimum && childMaximum <= parentMaximum;
+    return refinesEdgeContract(child, parent, (candidate, accepts) => classSatisfies(environment, candidate, accepts));
 }
 /** Whether `candidate` is, or is a Node Class extending, one of `accepts`. */
 export function classSatisfies(environment, candidate, accepts) {
@@ -216,12 +248,3 @@ export function classSatisfies(environment, candidate, accepts) {
         return required !== undefined && satisfiesClass(actual, required, resolve);
     });
 }
-function localRef(origin, name) {
-    return { origin, kind: 'class', name };
-}
-function sameRef(left, right) {
-    return left.origin === right.origin && left.kind === right.kind && left.name === right.name;
-}
-function escapePointer(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}

package/dist/v1/schema/validation/core.js

@@ -1,26 +1,44 @@
+import { equalDefinitionRefs } from '../../addressing/definition-ref.js';
 import { Key } from '../../addressing/key.js';
 import { compareUnicode, definitionRefIndex } from '../../addressing/ordering.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 { policyObjectKey, policyObjectOrigin, projectedMemberClass, } from '../../language/policy/model/policy.js';
 import { validateJsonInstance } from '../../language/value/evaluate/validate.js';
-import { diagnostic } from '../diagnostic.js';
+import { escapePointerToken } from '../../language/value/syntax/pointer.js';
+import { diagnostic, valueDiagnostic } from '../diagnostic.js';
 import { classSatisfies } from './class.js';
 const formatDefinitionRef = Key.of;
 export function validateCore(environment, analysis, registry) {
     const diagnostics = [];
     const nodesByRef = resolveCoreNodes(environment, analysis, registry, diagnostics);
     const edges = resolveCoreEdges(environment, analysis, registry, nodesByRef, diagnostics);
+    validateCoreNodeKeys(environment, nodesByRef, diagnostics);
     validateCoreEdgeSet(environment, edges, nodesByRef, diagnostics);
     return Object.freeze(diagnostics);
 }
+/** No two Core Nodes hold one key under a tuple covering their Classes, whichever declares it. */
+function validateCoreNodeKeys(environment, nodesByRef, diagnostics) {
+    const resolve = (ref) => environment.resolveAny(ref)?.declaration;
+    checkHeldKeys(nodesByRef.values(), (node) => {
+        const declaration = resolve(node.classRef);
+        if (declaration === undefined)
+            return [];
+        return nodeUniqueKeys(coveringNodeUniqueTuples(declaration, resolve), {
+            props: environment.candidate.core.nodes[node.slug].properties,
+        });
+    }, (node, previous) => diagnostics.push(diagnostic('DV_CORE_NODE_UNIQUE', nodePointer(node), `Core Node holds a key the Core Node at ${nodePointer(previous)} holds.`)));
+}
+function nodePointer(node) {
+    return `/core/nodes/${escapePointerToken(node.slug)}`;
+}
 function resolveCoreNodes(environment, analysis, registry, diagnostics) {
     const nodes = new Map();
     for (const [slug, node] of Object.entries(environment.candidate.core.nodes)) {
-        const pointer = `/core/nodes/${escapePointer(slug)}`;
+        const pointer = `/core/nodes/${escapePointerToken(slug)}`;
         const ref = { origin: environment.candidate.origin, kind: 'core', name: slug };
-        if (node.ref.origin !== ref.origin ||
-            node.ref.kind !== ref.kind ||
-            node.ref.name !== ref.name) {
+        if (!equalDefinitionRefs(node.ref, ref)) {
             diagnostics.push(diagnostic('DV_REF_RESOLVES', `${pointer}/ref`, `Core ref must be exactly ${formatDefinitionRef(ref)}.`, formatDefinitionRef(node.ref)));
         }
         const resolved = environment.resolve(node.class);
@@ -63,15 +81,11 @@ function resolveCoreEdges(environment, analysis, registry, nodesByRef, diagnosti
         const declaration = resolved.declaration;
         if (source === undefined || target === undefined)
             continue;
-        const endpointsSatisfy = declaration.orientation === 'directed'
-            ? endpointSatisfies(environment, source, declaration.endpoints.source.accepts) &&
-                endpointSatisfies(environment, target, declaration.endpoints.target.accepts)
-            : (endpointSatisfies(environment, source, declaration.endpoints[0].accepts) &&
-                endpointSatisfies(environment, target, declaration.endpoints[1].accepts)) ||
-                (endpointSatisfies(environment, source, declaration.endpoints[1].accepts) &&
-                    endpointSatisfies(environment, target, declaration.endpoints[0].accepts));
+        const endpointsSatisfy = coreEndpointsSatisfy(declaration, source, target, (endpoint, accepts) => endpointSatisfies(environment, endpoint, accepts));
         if (!endpointsSatisfy) {
-            diagnostics.push(diagnostic('DV_CORE_EDGE_CLASS', pointer, `Core Edge endpoints do not satisfy ${formatDefinitionRef(edge.class)}.`, formatDefinitionRef(edge.class)));
+            diagnostics.push(diagnostic('DV_CORE_EDGE_CLASS', pointer, `Core Edge endpoints do not satisfy ${formatDefinitionRef(edge.class)}.${source.kind === 'domain' || target.kind === 'domain'
+                ? ` The owning Domain is a ${formatDefinitionRef(DOMAIN_ENDPOINT_CLASS)} Node: the endpoint that names it must accept that Class or one it extends.`
+                : ''}`, formatDefinitionRef(edge.class)));
             continue;
         }
         edges.push({ source, target, declaration, value: edge, pointer });
@@ -80,7 +94,7 @@ function resolveCoreEdges(environment, analysis, registry, nodesByRef, diagnosti
 }
 function resolveCoreEndpoint(environment, ref, pointer, nodesByRef, diagnostics) {
     if (ref.kind === 'domain')
-        return { kind: 'domain', ref, key: 'domain' };
+        return { kind: 'domain', ref, key: 'domain', classRef: DOMAIN_ENDPOINT_CLASS };
     const undeclared = () => {
         const key = policyObjectKey(ref);
         diagnostics.push(diagnostic('DV_CORE_REF', pointer, `Core endpoint ${key} does not name a declared local Definition.`, key));
@@ -110,10 +124,14 @@ function declaresProjectedMember(environment, ref) {
         return Object.hasOwn(candidate.policies, ref.name);
     return Object.hasOwn(candidate.views, ref.name);
 }
+/**
+ * A Core Node is admitted by its own authored Class, a projected member by the Kernel declaration
+ * Class it projects as, and the owning Domain by the Kernel `Domain` Class of its Node: the write
+ * that projects the Edge binds exactly that Node, so an Edge Class that does not accept it can
+ * never be installed (DV-CORE-EDGE-CLASS).
+ */
 function endpointSatisfies(environment, endpoint, accepts) {
-    // The owning Domain is a graph-projection identity, not a Definition declared by this DSL.
-    // Its concrete Class contract is therefore admitted by the projection compiler.
-    return endpoint.kind === 'domain' || classSatisfies(environment, endpoint.classRef, accepts);
+    return classSatisfies(environment, endpoint.classRef, accepts);
 }
 function validateCreationProperties(definition, properties, registry, code, pointer, diagnostics) {
     const schema = {
@@ -127,166 +145,70 @@ function validateCreationProperties(definition, properties, registry, code, poin
             .sort(compareUnicode),
         additionalProperties: false,
     };
-    for (const failure of validateJsonInstance(schema, properties, registry, pointer)) {
-        diagnostics.push(diagnostic(code, failure.pointer, failure.message, failure.ref));
+    for (const refusal of validateJsonInstance(schema, properties, registry, pointer)) {
+        diagnostics.push(valueDiagnostic(code, refusal));
     }
 }
 function validateCoreEdgeSet(environment, edges, nodesByRef, diagnostics) {
-    const seen = new Map();
-    const edgeSlices = new Map();
-    for (const [name, candidate] of Object.entries(environment.candidate.classes)) {
-        if (candidate.kind !== 'edge')
-            continue;
-        const ref = {
-            origin: environment.candidate.origin,
-            kind: 'class',
-            name,
-        };
-        const resolved = environment.resolve(ref);
-        if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.kind !== 'edge') {
-            continue;
-        }
-        edgeSlices.set(definitionRefIndex(ref), {
-            declaration: resolved.declaration,
-            edges: [],
-        });
-    }
-    for (const edge of edges) {
-        const classKey = definitionRefIndex(edge.value.class);
-        const [source, target] = edge.declaration.orientation === 'undirected' &&
-            compareUnicode(edge.source.key, edge.target.key) > 0
-            ? [edge.target.key, edge.source.key]
-            : [edge.source.key, edge.target.key];
-        const key = `${classKey}\u0000${source}\u0000${target}`;
-        const previous = seen.get(key);
-        if (previous !== undefined) {
-            diagnostics.push(diagnostic('DV_CORE_EDGE_KEY', edge.pointer, `Core Edge duplicates the normalized EdgeKey declared at ${previous}.`));
-        }
-        else {
-            seen.set(key, edge.pointer);
-        }
-        const slice = edgeSlices.get(classKey) ?? {
-            declaration: edge.declaration,
-            edges: [],
-        };
-        slice.edges.push(edge);
-        edgeSlices.set(classKey, slice);
-        if (edge.declaration.constraints.noSelf === true && edge.source.key === edge.target.key) {
-            diagnostics.push(diagnostic('DV_CORE_EDGE_CONSTRAINTS', edge.pointer, 'Core Edge violates noSelf.'));
-        }
-    }
-    for (const { declaration, edges: classEdges } of edgeSlices.values()) {
-        if (declaration.constraints.acyclic === true && hasDirectedCycle(classEdges)) {
-            diagnostics.push(diagnostic('DV_CORE_EDGE_CONSTRAINTS', '/core/edges', 'Core Edge set violates exact-Class acyclicity.'));
-        }
-        validateCardinality(environment, declaration, classEdges, nodesByRef, diagnostics);
-    }
-}
-function validateCardinality(environment, declaration, edges, nodesByRef, diagnostics) {
-    const subjects = cardinalitySubjects(edges, nodesByRef);
-    if (declaration.orientation === 'undirected') {
-        const [first, second] = declaration.endpoints;
-        for (const subject of subjects) {
-            const matchesFirst = classSatisfies(environment, subject.classRef, first.accepts);
-            const matchesSecond = classSatisfies(environment, subject.classRef, second.accepts);
-            if (!matchesFirst && !matchesSecond)
-                continue;
-            const degree = edges.filter((edge) => edge.source.key === subject.key || edge.target.key === subject.key).length;
-            if (matchesFirst)
-                checkBound(first, first.incident, degree, subject, diagnostics);
-            if (matchesSecond && !sameIncidentEndpointContract(first, second)) {
-                checkBound(second, second.incident, degree, subject, diagnostics);
+    const { candidate } = environment;
+    const resolve = (ref) => environment.resolveAny(ref)?.declaration;
+    checkCoreEdgeSet({
+        edges: edges.map((edge) => ({
+            edge,
+            class: definitionRefIndex(edge.value.class),
+            contract: edge.declaration,
+            source: factEndpoint(edge.source, edge.pointer),
+            target: factEndpoint(edge.target, edge.pointer),
+        })),
+        classes: Object.entries(candidate.classes).flatMap(([name, declaration]) => {
+            if (declaration.kind !== 'edge')
+                return [];
+            const ref = { origin: candidate.origin, kind: 'class', name };
+            const resolved = environment.resolve(ref);
+            if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.kind !== 'edge') {
+                return [];
             }
-        }
-        return;
-    }
-    for (const subject of subjects) {
-        if (classSatisfies(environment, subject.classRef, declaration.endpoints.source.accepts)) {
-            const degree = edges.filter((edge) => edge.source.key === subject.key).length;
-            checkBound(declaration.endpoints.source, declaration.endpoints.source.outgoing, degree, subject, diagnostics);
-        }
-        if (classSatisfies(environment, subject.classRef, declaration.endpoints.target.accepts)) {
-            const degree = edges.filter((edge) => edge.target.key === subject.key).length;
-            checkBound(declaration.endpoints.target, declaration.endpoints.target.incoming, degree, subject, diagnostics);
-        }
-    }
-}
-/**
- * Every declared Core Node proves its own complete degree, so both bounds hold. A Definition
- * endpoint is only named by the Edges that reach it: the Domain may also create ordinary Edges of
- * the same Class against it, so a minimum is unprovable here and only the maximum is enforced.
- */
-function cardinalitySubjects(edges, nodesByRef) {
-    const subjects = new Map();
-    for (const node of nodesByRef.values()) {
-        subjects.set(node.key, {
+            return [
+                { key: definitionRefIndex(ref), contract: resolved.declaration },
+            ];
+        }),
+        nodes: [...nodesByRef.values()].map((node) => ({
             key: node.key,
-            classRef: node.classRef,
-            pointer: `/core/nodes/${escapePointer(node.slug)}`,
-            minimum: true,
-        });
-    }
-    for (const edge of edges) {
-        for (const endpoint of [edge.source, edge.target]) {
-            if (endpoint.kind !== 'member' || subjects.has(endpoint.key))
-                continue;
-            subjects.set(endpoint.key, {
-                key: endpoint.key,
-                classRef: endpoint.classRef,
-                pointer: edge.pointer,
-                minimum: false,
-            });
-        }
-    }
-    return Object.freeze([...subjects.values()]);
+            class: node.classRef,
+            pointer: nodePointer(node),
+        })),
+        satisfies: (ref, accepts) => classSatisfies(environment, ref, accepts),
+        keys: ({ edge }) => edgeUniqueKeys(coveringEdgeUniqueTuples(edge.declaration, resolve), {
+            source: edge.source.key,
+            target: edge.target.key,
+            props: edge.value.properties,
+        }),
+        sameIncident: sameIncidentEndpointContract,
+        report: (issue) => diagnostics.push(coreEdgeDiagnostic(issue)),
+    });
+}
+/** A projected member's degree, and the owning Domain's, is reported at the Edge that names it. */
+function factEndpoint(endpoint, pointer) {
+    return endpoint.kind === 'core'
+        ? endpoint
+        : { key: endpoint.key, member: { class: endpoint.classRef, pointer } };
 }
-function checkBound(endpoint, count, degree, subject, diagnostics) {
-    const [minimum, maximum] = countBounds(count);
-    if (degree <= maximum && (degree >= minimum || !subject.minimum))
-        return;
-    diagnostics.push(diagnostic('DV_CORE_EDGE_CONSTRAINTS', subject.pointer, `Core degree ${degree} violates ${endpoint.role} Edge count ${count}.`));
+function coreEdgeDiagnostic(issue) {
+    switch (issue.kind) {
+        case 'identity':
+            return diagnostic('DV_CORE_EDGE_KEY', issue.edge.pointer, `Core Edge duplicates the normalized EdgeKey declared at ${issue.previous.pointer}.`);
+        case 'no-self':
+            return diagnostic('DV_CORE_EDGE_CONSTRAINTS', issue.edge.pointer, 'Core Edge violates noSelf.');
+        case 'key':
+            return diagnostic('DV_CORE_EDGE_UNIQUE', issue.edge.pointer, `Core Edge holds a key the Core Edge at ${issue.previous.pointer} holds.`);
+        case 'acyclic':
+            return diagnostic('DV_CORE_EDGE_CONSTRAINTS', '/core/edges', 'Core Edge set violates exact-Class acyclicity.');
+        case 'degree':
+            return diagnostic('DV_CORE_EDGE_CONSTRAINTS', issue.pointer, `Core degree ${issue.degree} violates ${issue.endpoint.role} Edge count ${issue.count}.`);
+    }
 }
 function sameIncidentEndpointContract(left, right) {
     return (left.incident === right.incident &&
         left.accepts.length === right.accepts.length &&
         left.accepts.every((ref, index) => definitionRefIndex(ref) === definitionRefIndex(right.accepts[index])));
 }
-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];
-    }
-}
-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);
-}
-function escapePointer(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}