@astrale-os/kernel-core 0.9.0-beta.8 → 1.0.0-beta.1

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

@@ -1,96 +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">;
-//# sourceMappingURL=wire.d.ts.map
+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,34 +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) }),
 ]);
-//# 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,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;
@@ -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

@@ -2,11 +2,9 @@ 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;
 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,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))
@@ -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

@@ -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,19 +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;
-//# sourceMappingURL=correspondence.d.ts.map
+export {};

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

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

@@ -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,4 +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;
-//# sourceMappingURL=assess.d.ts.map
+export {};

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