@astrale-os/kernel-dsl 1.0.0-beta.12 → 1.0.0-beta.14

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

@@ -1,12 +1,14 @@
+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 { createDomainValueSchemaRegistry, createValueSchemaRegistry, } from '../resolution/value.registry.js';
 const formatDefinitionRef = Key.of;
@@ -16,9 +18,9 @@ export function validateDefinitions(environment, analysis) {
     const schema = environment.candidate;
     let scope;
     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 &&
@@ -28,27 +30,25 @@ export function validateDefinitions(environment, analysis) {
         validateFacet(environment, 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(environment, analysis, ref, declaration, pointer, diagnostics);
     }
-    validateEdgeClassComposition(environment, diagnostics);
     return Object.freeze(diagnostics);
 }
 function validateFacet(environment, declaration, pointer, diagnostics) {
     const valueRegistry = createValueSchemaRegistry(environment);
     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();
@@ -92,7 +92,7 @@ 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)}`;
+        const methodPointer = `${pointer}/methods/${escapePointerToken(name)}`;
         if (isMethodExecutable(declaration, method))
             continue;
         if (method.policy !== undefined) {
@@ -107,7 +107,7 @@ function validateFacet(environment, declaration, pointer, diagnostics) {
 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;
@@ -120,23 +120,26 @@ function validateParents(environment, owner, ownerKind, parents, diagnostics) {
         }
     }
 }
-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.`));
-    }
-    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.'));
-        }
+        diagnostics.push(diagnostic('DV_EDGE_ROLE', `${pointer}/endpoints/${keys[1]}/role`, `${formatDefinitionRef(owner)} has equal endpoint roles.`));
     }
+    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:
@@ -188,25 +191,20 @@ function validateUniqueProperties(environment, analysis, owner, declaration, poi
             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.`));
         }
     }
 }
@@ -223,63 +221,24 @@ function validateEdgeLifetimes(scope, owner, declaration, pointer, diagnostics)
         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. */
-function validateEdgeClassComposition(environment, diagnostics) {
-    for (const resolved of environment.definitions.values()) {
-        if (resolved.ref.kind !== 'class' || resolved.declaration.kind !== 'edge')
+/**
+ * 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) {
@@ -294,12 +253,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,10 +1,13 @@
+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, } 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) {
@@ -15,38 +18,27 @@ export function validateCore(environment, analysis, registry) {
     validateCoreEdgeSet(environment, edges, nodesByRef, diagnostics);
     return Object.freeze(diagnostics);
 }
-/**
- * No two Core Nodes hold one key under a tuple covering their Classes, whichever Class or ancestor
- * declares it (DV-NODE-UNIQUE); Activation checks them against stored data.
- */
+/** 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;
-    const holders = new Map();
-    for (const node of nodesByRef.values()) {
+    checkHeldKeys(nodesByRef.values(), (node) => {
         const declaration = resolve(node.classRef);
         if (declaration === undefined)
-            continue;
-        const pointer = `/core/nodes/${escapePointer(node.slug)}`;
-        const keys = nodeUniqueKeys(coveringNodeUniqueTuples(declaration, resolve), {
+            return [];
+        return nodeUniqueKeys(coveringNodeUniqueTuples(declaration, resolve), {
             props: environment.candidate.core.nodes[node.slug].properties,
         });
-        const previous = keys.map((key) => holders.get(key)).find((at) => at !== undefined);
-        if (previous !== undefined) {
-            diagnostics.push(diagnostic('DV_CORE_NODE_UNIQUE', pointer, `Core Node holds a key the Core Node at ${previous} holds.`));
-        }
-        for (const key of keys)
-            if (!holders.has(key))
-                holders.set(key, pointer);
-    }
+    }, (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);
@@ -89,13 +81,7 @@ 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)));
             continue;
@@ -153,190 +139,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.'));
-        }
-    }
-    validateCoreEdgeKeys(environment, edges, diagnostics);
-    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);
-    }
-}
-/**
- * No two Core Edges hold one key under a tuple covering their Classes, whichever Class or ancestor
- * declares it (DV-EDGE-UNIQUE). Core Edges have no slug, so only tuples of endpoints and
- * Properties can bind them; Activation checks them against stored data.
- */
-function validateCoreEdgeKeys(environment, edges, diagnostics) {
+    const { candidate } = environment;
     const resolve = (ref) => environment.resolveAny(ref)?.declaration;
-    const holders = new Map();
-    for (const edge of edges) {
-        const keys = edgeUniqueKeys(coveringEdgeUniqueTuples(edge.declaration, resolve), {
+    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 [
+                { key: definitionRefIndex(ref), contract: resolved.declaration },
+            ];
+        }),
+        nodes: [...nodesByRef.values()].map((node) => ({
+            key: node.key,
+            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,
-        });
-        const previous = keys.map((key) => holders.get(key)).find((pointer) => pointer !== undefined);
-        if (previous !== undefined) {
-            diagnostics.push(diagnostic('DV_CORE_EDGE_UNIQUE', edge.pointer, `Core Edge holds a key the Core Edge at ${previous} holds.`));
-        }
-        for (const key of keys)
-            if (!holders.has(key))
-                holders.set(key, edge.pointer);
+        }),
+        sameIncident: sameIncidentEndpointContract,
+        report: (issue) => diagnostics.push(coreEdgeDiagnostic(issue)),
+    });
+}
+/** A projected member's degree is reported at the Edge that names it. */
+function factEndpoint(endpoint, pointer) {
+    return endpoint.kind === 'member'
+        ? { key: endpoint.key, member: { class: endpoint.classRef, pointer } }
+        : endpoint;
+}
+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 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);
-            }
-        }
-        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, {
-            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()]);
-}
-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 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');
-}

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

@@ -1,4 +1,4 @@
-import { compareUnicode } from '../../addressing/ordering.js';
+import { orderAndDeduplicate } from '../../language/validation/diagnostic.js';
 import { analyzeDefinitions } from '../analysis/class.js';
 import { buildDomainResolutionContext } from '../resolution/context.js';
 import { createValueSchemaRegistry } from '../resolution/value.registry.js';
@@ -27,12 +27,3 @@ export function validateDomainSchemaSemantics(schema, lookup) {
         diagnostics: Object.freeze(orderAndDeduplicate(diagnostics)),
     });
 }
-function orderAndDeduplicate(diagnostics) {
-    const unique = new Map();
-    for (const value of diagnostics) {
-        unique.set(`${value.pointer}\u0000${value.code}\u0000${value.ref ?? ''}\u0000${value.message}`, value);
-    }
-    return [...unique.values()].sort((left, right) => compareUnicode(left.pointer, right.pointer) ||
-        compareUnicode(left.code, right.code) ||
-        compareUnicode(left.message, right.message));
-}

package/dist/v1/schema/validation/domain.json-schema.d.ts

@@ -0,0 +1,15 @@
+import { type core as zodCore } from 'zod';
+export type JsonSchemaDocument = zodCore.JSONSchema.JSONSchema;
+/**
+ * The JSON Schema of an authored Domain schema document, rendered from the structure the Kernel
+ * enforces. Zod derives what it reads; `documentJsonSchema` states each refinement it cannot read,
+ * or names the rule JSON Schema cannot state. A refinement neither stated nor named fails the
+ * rendering, so that no check of the structure is dropped silently. Every value schema is in the
+ * published dialect and states the profile rules JSON Schema can state; the others are named.
+ */
+export declare function domainSchemaJsonSchema(): JsonSchemaDocument;
+/**
+ * Every refinement and custom part of the structure carries its statement in `documentJsonSchema`:
+ * the keywords that state it, or its named rule. Only parts zod renders take part.
+ */
+export declare function assertChecksStated(schema: zodCore.$ZodType, visited?: Set<zodCore.$ZodType<unknown, unknown, zodCore.$ZodTypeInternals<unknown, unknown>>>): void;