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

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

@@ -6,6 +6,7 @@ import { GraphData } from '../../graph/index.js';
 import { NodeId as admitNodeId } from '../../node/index.js';
 import { compareNodeIds } from '../../node/index.js';
 import { encodeQueryAST, QueryASTDecodeError } from '../language/index.js';
+import { compareQueryRank, queryRangeContains } from '../order/index.js';
 import { decodeQueryResult } from '../result/index.js';
 import { QueryReferenceError } from './error.js';
 /** Independent backend-neutral executable Query V6 row algebra. */
@@ -141,8 +142,10 @@ function evaluate(ast, context, options) {
                     if (!Object.hasOwn(value.value.props, predicate.property)) {
                         return false;
                     }
-                    return (predicate.kind === 'property.present' ||
-                        portable.equal(value.value.props[predicate.property], predicate.value));
+                    const stored = value.value.props[predicate.property];
+                    if (predicate.kind === 'property.range')
+                        return queryRangeContains(predicate, stored);
+                    return predicate.kind === 'property.present' || portable.equal(stored, predicate.value);
                 });
             }
             stepRows.push(rows.length);
@@ -273,9 +276,13 @@ function decodeWitness(input, path, context) {
 }
 function selectNodes(rows, select, size, after, admission, properties) {
     const selected = new Map();
+    const ordered = orderedClasses(select.order, 'node', properties);
     rows.forEach((row) => {
         const node = boundNode(row, select.binding, '/select/binding');
-        const needsRead = select.kind === 'graph' || (select.kind === 'nodes' && select.projection.kind === 'value');
+        // A value is read; an ordered reference reads a fact its order applies to before ranking it.
+        const needsRead = select.kind === 'graph' ||
+            (select.kind === 'nodes' && select.projection.kind === 'value') ||
+            ordered.has(node.class);
         if (needsRead && !admission.readNode(node, '/select/binding'))
             return;
         selected.set(node.id, node);
@@ -305,6 +312,7 @@ function selectNodes(rows, select, size, after, admission, properties) {
 }
 function selectEdges(rows, select, size, after, context, admission, properties) {
     const selected = new Map();
+    const ordered = orderedClasses(select.order, 'edge', properties);
     rows.forEach((row) => {
         const edge = boundEdge(row, select.binding, '/select/binding');
         const source = requireNode(context, edge.source, '/select/binding');
@@ -319,7 +327,7 @@ function selectEdges(rows, select, size, after, context, admission, properties)
                 admission.readNode(source, '/select/binding') &&
                 admission.readNode(target, '/select/binding')
             : select.kind === 'edges'
-                ? (select.projection.edge === 'reference' ||
+                ? ((select.projection.edge === 'reference' && !ordered.has(edge.class)) ||
                     admission.readEdge(edge, '/select/binding')) &&
                     (select.projection.source === 'reference' ||
                         admission.readNode(source, '/select/binding')) &&
@@ -362,12 +370,24 @@ function selectEdges(rows, select, size, after, context, admission, properties)
     const next = last === undefined ? undefined : frontierOf(last, order, 'edge', properties);
     return Object.freeze({ result, ...(next === undefined ? {} : { next }) });
 }
+/** The Classes a Property order applies to, whose facts are read before they are ranked. */
+function orderedClasses(order, kind, properties) {
+    return order === undefined
+        ? new Set()
+        : properties.close(order.property, kind, '/select/order/property');
+}
 function orderingComparator(order, kind, properties) {
-    return (left, right) => compareReferenceRank(rankOf(left, order, kind, properties), rankOf(right, order, kind, properties), order);
+    const ordering = orderingOf(order, kind, properties);
+    return (left, right) => compareReferenceRank(rankOf(left, order, kind, properties), rankOf(right, order, kind, properties), order, ordering);
+}
+function orderingOf(order, kind, properties) {
+    return order === undefined
+        ? undefined
+        : properties.ordering(order.property, kind, '/select/order/property');
 }
 function compareFrontier(frontier, fact, order, kind, properties) {
     const admitted = decodeReferenceFrontier(frontier, order, kind, properties);
-    return compareReferenceRank(admitted, rankOf(fact, order, kind, properties), order);
+    return compareReferenceRank(admitted, rankOf(fact, order, kind, properties), order, orderingOf(order, kind, properties));
 }
 function frontierOf(fact, order, kind, properties) {
     const rank = rankOf(fact, order, kind, properties);
@@ -413,36 +433,8 @@ function decodeReferenceFrontier(frontier, order, kind, properties) {
     }
     return Object.freeze({ bucket: 'ranked', value: frontier.value, identity });
 }
-function compareReferenceRank(left, right, order) {
-    if (order === undefined)
-        return compareIdentity(left.identity, right.identity);
-    if (left.bucket !== right.bucket) {
-        return left.bucket === 'unranked'
-            ? order.unranked === 'first'
-                ? -1
-                : 1
-            : order.unranked === 'first'
-                ? 1
-                : -1;
-    }
-    if (left.bucket === 'ranked' && right.bucket === 'ranked') {
-        const kind = typeof left.value === 'boolean'
-            ? 'boolean'
-            : typeof left.value === 'number'
-                ? 'number'
-                : 'string';
-        const compared = compareOrderingValue(left.value, right.value, kind);
-        if (compared !== 0)
-            return order.direction === 'asc' ? compared : -compared;
-    }
-    return compareIdentity(left.identity, right.identity);
-}
-function compareIdentity(left, right) {
-    if (typeof left === 'string' && typeof right === 'string')
-        return compareNodeIds(left, right);
-    if (typeof left !== 'string' && typeof right !== 'string')
-        return compareEdgeKeys(left, right);
-    invalid('/after/identity', 'Frontier identity kind disagrees with selection');
+function compareReferenceRank(left, right, order, ordering) {
+    return compareQueryRank(left, right, order === undefined || ordering === undefined ? undefined : { ...order, kind: ordering });
 }
 function orderingValue(input, kind) {
     if (kind === 'boolean')
@@ -451,22 +443,6 @@ function orderingValue(input, kind) {
         return typeof input === 'number' && Number.isFinite(input);
     return typeof input === 'string';
 }
-function compareOrderingValue(left, right, kind) {
-    if (kind === 'boolean')
-        return Number(left) - Number(right);
-    if (kind === 'number')
-        return left - right;
-    return compareUnicodeScalars(left, right);
-}
-function compareUnicodeScalars(left, right) {
-    const a = Array.from(left, (value) => value.codePointAt(0));
-    const b = Array.from(right, (value) => value.codePointAt(0));
-    for (let index = 0; index < Math.min(a.length, b.length); index += 1) {
-        if (a[index] !== b[index])
-            return a[index] - b[index];
-    }
-    return a.length - b.length;
-}
 function projectNode(node, shape) {
     return shape === 'value'
         ? Object.freeze({ kind: 'value', value: node })
@@ -611,6 +587,15 @@ class Admission {
         const cached = this.#edges.get(key);
         if (cached !== undefined)
             return cached;
+        const source = requireNode(this.context, edge.source, path);
+        const target = requireNode(this.context, edge.target, path);
+        const admitted = call(path, 'Logical Edge fact admission failed', () => this.context.admitEdge(edge, source, target));
+        if (typeof admitted !== 'boolean')
+            invalid(path, 'Logical Edge fact admission must return boolean');
+        if (!admitted) {
+            this.#edges.set(key, false);
+            return false;
+        }
         const explicit = call(path, 'Edge traversal admission failed', () => this.context.traverseEdge(edge));
         if (typeof explicit !== 'boolean')
             invalid(path, 'Edge traversal admission must return boolean');
@@ -648,6 +633,7 @@ function acceptContext(input) {
         'closeClass',
         'closeProperty',
         'orientation',
+        'admitEdge',
         'traverseNode',
         'traverseEdge',
         'readNode',
@@ -671,6 +657,7 @@ function acceptContext(input) {
         closeClass: input.closeClass.bind(input),
         closeProperty: input.closeProperty.bind(input),
         orientation: input.orientation.bind(input),
+        admitEdge: input.admitEdge.bind(input),
         traverseNode: input.traverseNode.bind(input),
         traverseEdge: input.traverseEdge.bind(input),
         readNode: input.readNode.bind(input),

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

@@ -35,7 +35,7 @@ export function queryResultSelection(input) {
 /** Decode exact QueryResult structure; Query-relative closure remains Runtime-owned. */
 export function decodeQueryResult(input) {
     try {
-        const value = decodeWire(queryResultSchema, portable.accept(input), invalid);
+        const value = decodeWire(queryResultSchema, portable.acceptForRead(input), invalid);
         if (value.kind === 'graph') {
             const graph = decodeGraph(value.graph, '/graph');
             const selection = decodeSelection(value.selection, graph);

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

@@ -1,95 +1,94 @@
-import { z } from 'zod';
 /** Exact discriminated structural result; Runtime owns Query-relative closure and order. */
-export declare const queryResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    kind: z.ZodLiteral<"graph">;
-    graph: z.ZodObject<{
-        nodes: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            class: z.ZodString;
-            props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        }, z.core.$strict>>;
-        edges: z.ZodArray<z.ZodObject<{
-            source: z.ZodString;
-            target: z.ZodString;
-            class: z.ZodString;
-            slug: z.ZodOptional<z.ZodType<import("../../edge/index.js").EdgeSlug, unknown, z.core.$ZodTypeInternals<import("../../edge/index.js").EdgeSlug, unknown>>>;
-            props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>;
-    selection: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"node">;
-        ids: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"edge">;
-        keys: z.ZodArray<z.ZodObject<{
-            source: z.ZodString;
-            target: z.ZodString;
-            class: z.ZodString;
-        }, z.core.$strict>>;
-    }, z.core.$strict>], "kind">;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"nodes">;
-    nodes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"reference">;
-        value: z.ZodObject<{
-            id: z.ZodString;
-            class: z.ZodString;
-        }, z.core.$strict>;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"value">;
-        value: z.ZodObject<{
-            id: z.ZodString;
-            class: z.ZodString;
-            props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        }, z.core.$strict>;
-    }, z.core.$strict>], "kind">>;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"edges">;
-    edges: z.ZodArray<z.ZodObject<{
-        edge: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"reference">;
-            value: z.ZodObject<{
-                source: z.ZodString;
-                target: z.ZodString;
-                class: z.ZodString;
-            }, z.core.$strict>;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"value">;
-            value: z.ZodObject<{
-                source: z.ZodString;
-                target: z.ZodString;
-                class: z.ZodString;
-                slug: z.ZodOptional<z.ZodType<import("../../edge/index.js").EdgeSlug, unknown, z.core.$ZodTypeInternals<import("../../edge/index.js").EdgeSlug, unknown>>>;
-                props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-            }, z.core.$strict>;
-        }, z.core.$strict>], "kind">;
-        source: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"reference">;
-            value: z.ZodObject<{
-                id: z.ZodString;
-                class: z.ZodString;
-            }, z.core.$strict>;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"value">;
-            value: z.ZodObject<{
-                id: z.ZodString;
-                class: z.ZodString;
-                props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-            }, z.core.$strict>;
-        }, z.core.$strict>], "kind">;
-        target: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"reference">;
-            value: z.ZodObject<{
-                id: z.ZodString;
-                class: z.ZodString;
-            }, z.core.$strict>;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"value">;
-            value: z.ZodObject<{
-                id: z.ZodString;
-                class: z.ZodString;
-                props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-            }, z.core.$strict>;
-        }, z.core.$strict>], "kind">;
-    }, z.core.$strict>>;
-}, z.core.$strict>], "kind">;
+export declare const queryResultSchema: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+    kind: import("zod").ZodLiteral<"graph">;
+    graph: import("zod").ZodObject<{
+        nodes: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            class: import("zod").ZodString;
+            props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+        }, import("zod/v4/core").$strict>>;
+        edges: import("zod").ZodArray<import("zod").ZodObject<{
+            source: import("zod").ZodString;
+            target: import("zod").ZodString;
+            class: import("zod").ZodString;
+            slug: import("zod").ZodOptional<import("zod").ZodType<import("../../edge/index.js").EdgeSlug, unknown, import("zod/v4/core").$ZodTypeInternals<import("../../edge/index.js").EdgeSlug, unknown>>>;
+            props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+        }, import("zod/v4/core").$strict>>;
+    }, import("zod/v4/core").$strict>;
+    selection: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"node">;
+        ids: import("zod").ZodArray<import("zod").ZodString>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"edge">;
+        keys: import("zod").ZodArray<import("zod").ZodObject<{
+            source: import("zod").ZodString;
+            target: import("zod").ZodString;
+            class: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>>;
+    }, import("zod/v4/core").$strict>], "kind">;
+}, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+    kind: import("zod").ZodLiteral<"nodes">;
+    nodes: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"reference">;
+        value: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            class: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"value">;
+        value: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            class: import("zod").ZodString;
+            props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+        }, import("zod/v4/core").$strict>;
+    }, import("zod/v4/core").$strict>], "kind">>;
+}, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+    kind: import("zod").ZodLiteral<"edges">;
+    edges: import("zod").ZodArray<import("zod").ZodObject<{
+        edge: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"reference">;
+            value: import("zod").ZodObject<{
+                source: import("zod").ZodString;
+                target: import("zod").ZodString;
+                class: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"value">;
+            value: import("zod").ZodObject<{
+                source: import("zod").ZodString;
+                target: import("zod").ZodString;
+                class: import("zod").ZodString;
+                slug: import("zod").ZodOptional<import("zod").ZodType<import("../../edge/index.js").EdgeSlug, unknown, import("zod/v4/core").$ZodTypeInternals<import("../../edge/index.js").EdgeSlug, unknown>>>;
+                props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strict>], "kind">;
+        source: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"reference">;
+            value: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                class: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"value">;
+            value: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                class: import("zod").ZodString;
+                props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strict>], "kind">;
+        target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"reference">;
+            value: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                class: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"value">;
+            value: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                class: import("zod").ZodString;
+                props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strict>], "kind">;
+    }, import("zod/v4/core").$strict>>;
+}, import("zod/v4/core").$strict>], "kind">;

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

@@ -1,33 +1,33 @@
-import { z } from 'zod';
+import { array, discriminatedUnion, literal, strictObject, string } from 'zod';
 import { edgeKeySchema, graphDataSchema, graphEdgeSchema, graphNodeSchema, } from '#graph/graph/model/wire';
-const text = z.string().min(1);
-const nodeReference = z.strictObject({ id: text, class: text });
-const nodeProjection = z.discriminatedUnion('kind', [
-    z.strictObject({ kind: z.literal('reference'), value: nodeReference }),
-    z.strictObject({ kind: z.literal('value'), value: graphNodeSchema }),
+const text = string().min(1);
+const nodeReference = strictObject({ id: text, class: text });
+const nodeProjection = discriminatedUnion('kind', [
+    strictObject({ kind: literal('reference'), value: nodeReference }),
+    strictObject({ kind: literal('value'), value: graphNodeSchema }),
 ]);
-const edgeProjection = z.discriminatedUnion('kind', [
-    z.strictObject({ kind: z.literal('reference'), value: edgeKeySchema }),
-    z.strictObject({ kind: z.literal('value'), value: graphEdgeSchema }),
+const edgeProjection = discriminatedUnion('kind', [
+    strictObject({ kind: literal('reference'), value: edgeKeySchema }),
+    strictObject({ kind: literal('value'), value: graphEdgeSchema }),
 ]);
-const edgeItem = z.strictObject({
+const edgeItem = strictObject({
     edge: edgeProjection,
     source: nodeProjection,
     target: nodeProjection,
 });
 /** Exact discriminated structural result; Runtime owns Query-relative closure and order. */
-export const queryResultSchema = z.discriminatedUnion('kind', [
-    z.strictObject({
-        kind: z.literal('graph'),
+export const queryResultSchema = discriminatedUnion('kind', [
+    strictObject({
+        kind: literal('graph'),
         graph: graphDataSchema,
-        selection: z.discriminatedUnion('kind', [
-            z.strictObject({ kind: z.literal('node'), ids: z.array(text) }),
-            z.strictObject({ kind: z.literal('edge'), keys: z.array(edgeKeySchema) }),
+        selection: discriminatedUnion('kind', [
+            strictObject({ kind: literal('node'), ids: array(text) }),
+            strictObject({ kind: literal('edge'), keys: array(edgeKeySchema) }),
         ]),
     }),
-    z.strictObject({
-        kind: z.literal('nodes'),
-        nodes: z.array(nodeProjection),
+    strictObject({
+        kind: literal('nodes'),
+        nodes: array(nodeProjection),
     }),
-    z.strictObject({ kind: z.literal('edges'), edges: z.array(edgeItem) }),
+    strictObject({ kind: literal('edges'), edges: array(edgeItem) }),
 ]);

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

@@ -1,13 +1,13 @@
 import type { PropertyKey } from '@astrale-os/kernel-dsl/v1';
 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 { LocalAlias, MergeConflict as GraphMergeConflict } from '../../graph/index.js';
 import type { NodeId } from '../../node/index.js';
 import type { DesiredProperties } from '../../properties/index.js';
 import type { QueryEdgeAST, QueryNodeAST } from '../../query/index.js';
 declare const DESIRED_BRAND: unique symbol;
 export type DesiredNodeRef = NodeId | {
-    readonly desired: LocalBinding;
+    readonly desired: LocalAlias;
 };
 export interface DesiredEdgeRef {
     readonly source: DesiredNodeRef;

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

@@ -2,7 +2,6 @@ import type { DesiredEdge, DesiredEdgeRef, DesiredNode, DesiredNodeRef, Expectat
 import { type EdgeKey, type EdgeSlug } from '../../edge/index.js';
 export declare function admitDesiredNode(node: DesiredNode): DesiredNode;
 export declare function admitDesiredEdge(edge: DesiredEdge): DesiredEdge;
-export declare function admitNodeRef(ref: DesiredNodeRef): DesiredNodeRef;
 export declare function admitEdgeRef(ref: DesiredEdgeRef | EdgeKey): DesiredEdgeRef;
 export declare function equalExpectation(left: Expectation<EdgeSlug>, right: Expectation<EdgeSlug>): boolean;
 export declare function encodeDesiredNodeRef(ref: DesiredNodeRef): string;

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

@@ -1,6 +1,6 @@
 import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import { isEdgeSlug } from '../../edge/index.js';
-import { LocalBinding, isLocalBinding } from '../../graph/index.js';
+import { LocalAlias, isLocalAlias } from '../../graph/index.js';
 import { isNodeId } from '../../node/index.js';
 export function admitDesiredNode(node) {
     const ref = admitNodeRef(node.node);
@@ -29,14 +29,14 @@ export function admitDesiredEdge(edge) {
         properties: edge.properties,
     });
 }
-export function admitNodeRef(ref) {
+function admitNodeRef(ref) {
     if (typeof ref === 'string') {
         requireNodeId(ref);
         return ref;
     }
-    if (!isLocalBinding(ref.desired))
+    if (!isLocalAlias(ref.desired))
         throw new TypeError(`Invalid desired Node binding.`);
-    return Object.freeze({ desired: LocalBinding(ref.desired) });
+    return Object.freeze({ desired: LocalAlias(ref.desired) });
 }
 export function admitEdgeRef(ref) {
     if (!ClassKey.is(ref.class))

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

@@ -1,8 +1,8 @@
-import type { LocalBinding } from '../graph/index.js';
+import type { LocalAlias } from '../graph/index.js';
 import type { NodeId } from '../node/index.js';
 import type { QueryObservation } from './evidence.js';
 export type CorrespondenceEntry = {
-    readonly desired: LocalBinding;
+    readonly desired: LocalAlias;
     readonly kind: 'present';
     readonly node: NodeId;
     readonly observation: Extract<QueryObservation, {
@@ -11,7 +11,7 @@ export type CorrespondenceEntry = {
         };
     }>;
 } | {
-    readonly desired: LocalBinding;
+    readonly desired: LocalAlias;
     readonly kind: 'absent';
     readonly observation: Extract<QueryObservation, {
         readonly selection: {
@@ -24,18 +24,19 @@ export interface Correspondence {
 }
 export type CorrespondenceConflict = {
     readonly kind: 'correspondence-duplicate';
-    readonly desired: LocalBinding;
+    readonly desired: LocalAlias;
 } | {
     readonly kind: 'correspondence-noninjective';
     readonly node: NodeId;
-    readonly desired: readonly LocalBinding[];
+    readonly desired: readonly LocalAlias[];
 } | {
     readonly kind: 'correspondence-observation-invalid';
-    readonly desired: LocalBinding;
+    readonly desired: LocalAlias;
 };
-export interface CorrespondenceAnalysis {
-    readonly entries: ReadonlyMap<LocalBinding, CorrespondenceEntry>;
+interface CorrespondenceAnalysis {
+    readonly entries: ReadonlyMap<LocalAlias, CorrespondenceEntry>;
     readonly conflicts: readonly CorrespondenceConflict[];
 }
 /** Canonically index correspondence and classify duplicate or non-injective mappings. */
 export declare function analyzeCorrespondence(entries: readonly CorrespondenceEntry[]): CorrespondenceAnalysis;
+export {};

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

@@ -1,10 +1,10 @@
-import type { LocalBinding } from '../graph/index.js';
+import type { LocalAlias } from '../graph/index.js';
 import type { NodeId } from '../node/index.js';
 import type { QueryEdgeAST, QueryNodeAST, QuerySelection } from '../query/index.js';
 import { type EdgeKey } from '../edge/index.js';
 export type ObservationRequirement = {
     readonly kind: 'correspondence';
-    readonly desired: LocalBinding;
+    readonly desired: LocalAlias;
 } | {
     readonly kind: 'selection';
     readonly query: QueryNodeAST | QueryEdgeAST;

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

@@ -4,7 +4,7 @@ export type QueryPremise = Extract<ReconciliationPlan['premises'][number], {
     kind: 'query';
 }>;
 export type PointPremise = Exclude<ReconciliationPlan['premises'][number], QueryPremise>;
-export type MutationAssessment = {
+type MutationAssessment = {
     readonly kind: 'supported';
     readonly pointPremises: readonly PointPremise[];
     readonly queryPremises: readonly QueryPremise[];
@@ -14,3 +14,4 @@ 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;
+export {};

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

@@ -1,4 +1,4 @@
-import type { GraphData, LocalBinding } from '../graph/index.js';
+import type { GraphData, LocalAlias } from '../graph/index.js';
 import type { Node, NodeId } from '../node/index.js';
 import type { Correspondence, CorrespondenceEntry } from './correspondence.js';
 import type { EvidenceRequirement, ObservationEvidence } from './evidence.js';
@@ -16,11 +16,12 @@ export type ObservationConflict = {
     readonly kind: 'observation-evidence-contradiction';
     readonly requirement: EvidenceRequirement;
 };
-export interface ObservationAnalysis {
+interface ObservationAnalysis {
     readonly nodes: ReadonlyMap<NodeId, Node>;
     readonly edges: ReadonlyMap<string, Edge>;
     readonly evidence: readonly ObservationEvidence[];
     readonly conflicts: readonly ObservationConflict[];
 }
 /** Index finite facts and classify contradictory or duplicate evidence. */
-export declare function analyzeObservation(observation: Observation, correspondence: ReadonlyMap<LocalBinding, CorrespondenceEntry>): ObservationAnalysis;
+export declare function analyzeObservation(observation: Observation, correspondence: ReadonlyMap<LocalAlias, CorrespondenceEntry>): ObservationAnalysis;
+export {};

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

@@ -2,6 +2,12 @@ import { type ObservationRequirement } from '#graph/reconcile/evidence';
 import type { Effect, PlanningBlocker, PlanningConflict, Premise, ReconciliationPlan } from './model.js';
 export declare function canonicalRequirements(values: readonly ObservationRequirement[]): ObservationRequirement[];
 export declare function canonicalPremises(values: readonly Premise[]): Premise[];
+/**
+ * Distinct desired refs can name one target: an explicit NodeId and a binding whose
+ * correspondence observes that Node. Effects with one key and equal content collapse; effects with
+ * one key and different content contradict the desired state, which no transition can establish.
+ */
+export declare function contradictoryEffects(values: readonly Effect[]): PlanningConflict[];
 export declare function canonicalEffects(values: readonly Effect[]): Effect[];
 export declare function canonicalConflicts(values: readonly PlanningConflict[]): PlanningConflict[];
 export declare function canonicalBlockers(values: readonly PlanningBlocker[]): PlanningBlocker[];

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

@@ -1,3 +1,4 @@
+import * as portable from '@astrale-os/kernel-dsl/value';
 import { freezeRequirement, requirementKey, } from '#graph/reconcile/evidence';
 import { encodeEdgeKey } from '../../edge/index.js';
 export function canonicalRequirements(values) {
@@ -8,6 +9,30 @@ export function canonicalRequirements(values) {
 export function canonicalPremises(values) {
     return [...new Map(values.map((value) => [premiseKey(value), value])).values()].sort(comparePremises);
 }
+/**
+ * Distinct desired refs can name one target: an explicit NodeId and a binding whose
+ * correspondence observes that Node. Effects with one key and equal content collapse; effects with
+ * one key and different content contradict the desired state, which no transition can establish.
+ */
+export function contradictoryEffects(values) {
+    const groups = new Map();
+    for (const value of values) {
+        const key = effectKey(value);
+        const group = groups.get(key) ?? new Map();
+        group.set(portable.json.serialize(value), value);
+        groups.set(key, group);
+    }
+    const conflicts = [];
+    for (const group of groups.values()) {
+        if (group.size < 2)
+            continue;
+        conflicts.push({
+            kind: 'desired-target-contradictory',
+            effects: [...group].sort(([left], [right]) => compare(left, right)).map(([, value]) => value),
+        });
+    }
+    return conflicts;
+}
 export function canonicalEffects(values) {
     return [...new Map(values.map((value) => [effectKey(value), value])).values()].sort(compareEffects);
 }
@@ -66,6 +91,9 @@ function freezeConflict(value) {
     if (value.kind === 'correspondence-noninjective') {
         return Object.freeze({ ...value, desired: Object.freeze([...value.desired]) });
     }
+    if (value.kind === 'desired-target-contradictory') {
+        return Object.freeze({ ...value, effects: Object.freeze([...value.effects]) });
+    }
     return Object.freeze({ ...value });
 }
 function compare(left, right) {