@astrale-os/kernel-core 0.9.0-beta.7 → 0.9.0-beta.9

package/dist/graph/query/reference/evaluate.js

@@ -1,6 +1,6 @@
 import { PropertyKey, } from '@astrale-os/kernel-dsl/v1/addressing';
+import { ClassKey as admitClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import * as portable from '@astrale-os/kernel-dsl/value';
-import { ClassPath as admitClassPath } from '../../class/index.js';
 import { compareEdgeKeys, edgeKeyOf, encodeEdgeKey } from '../../edge/index.js';
 import { GraphData } from '../../graph/index.js';
 import { NodeId as admitNodeId } from '../../node/index.js';
@@ -33,7 +33,7 @@ export const QueryReference = Object.freeze({
 });
 function evaluate(ast, context, options) {
     const admission = new Admission(context);
-    const definitions = new Definitions(context);
+    const classes = new Classes(context);
     const properties = new PropertyClosures(context);
     let rows;
     let sourceRows;
@@ -48,9 +48,9 @@ function evaluate(ast, context, options) {
                 sourceFromPath(term.path, path, context, admission, source);
                 return;
             }
-            const classes = definitions.close(term.definition, 'node', `${path}/definition`);
+            const extent = classes.close(term.class, 'node', `${path}/class`);
             for (const node of context.graph.nodes) {
-                if (classes.has(node.class) && admission.node(node, `${path}/definition`)) {
+                if (extent.has(node.class) && admission.node(node, `${path}/class`)) {
                     source.set(node.id, node);
                 }
             }
@@ -61,15 +61,15 @@ function evaluate(ast, context, options) {
     }
     else {
         const edgeSource = ast.source;
-        const classes = new Set();
+        const extentClasses = new Set();
         edgeSource.terms.forEach((term, index) => {
-            for (const classPath of definitions.close(term.definition, 'edge', `/source/terms/${index}/definition`)) {
-                classes.add(classPath);
+            for (const classKey of classes.close(term.class, 'edge', `/source/terms/${index}/class`)) {
+                extentClasses.add(classKey);
             }
         });
         const source = new Map();
         for (const edge of context.graph.edges) {
-            if (!classes.has(edge.class))
+            if (!extentClasses.has(edge.class))
                 continue;
             const sourceNode = requireNode(context, edge.source, '/source');
             const targetNode = requireNode(context, edge.target, '/source');
@@ -100,12 +100,21 @@ function evaluate(ast, context, options) {
     ast.steps.forEach((step, index) => {
         const path = `/steps/${index}`;
         if (step.op === 'filter') {
-            if (step.predicate.kind === 'definition.satisfies') {
+            if (step.predicate.kind === 'class.satisfies' || step.predicate.kind === 'class.equal') {
                 const kind = kinds.get(step.binding);
                 if (kind === undefined)
                     invalid(`${path}/binding`, 'Filter binding is unavailable');
-                const classes = definitions.close(step.predicate.definition, kind, `${path}/predicate/definition`);
-                rows = rows.filter((row) => classes.has(boundValue(row, step.binding, `${path}/binding`).value.class));
+                const extent = classes.close(step.predicate.class, kind, `${path}/predicate/class`);
+                if (step.predicate.kind === 'class.satisfies') {
+                    rows = rows.filter((row) => extent.has(boundValue(row, step.binding, `${path}/binding`).value.class));
+                }
+                else {
+                    const exact = admitClassKey.of(step.predicate.class);
+                    rows = rows.filter((row) => {
+                        const value = boundValue(row, step.binding, `${path}/binding`).value;
+                        return value.class === exact;
+                    });
+                }
             }
             else if (step.predicate.kind === 'identity.equal') {
                 const predicate = step.predicate;
@@ -140,12 +149,12 @@ function evaluate(ast, context, options) {
             return;
         }
         const orientations = new Map();
-        step.via.forEach((definition, definitionIndex) => {
-            const classes = definitions.close(definition, 'edge', `${path}/via/${definitionIndex}`);
-            for (const edge of classes) {
-                const orientation = call(`${path}/via/${definitionIndex}`, 'Edge Class orientation could not be resolved', () => context.orientation(edge));
+        step.via.forEach((classRef, classIndex) => {
+            const extent = classes.close(classRef, 'edge', `${path}/via/${classIndex}`);
+            for (const edge of extent) {
+                const orientation = call(`${path}/via/${classIndex}`, 'Edge Class orientation could not be resolved', () => context.orientation(edge));
                 if (orientation !== 'directed' && orientation !== 'undirected') {
-                    invalid(`${path}/via/${definitionIndex}`, 'Definition closes to a non-Edge Class');
+                    invalid(`${path}/via/${classIndex}`, 'Class closes to a non-Edge Class');
                 }
                 orientations.set(edge, orientation);
             }
@@ -501,29 +510,28 @@ function boundValue(row, binding, path) {
         invalid(path, 'Binding is unavailable');
     return value;
 }
-class Definitions {
+class Classes {
     context;
     #cache = new Map();
     constructor(context) {
         this.context = context;
     }
-    close(definition, expected, path) {
-        const key = `${expected}\0${definition.origin}\0${definition.kind}\0${definition.name}`;
+    close(classRef, expected, path) {
+        const key = `${expected}\0${classRef.origin}\0${classRef.name}`;
         const cached = this.#cache.get(key);
         if (cached !== undefined)
             return cached;
-        const value = call(path, 'Definition closure failed', () => this.context.closeDefinition(definition));
-        if (value === undefined || !isRecord(value) || !exactKeys(value, ['family', 'classes'])) {
-            invalid(path, 'Definition is unresolved');
+        const value = call(path, 'Class closure failed', () => this.context.closeClass(classRef));
+        if (value === undefined || !isRecord(value) || !exactKeys(value, ['kind', 'classes'])) {
+            invalid(path, 'Class is unresolved');
         }
-        if ((value.family !== 'node' && value.family !== 'edge' && value.family !== 'both') ||
-            (value.family !== expected && value.family !== 'both')) {
-            invalid(path, `Definition is not ${expected}-capable`);
+        if (value.kind !== expected) {
+            invalid(path, `Class is not a ${expected} Class`);
         }
         if (!Array.isArray(value.classes))
-            invalid(`${path}/classes`, 'Classes must be an array');
-        const classes = value.classes.map((entry, index) => decodeClassPath(entry, `${path}/classes/${index}`));
-        unique(classes, (entry) => entry, `${path}/classes`, 'ClassPath');
+            invalid(`${path}/classes`, 'Class extent must be an array');
+        const classes = value.classes.map((entry, index) => decodeClassKey(entry, `${path}/classes/${index}`));
+        unique(classes, (entry) => entry, `${path}/classes`, 'ClassKey');
         const accepted = new Set(classes);
         this.#cache.set(key, accepted);
         return accepted;
@@ -563,8 +571,8 @@ class PropertyClosures {
         const inputClasses = value[kind === 'node' ? 'nodes' : 'edges'];
         if (!Array.isArray(inputClasses))
             invalid(path, 'Property Classes must be an array');
-        const classes = inputClasses.map((entry, index) => decodeClassPath(entry, `${path}/classes/${index}`));
-        unique(classes, (entry) => entry, `${path}/classes`, 'ClassPath');
+        const classes = inputClasses.map((entry, index) => decodeClassKey(entry, `${path}/classes/${index}`));
+        unique(classes, (entry) => entry, `${path}/classes`, 'ClassKey');
         const accepted = new Set(classes);
         this.#cache.set(cacheKey, accepted);
         this.#ordering.set(property, value.ordering);
@@ -637,7 +645,7 @@ function acceptContext(input) {
         invalid('', 'Reference context must be an object');
     for (const name of [
         'resolve',
-        'closeDefinition',
+        'closeClass',
         'closeProperty',
         'orientation',
         'traverseNode',
@@ -660,7 +668,7 @@ function acceptContext(input) {
         nodes: new Map(graph.nodes.map((node) => [node.id, node])),
         edges: new Map(graph.edges.map((edge) => [encodeEdgeKey(edge), edge])),
         resolve: input.resolve.bind(input),
-        closeDefinition: input.closeDefinition.bind(input),
+        closeClass: input.closeClass.bind(input),
         closeProperty: input.closeProperty.bind(input),
         orientation: input.orientation.bind(input),
         traverseNode: input.traverseNode.bind(input),
@@ -691,15 +699,12 @@ function decodeNodeId(input, path) {
         invalid(path, 'Invalid NodeId', cause);
     }
 }
-function decodeClassPath(input, path) {
+function decodeClassKey(input, path) {
     if (typeof input !== 'string')
-        invalid(path, 'Expected ClassPath string');
-    try {
-        return admitClassPath.parse(input);
-    }
-    catch (cause) {
-        invalid(path, 'Invalid ClassPath', cause);
-    }
+        invalid(path, 'Expected ClassKey string');
+    if (!admitClassKey.is(input))
+        invalid(path, 'Invalid ClassKey');
+    return admitClassKey(input);
 }
 function decodeEdgeKey(input, path) {
     if (!isRecord(input) || !exactKeys(input, ['source', 'target', 'class'])) {
@@ -708,7 +713,7 @@ function decodeEdgeKey(input, path) {
     return Object.freeze({
         source: decodeNodeId(input.source, `${path}/source`),
         target: decodeNodeId(input.target, `${path}/target`),
-        class: decodeClassPath(input.class, `${path}/class`),
+        class: decodeClassKey(input.class, `${path}/class`),
     });
 }
 function unique(values, keyOf, path, label) {
@@ -738,4 +743,3 @@ function isRecord(input) {
 function invalid(path, message, cause) {
     throw new QueryReferenceError(path, message, cause === undefined ? undefined : { cause });
 }
-//# sourceMappingURL=evaluate.js.map

package/dist/graph/query/reference/index.d.ts

@@ -1,4 +1,3 @@
 export { QueryReference } from './evaluate.js';
-export type { QueryReferenceContext, QueryReferenceDefinition, QueryReferenceEvaluation, QueryReferenceFrontier, QueryReferenceIdentity, QueryReferenceOptions, QueryReferencePathWitness, QueryReferenceProperty, QueryReferenceTrace, } from './evaluate.js';
+export type { QueryReferenceContext, QueryReferenceClassClosure, QueryReferenceEvaluation, QueryReferenceFrontier, QueryReferenceIdentity, QueryReferenceOptions, QueryReferencePathWitness, QueryReferenceProperty, QueryReferenceTrace, } from './evaluate.js';
 export { QueryReferenceError } from './error.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/query/reference/index.js

@@ -1,3 +1,2 @@
 export { QueryReference } from './evaluate.js';
 export { QueryReferenceError } from './error.js';
-//# sourceMappingURL=index.js.map

package/dist/graph/query/result/error.d.ts

@@ -3,4 +3,3 @@ export declare class QueryResultDecodeError extends TypeError {
     readonly code: 'QUERY_RESULT_INVALID';
     constructor(path: string, message: string, options?: ErrorOptions);
 }
-//# sourceMappingURL=error.d.ts.map

package/dist/graph/query/result/error.js

@@ -7,4 +7,3 @@ export class QueryResultDecodeError extends TypeError {
         this.name = 'QueryResultDecodeError';
     }
 }
-//# sourceMappingURL=error.js.map

package/dist/graph/query/result/index.d.ts

@@ -1,11 +1,11 @@
-import type { ClassPath as ClassPathValue } from '../../class/index.js';
+import type { ClassKey as ClassKeyValue } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { Edge, EdgeKey } from '../../edge/index.js';
 import type { GraphData as GraphDataValue } from '../../graph/index.js';
 import type { Node, NodeId as NodeIdValue } from '../../node/index.js';
 import type { EdgeBinding, NodeBinding, QueryAST, QueryEdgeProjection, QueryEdgeSelect, QueryGraphSelect, QueryNodeProjection, QueryNodeSelect, QueryProjectionShape, QuerySelect } from '../language/index.js';
 export interface QueryNodeReference {
     readonly id: NodeIdValue;
-    readonly class: ClassPathValue;
+    readonly class: ClassKeyValue;
 }
 export type QueryNodeItemFor<Projection extends QueryNodeProjection> = Projection extends {
     readonly kind: 'reference';
@@ -89,4 +89,3 @@ export declare function encodeQueryResult(input: QueryResult): QueryResult;
 export declare function queryResultSelection<Result extends QueryResult>(input: Result): QuerySelectionFor<Result>;
 /** Decode exact QueryResult structure; Query-relative closure remains Runtime-owned. */
 export declare function decodeQueryResult(input: unknown): QueryResult;
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/query/result/index.js

@@ -1,5 +1,5 @@
+import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import * as portable from '@astrale-os/kernel-dsl/value';
-import { ClassPath } from '../../class/index.js';
 import { edgeKeyOf, encodeEdgeKey } from '../../edge/index.js';
 import { GraphData, GraphDataDecodeError } from '../../graph/index.js';
 import { NodeId as admitNodeId } from '../../node/index.js';
@@ -71,7 +71,7 @@ function decodeNodeProjection(input, path) {
             kind: input.kind,
             value: Object.freeze({
                 id: decodeNodeId(value.id, `${path}/value/id`),
-                class: decodeClassPath(value.class, `${path}/value/class`),
+                class: decodeClassKey(value.class, `${path}/value/class`),
             }),
         });
     }
@@ -86,7 +86,7 @@ function decodeEdgeProjection(input, path) {
             value: Object.freeze({
                 source: decodeNodeId(value.source, `${path}/value/source`),
                 target: decodeNodeId(value.target, `${path}/value/target`),
-                class: decodeClassPath(value.class, `${path}/value/class`),
+                class: decodeClassKey(value.class, `${path}/value/class`),
             }),
         });
     }
@@ -114,13 +114,10 @@ function decodeNodeId(input, path) {
         invalid(path, 'Invalid NodeId', cause);
     }
 }
-function decodeClassPath(input, path) {
-    try {
-        return ClassPath.parse(input);
-    }
-    catch (cause) {
-        invalid(path, 'Invalid ClassPath', cause);
-    }
+function decodeClassKey(input, path) {
+    if (!ClassKey.is(input))
+        invalid(path, 'Invalid ClassKey');
+    return ClassKey(input);
 }
 function decodeSelection(input, graph) {
     if (input.kind === 'node') {
@@ -151,7 +148,7 @@ function decodeSelection(input, graph) {
             key = Object.freeze({
                 source: admitNodeId(entry.source),
                 target: admitNodeId(entry.target),
-                class: ClassPath.parse(entry.class),
+                class: ClassKey(entry.class),
             });
         }
         catch (cause) {
@@ -176,4 +173,3 @@ function joinPointer(base, nested) {
 function errorPointer(error) {
     return error instanceof portable.BoundaryError ? error.pointer : '';
 }
-//# sourceMappingURL=index.js.map

package/dist/graph/query/result/wire.d.ts

@@ -93,4 +93,3 @@ export declare const queryResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         }, z.core.$strict>], "kind">;
     }, z.core.$strict>>;
 }, z.core.$strict>], "kind">;
-//# sourceMappingURL=wire.d.ts.map

package/dist/graph/query/result/wire.js

@@ -31,4 +31,3 @@ export const queryResultSchema = z.discriminatedUnion('kind', [
     }),
     z.strictObject({ kind: z.literal('edges'), edges: z.array(edgeItem) }),
 ]);
-//# sourceMappingURL=wire.js.map

package/dist/graph/query/wire/index.d.ts

@@ -1,4 +1,3 @@
 /** Private compatibility facade for callable-admission Zod carriers. */
 export { queryAstSchema } from '../language/index.js';
 export { queryResultSchema } from '../result/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/query/wire/index.js

@@ -1,4 +1,3 @@
 /** Private compatibility facade for callable-admission Zod carriers. */
 export { queryAstSchema } from '../language/index.js';
 export { queryResultSchema } from '../result/index.js';
-//# sourceMappingURL=index.js.map

package/dist/graph/reconcile/condition/admit.d.ts

@@ -1,4 +1,3 @@
 import type { DesiredInput, DesiredResult } from './model.js';
 /** Admit and canonicalize one low-level desired-state declaration. */
 export declare function desired(input: DesiredInput): DesiredResult;
-//# sourceMappingURL=admit.d.ts.map

package/dist/graph/reconcile/condition/admit.js

@@ -8,4 +8,3 @@ export function desired(input) {
         createDesired((input.nodes ?? []).map(admitDesiredNode), (input.edges ?? []).map(admitDesiredEdge), (input.selections ?? []).map(admitDesiredSelection)),
     ]);
 }
-//# sourceMappingURL=admit.js.map

package/dist/graph/reconcile/condition/canonical.d.ts

@@ -1,4 +1,3 @@
 import type { Desired, DesiredEdge, DesiredNode, DesiredSelection } from './model.js';
 export declare function createDesired(nodes: readonly DesiredNode[], edges: readonly DesiredEdge[], selections?: readonly DesiredSelection[]): Desired;
 export declare function compare(left: string, right: string): number;
-//# sourceMappingURL=canonical.d.ts.map

package/dist/graph/reconcile/condition/canonical.js

@@ -8,4 +8,3 @@ export function createDesired(nodes, edges, selections = []) {
 export function compare(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
 }
-//# sourceMappingURL=canonical.js.map

package/dist/graph/reconcile/condition/combine.d.ts

@@ -3,4 +3,3 @@ import type { Desired, DesiredOperand, DesiredResult, ReconcileConflict } from '
 export declare function combine(...operands: readonly DesiredOperand[]): DesiredResult;
 export declare function combineDesired(values: readonly Desired[]): DesiredResult;
 export declare function sortConflicts(values: readonly ReconcileConflict[]): ReconcileConflict[];
-//# sourceMappingURL=combine.d.ts.map

package/dist/graph/reconcile/condition/combine.js

@@ -167,4 +167,3 @@ function nodeConflict(value) {
 function edgeConflict(value) {
     return Object.freeze({ kind: 'conflict', conflicts: Object.freeze([Object.freeze(value)]) });
 }
-//# sourceMappingURL=combine.js.map

package/dist/graph/reconcile/condition/ensure.d.ts

@@ -3,4 +3,3 @@ import type { Desired, EnsureInput } from './model.js';
 export declare function ensure(input: EnsureInput): Desired;
 /** Batch additive ensure over explicitly resolved desired references. */
 export declare function upsert(input: EnsureInput): Desired;
-//# sourceMappingURL=ensure.d.ts.map

package/dist/graph/reconcile/condition/ensure.js

@@ -27,4 +27,3 @@ function requireCombined(result) {
         throw new TypeError('Unexpected conflicting ensure input.');
     return result.value;
 }
-//# sourceMappingURL=ensure.js.map

package/dist/graph/reconcile/condition/fingerprint.d.ts

@@ -2,4 +2,3 @@ import type { Desired } from './model.js';
 export type DesiredFingerprint = `sha256:${string}`;
 /** Derive stable semantic identity from one canonical Desired value. */
 export declare function fingerprint(desired: Desired): DesiredFingerprint;
-//# sourceMappingURL=fingerprint.d.ts.map

package/dist/graph/reconcile/condition/fingerprint.js

@@ -15,4 +15,3 @@ export function fingerprint(desired) {
         hexadecimal += byte.toString(16).padStart(2, '0');
     return `sha256:${hexadecimal}`;
 }
-//# sourceMappingURL=fingerprint.js.map

package/dist/graph/reconcile/condition/index.d.ts

@@ -7,4 +7,3 @@ export { merge } from './merge.js';
 export type { Desired, DesiredEdge, DesiredEdgeRef, DesiredInput, DesiredNode, DesiredNodeRef, DesiredOperand, DesiredResult, DesiredSelection, EnsureEdge, EnsureInput, EnsureNode, Expectation, ManagedEdge, ManagedNode, ManagedScope, ReconcileConflict, } from './model.js';
 export { replace } from './replace.js';
 export { encodeDesiredEdgeRef, equalDesiredEdgeRefs, equalDesiredNodeRefs } from './references.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/reconcile/condition/index.js

@@ -5,4 +5,3 @@ export { fingerprint } from './fingerprint.js';
 export { merge } from './merge.js';
 export { replace } from './replace.js';
 export { encodeDesiredEdgeRef, equalDesiredEdgeRefs, equalDesiredNodeRefs } from './references.js';
-//# sourceMappingURL=index.js.map

package/dist/graph/reconcile/condition/merge.d.ts

@@ -2,4 +2,3 @@ import type { DesiredResult } from './model.js';
 import { type GraphData } from '../../graph/index.js';
 /** Express the non-conflicting exact three-way changes as a partial desired state. */
 export declare function merge(base: GraphData, current: GraphData, target: GraphData): DesiredResult;
-//# sourceMappingURL=merge.d.ts.map

package/dist/graph/reconcile/condition/merge.js

@@ -92,4 +92,3 @@ function desiredFromDifference(current, target) {
     }
     return desired({ nodes, edges });
 }
-//# sourceMappingURL=merge.js.map

package/dist/graph/reconcile/condition/model.d.ts

@@ -1,5 +1,5 @@
 import type { PropertyKey } from '@astrale-os/kernel-dsl/v1';
-import type { ClassPath } from '../../class/index.js';
+import type { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { EdgeKey, EdgeSlug } from '../../edge/index.js';
 import type { LocalBinding, MergeConflict as GraphMergeConflict } from '../../graph/index.js';
 import type { NodeId } from '../../node/index.js';
@@ -12,7 +12,7 @@ export type DesiredNodeRef = NodeId | {
 export interface DesiredEdgeRef {
     readonly source: DesiredNodeRef;
     readonly target: DesiredNodeRef;
-    readonly class: ClassPath;
+    readonly class: ClassKey;
 }
 export type Expectation<Value> = {
     readonly kind: 'equal';
@@ -23,7 +23,7 @@ export type Expectation<Value> = {
 export type DesiredNode = {
     readonly kind: 'present';
     readonly node: DesiredNodeRef;
-    readonly class: ClassPath;
+    readonly class: ClassKey;
     readonly properties: DesiredProperties;
 } | {
     readonly kind: 'absent';
@@ -67,7 +67,7 @@ export interface DesiredInput {
 }
 export interface EnsureNode {
     readonly node: DesiredNodeRef;
-    readonly class: ClassPath;
+    readonly class: ClassKey;
     readonly properties?: DesiredProperties;
 }
 export interface EnsureEdge {
@@ -134,4 +134,3 @@ export type DesiredResult = {
 /** A desired value or the typed result of constructing one. */
 export type DesiredOperand = Desired | DesiredResult;
 export {};
-//# sourceMappingURL=model.d.ts.map

package/dist/graph/reconcile/condition/model.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=model.js.map

package/dist/graph/reconcile/condition/references.d.ts

@@ -9,4 +9,3 @@ export declare function encodeDesiredNodeRef(ref: DesiredNodeRef): string;
 export declare function encodeDesiredEdgeRef(ref: DesiredEdgeRef): string;
 export declare function equalDesiredNodeRefs(left: DesiredNodeRef, right: DesiredNodeRef): boolean;
 export declare function equalDesiredEdgeRefs(left: DesiredEdgeRef, right: DesiredEdgeRef): boolean;
-//# sourceMappingURL=references.d.ts.map

package/dist/graph/reconcile/condition/references.js

@@ -1,4 +1,4 @@
-import { isClassPath } from '../../class/index.js';
+import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import { isEdgeSlug } from '../../edge/index.js';
 import { LocalBinding, isLocalBinding } from '../../graph/index.js';
 import { isNodeId } from '../../node/index.js';
@@ -6,7 +6,7 @@ export function admitDesiredNode(node) {
     const ref = admitNodeRef(node.node);
     if (node.kind === 'absent')
         return Object.freeze({ kind: 'absent', node: ref });
-    if (!isClassPath(node.class))
+    if (!ClassKey.is(node.class))
         throw new TypeError(`Invalid desired Node Class ${node.class}.`);
     return Object.freeze({
         kind: 'present',
@@ -39,7 +39,7 @@ export function admitNodeRef(ref) {
     return Object.freeze({ desired: LocalBinding(ref.desired) });
 }
 export function admitEdgeRef(ref) {
-    if (!isClassPath(ref.class))
+    if (!ClassKey.is(ref.class))
         throw new TypeError(`Invalid desired Edge Class ${ref.class}.`);
     return Object.freeze({
         source: admitNodeRef(ref.source),
@@ -74,4 +74,3 @@ function requireNodeId(input) {
     if (!isNodeId(input))
         throw new TypeError(`Invalid desired NodeId ${JSON.stringify(input)}.`);
 }
-//# sourceMappingURL=references.js.map

package/dist/graph/reconcile/condition/replace.d.ts

@@ -2,4 +2,3 @@ import type { GraphData } from '../../graph/index.js';
 import type { DesiredResult, ManagedScope } from './model.js';
 /** Make each explicitly managed coordinate equal its target value. */
 export declare function replace(scope: ManagedScope, target: GraphData): DesiredResult;
-//# sourceMappingURL=replace.d.ts.map

package/dist/graph/reconcile/condition/replace.js

@@ -82,4 +82,3 @@ function requireNodeId(input) {
     if (!isNodeId(input))
         throw new TypeError(`Invalid desired NodeId ${JSON.stringify(input)}.`);
 }
-//# sourceMappingURL=replace.js.map

package/dist/graph/reconcile/condition/selection.d.ts

@@ -5,4 +5,3 @@ export declare function admitDesiredSelection(input: DesiredSelection): DesiredS
 export declare function selectionKey(value: {
     readonly query: QueryNodeAST | QueryEdgeAST;
 }): string;
-//# sourceMappingURL=selection.d.ts.map

package/dist/graph/reconcile/condition/selection.js

@@ -40,4 +40,3 @@ export function admitDesiredSelection(input) {
 export function selectionKey(value) {
     return QueryAST.fingerprint(value.query);
 }
-//# sourceMappingURL=selection.js.map

package/dist/graph/reconcile/correspondence.d.ts

@@ -39,4 +39,3 @@ export interface CorrespondenceAnalysis {
 }
 /** Canonically index correspondence and classify duplicate or non-injective mappings. */
 export declare function analyzeCorrespondence(entries: readonly CorrespondenceEntry[]): CorrespondenceAnalysis;
-//# sourceMappingURL=correspondence.d.ts.map

package/dist/graph/reconcile/correspondence.js

@@ -41,4 +41,3 @@ export function analyzeCorrespondence(entries) {
 function compare(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
 }
-//# sourceMappingURL=correspondence.js.map

package/dist/graph/reconcile/evidence.d.ts

@@ -47,4 +47,3 @@ export declare function validQueryObservation(observation: QueryObservation): bo
 export declare function findEvidence(requirement: ObservationRequirement, evidence: readonly ObservationEvidence[]): ObservationEvidence | undefined;
 export declare function requirementKey(value: ObservationRequirement): string;
 export declare function freezeRequirement<Value extends ObservationRequirement>(value: Value): Value;
-//# sourceMappingURL=evidence.d.ts.map

package/dist/graph/reconcile/evidence.js

@@ -52,4 +52,3 @@ export function freezeRequirement(value) {
             ? { ...value, edge: Object.freeze({ ...value.edge }) }
             : { ...value });
 }
-//# sourceMappingURL=evidence.js.map

package/dist/graph/reconcile/index.d.ts

@@ -25,4 +25,3 @@ export type { EvidenceRequirement, ObservationEvidence, ObservationRequirement,
 export type { Observation } from './observation.js';
 export type { Effect, EdgePremise, NodePremise, PlanResult, PlanningBlocker, PlanningConflict, Premise, QueryPremise, ReconciliationPlan, ResolvedEdgeRef, ResolvedNodeRef, } from './planning/index.js';
 export { ReconcileReference };
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/reconcile/index.js

@@ -12,4 +12,3 @@ export const Reconcile = Object.freeze({
     reference: ReconcileReference,
 });
 export { ReconcileReference };
-//# sourceMappingURL=index.js.map

package/dist/graph/reconcile/mutation/assess.d.ts

@@ -14,4 +14,3 @@ export type MutationAssessment = {
 };
 /** Classify whether one complete semantic plan fits the target's atomic Mutation profile. */
 export declare function assess(plan: ReconciliationPlan, profile: MutationRealizationProfile): MutationAssessment;
-//# sourceMappingURL=assess.d.ts.map

package/dist/graph/reconcile/mutation/assess.js

@@ -56,4 +56,3 @@ function requireBound(name, value) {
         throw new TypeError(`${name} must be a non-negative safe integer.`);
     }
 }
-//# sourceMappingURL=assess.js.map

package/dist/graph/reconcile/mutation/index.d.ts

@@ -4,4 +4,3 @@ export declare const MutationReconcile: {
     realize(plan: ReconciliationPlan, profile: MutationRealizationProfile): MutationRealizationResult;
 };
 export type { MutationRealizationBlocker, MutationRealizationProfile, MutationRealizationResult, } from './model.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/reconcile/mutation/index.js

@@ -1,3 +1,2 @@
 import { realize } from './realize.js';
 export const MutationReconcile = Object.freeze({ realize });
-//# sourceMappingURL=index.js.map

package/dist/graph/reconcile/mutation/model.d.ts

@@ -31,4 +31,3 @@ export type MutationRealizationResult = {
     readonly plan: ReconciliationPlan;
     readonly blockers: readonly MutationRealizationBlocker[];
 };
-//# sourceMappingURL=model.d.ts.map

package/dist/graph/reconcile/mutation/model.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=model.js.map

package/dist/graph/reconcile/mutation/operations.d.ts

@@ -2,4 +2,3 @@ import type { MutationInputOperation } from '../../mutate/index.js';
 import type { Effect } from '../planning/index.js';
 /** Lower one semantic effect to its exact Mutation V3 operation. */
 export declare function lowerOperation(effect: Effect): MutationInputOperation;
-//# sourceMappingURL=operations.d.ts.map

package/dist/graph/reconcile/mutation/operations.js

@@ -53,4 +53,3 @@ export function lowerOperation(effect) {
             };
     }
 }
-//# sourceMappingURL=operations.js.map

package/dist/graph/reconcile/mutation/preconditions.d.ts

@@ -7,4 +7,3 @@ export declare function lowerPrecondition(premise: PointPremise): MutationInputP
 export declare function lowerQueryPrecondition(premise: Extract<Premise, {
     readonly kind: 'query';
 }>): MutationInputPrecondition;
-//# sourceMappingURL=preconditions.d.ts.map

package/dist/graph/reconcile/mutation/preconditions.js

@@ -52,4 +52,3 @@ function conditions(desired) {
         }
         : undefined;
 }
-//# sourceMappingURL=preconditions.js.map

package/dist/graph/reconcile/mutation/realize.d.ts

@@ -2,4 +2,3 @@ import type { ReconciliationPlan } from '../planning/index.js';
 import type { MutationRealizationProfile, MutationRealizationResult } from './model.js';
 /** Lower one complete semantic plan only when Mutation V3 preserves every premise and effect. */
 export declare function realize(plan: ReconciliationPlan, profile: MutationRealizationProfile): MutationRealizationResult;
-//# sourceMappingURL=realize.d.ts.map

package/dist/graph/reconcile/mutation/realize.js

@@ -23,4 +23,3 @@ export function realize(plan, profile) {
         }),
     });
 }
-//# sourceMappingURL=realize.js.map