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

package/dist/callable/invocation/call.d.ts

@@ -1,7 +1,21 @@
-import type { NodePath } from '@astrale-os/kernel-core/path';
+import type { Key } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { Value } from '@astrale-os/kernel-dsl/value';
+import { type NodePath } from '@astrale-os/kernel-core/path';
+/**
+ * One declaration, optionally bound to an instance and to the caller's expectation of it: the
+ * fingerprint of the callable meaning it compiled against.
+ */
+export type Target = {
+    readonly callable: Key.Callable;
+    readonly instance?: NodePath;
+    readonly fingerprint?: `sha256:${string}`;
+};
+/** Capture a structured invocation target at a representation boundary. */
+export declare function Target(input: Target): Target;
+/** Project an admitted target to its canonical graph path without discarding the original Call. */
+export declare function targetPath(target: NodePath | Target): NodePath;
 /** One canonical callable invocation meaning, independent of its carrier. */
 export interface Call {
-    readonly target: NodePath;
+    readonly target: NodePath | Target;
     readonly input: Value;
 }

package/dist/callable/invocation/call.js

@@ -1 +1,41 @@
-export {};
+import { Path } from '@astrale-os/kernel-core/path';
+import { callableAddress } from '@astrale-os/kernel-dsl/v1/addressing';
+const FINGERPRINT_PATTERN = /^sha256:[0-9a-f]{64}$/u;
+/** Capture a structured invocation target at a representation boundary. */
+export function Target(input) {
+    if (input === null ||
+        typeof input !== 'object' ||
+        Array.isArray(input) ||
+        Reflect.ownKeys(input).some((field) => !['callable', 'instance', 'fingerprint'].includes(String(field)))) {
+        throw new TypeError('Invocation Target must contain only callable, instance and fingerprint.');
+    }
+    const callable = input.callable;
+    const coordinate = callableAddress(callable);
+    const fingerprint = input.fingerprint;
+    if (fingerprint !== undefined &&
+        (typeof fingerprint !== 'string' || !FINGERPRINT_PATTERN.test(fingerprint))) {
+        throw new TypeError('Invocation Target fingerprint is invalid.');
+    }
+    const suppliedInstance = input.instance;
+    const instance = suppliedInstance === undefined ? undefined : Path.parse(suppliedInstance);
+    if (instance !== undefined &&
+        (coordinate.kind !== 'method' || instance.ast.steps.at(-1)?.kind === 'method')) {
+        throw new TypeError('Only an instance Method target can carry a node instance path.');
+    }
+    return Object.freeze({
+        callable,
+        ...(instance === undefined ? {} : { instance: instance.raw }),
+        ...(fingerprint === undefined ? {} : { fingerprint }),
+    });
+}
+/** Project an admitted target to its canonical graph path without discarding the original Call. */
+export function targetPath(target) {
+    if (typeof target === 'string')
+        return target;
+    const coordinate = callableAddress(target.callable);
+    if (coordinate.kind === 'function')
+        return Path.project(coordinate).raw;
+    return target.instance === undefined
+        ? Path.staticMethod(Path.project(coordinate.owner), coordinate.name).raw
+        : Path.instanceMethod(Path.parse(target.instance), target.callable).raw;
+}

package/dist/callable/invocation/index.d.ts

@@ -1,2 +1,2 @@
-export type { Call } from './call.js';
+export { Target, targetPath, type Call } from './call.js';
 export type { CallableResult } from './result.js';

package/dist/callable/invocation/index.js

@@ -1 +1 @@
-export {};
+export { Target, targetPath } from './call.js';

package/dist/callable/invocation/result.d.ts

@@ -1,5 +1,9 @@
-import type { BinaryResult } from '../contract/index.js';
-/** Successful callable output modes parameterized by the owner's stream capability. */
+import type { NodeId } from '@astrale-os/kernel-core/graph/node';
+import type { BinaryOutput } from '../contract/index.js';
+/**
+ * Successful result of invoking a callable: its output in the declared mode, or the Execution a
+ * durable callable started, whose outcome later carries that output.
+ */
 export type CallableResult<Output, Stream extends AsyncIterable<Output>> = {
     readonly kind: 'value';
     readonly value: Output;
@@ -8,5 +12,8 @@ export type CallableResult<Output, Stream extends AsyncIterable<Output>> = {
     readonly stream: Stream;
 } | {
     readonly kind: 'binary';
-    readonly value: BinaryResult;
+    readonly value: BinaryOutput;
+} | {
+    readonly kind: 'execution';
+    readonly execution: NodeId;
 };

package/dist/dns-label.d.ts

@@ -1,4 +1,3 @@
-import { z } from 'zod';
 /**
  * Canonical RFC 1035 §2.3.4 DNS label: lowercase alphanumeric + hyphen, no
  * leading/trailing hyphen, 1–63 characters.
@@ -22,4 +21,4 @@ export declare function assertDnsLabel(value: string, name: string): void;
  * instance id / public slug so non-DNS-safe values are rejected at parse time
  * (the `.max(63)`/`.min(1)` give clear length errors before the regex check).
  */
-export declare const dnsLabelSchema: z.ZodString;
+export declare const dnsLabelSchema: import("zod").ZodString;

package/dist/dns-label.js

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { string } from 'zod';
 /**
  * Canonical RFC 1035 §2.3.4 DNS label: lowercase alphanumeric + hyphen, no
  * leading/trailing hyphen, 1–63 characters.
@@ -28,8 +28,7 @@ export function assertDnsLabel(value, name) {
  * instance id / public slug so non-DNS-safe values are rejected at parse time
  * (the `.max(63)`/`.min(1)` give clear length errors before the regex check).
  */
-export const dnsLabelSchema = z
-    .string()
+export const dnsLabelSchema = string()
     .min(1)
     .max(63)
     .regex(DNS_LABEL_RE, 'must be a lowercase DNS label [a-z0-9-], ≤63 chars, no leading/trailing hyphen');

package/dist/graph/graph/graph.d.ts

@@ -1,18 +1,15 @@
-import type { Node } from '../node/index.js';
-import type { PathLike } from '../path/index.js';
 import type { GraphAdmissionContext } from './admission/index.js';
 import type { Delta, DeltaResult } from './delta/index.js';
 import type { GraphEdges, GraphNodes } from './indexes/index.js';
 import type { MergeResult } from './merge/index.js';
 import type { GraphData } from './model/index.js';
-import type { GraphPathWalker } from './navigation/index.js';
 /** Immutable indexed behavioral view over exactly one admitted GraphData value. */
 export declare class Graph {
     #private;
     readonly nodes: GraphNodes;
     readonly edges: GraphEdges;
     private constructor();
-    static admit(data: GraphData, context: GraphAdmissionContext, walker?: GraphPathWalker): Graph;
+    static admit(data: GraphData, context: GraphAdmissionContext): Graph;
     static empty(): Graph;
     /** Compare reference-open observations without deriving deletion from absence. */
     static delta(left: Graph, right: Graph): DeltaResult;
@@ -22,7 +19,6 @@ export declare class Graph {
     static merge(base: Graph, current: Graph, target: Graph): MergeResult;
     /** Apply the same exact merge rule to canonical finite values without schema re-admission. */
     static mergeData(base: GraphData, current: GraphData, target: GraphData): MergeResult;
-    walk(path: PathLike): Node | undefined;
     toData(): GraphData;
     equals(other: Graph): boolean;
 }

package/dist/graph/graph/graph.js

@@ -1,11 +1,9 @@
 import { edgeKeyOf } from '../edge/index.js';
-import { Path } from '../path/index.js';
 import { equal as equalProperties } from '../properties/index.js';
 import { admitGraphData } from './admission/index.js';
 import { apply as applyDelta, delta as graphDelta } from './delta/index.js';
 import { buildIndexes, createCollections } from './indexes/index.js';
 import { mergeData as mergeGraphData } from './merge/index.js';
-import { GraphPathWalkerRequiredError } from './navigation/index.js';
 const EMPTY_DATA = Object.freeze({
     nodes: Object.freeze([]),
     edges: Object.freeze([]),
@@ -17,30 +15,17 @@ export class Graph {
     nodes;
     edges;
     #data;
-    #indexes;
-    #walker;
-    #pathContext;
-    constructor(data, indexes, walker) {
+    constructor(data, indexes) {
         this.#data = data;
-        this.#indexes = indexes;
-        this.#walker = walker;
         const collections = createCollections(data.nodes, data.edges, indexes);
         this.nodes = collections.nodes;
         this.edges = collections.edges;
-        this.#pathContext = Object.freeze({
-            nodes: this.nodes,
-            edges: this.edges,
-            orientation: (classKey) => {
-                const info = this.#indexes.classes.byKey.get(classKey);
-                return info?.kind === 'edge' ? info.orientation : undefined;
-            },
-        });
         Object.freeze(this);
     }
-    static admit(data, context, walker) {
+    static admit(data, context) {
         const admitted = admitGraphData(data, context);
         const indexes = buildIndexes(admitted.data.nodes, admitted.data.edges, admitted.classes);
-        return new Graph(admitted.data, indexes, walker);
+        return new Graph(admitted.data, indexes);
     }
     static empty() {
         return Graph.#EMPTY;
@@ -61,15 +46,6 @@ export class Graph {
     static mergeData(base, current, target) {
         return mergeGraphData(base, current, target);
     }
-    walk(path) {
-        const value = Path.from(path);
-        if (this.#walker !== undefined)
-            return this.#walker.walk(value, this.#pathContext);
-        if (value.ast.anchor.kind === 'id' && value.ast.steps.length === 0) {
-            return this.#indexes.nodes.byId.get(value.ast.anchor.id);
-        }
-        throw new GraphPathWalkerRequiredError(value.raw);
-    }
     toData() {
         return this.#data;
     }

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

@@ -1,12 +1,10 @@
-/** Stable aggregate facade over Graph model, admission, indexes, navigation, delta, and merge. */
+/** Stable aggregate facade over Graph model, admission, indexes, delta, and merge. */
 export { Graph } from './graph.js';
 export type { Delta, DeltaConflict, DeltaResult } from './delta/index.js';
 export type { MergeConflict, MergeResult } from './merge/index.js';
 export { GraphData, GraphDataDecodeError, GraphSpec, GraphSpecDecodeError } from './model/index.js';
 export type { AnonymousNodeSpec, GraphDataJson, GraphSpecEdge, GraphSpecEndpoint, GraphSpecJson, GraphSpecNode, } from './model/index.js';
-export { LocalBinding, isLocalBinding } from './model/index.js';
+export { LocalAlias, isLocalAlias } from './model/index.js';
 export type { GraphAdmissionContext, GraphClassInfo, GraphDiagnostic } from './admission/index.js';
 export { GraphAdmissionError } from './admission/index.js';
 export type { GraphEdges, GraphNodes } from './indexes/index.js';
-export type { GraphPathContext, GraphPathWalker } from './navigation/index.js';
-export { GraphPathAmbiguousError, GraphPathWalkerRequiredError } from './navigation/index.js';

package/dist/graph/graph/index.js

@@ -1,6 +1,5 @@
-/** Stable aggregate facade over Graph model, admission, indexes, navigation, delta, and merge. */
+/** Stable aggregate facade over Graph model, admission, indexes, delta, and merge. */
 export { Graph } from './graph.js';
 export { GraphData, GraphDataDecodeError, GraphSpec, GraphSpecDecodeError } from './model/index.js';
-export { LocalBinding, isLocalBinding } from './model/index.js';
+export { LocalAlias, isLocalAlias } from './model/index.js';
 export { GraphAdmissionError } from './admission/index.js';
-export { GraphPathAmbiguousError, GraphPathWalkerRequiredError } from './navigation/index.js';

package/dist/graph/graph/model/codec.js

@@ -5,7 +5,7 @@ import { node as constructNode, NodeId } from '../../node/index.js';
 import { NodePath } from '../../path/index.js';
 import { normalizeProperties } from '../../properties/index.js';
 import { decodeWire } from '../../wire.js';
-import { isLocalBinding, LocalBinding } from './model.js';
+import { isLocalAlias, LocalAlias } from './model.js';
 import { graphSpecSchema } from './wire.js';
 export class GraphDataDecodeError extends TypeError {
     path;
@@ -28,7 +28,7 @@ export class GraphSpecDecodeError extends TypeError {
 /** Strengthen unknown JSON into detached immutable structural graph values. */
 export function decodeGraphSpec(input) {
     try {
-        const value = decodeWire(graphSpecSchema, portable.accept(input), specInvalid);
+        const value = decodeWire(graphSpecSchema, portable.acceptForRead(input), specInvalid);
         const nodes = value.nodes.map((node, index) => decodeSpecNode(node, `/nodes/${index}`));
         const edges = value.edges.map((edge, index) => decodeSpecEdge(edge, `/edges/${index}`));
         validateGraphSpec(nodes, edges);
@@ -124,10 +124,10 @@ function decodeEndpoint(input, path) {
     return Object.freeze({ created: binding(input.created, `${path}/created`) });
 }
 function binding(input, path) {
-    if (!isLocalBinding(input)) {
+    if (!isLocalAlias(input)) {
         specInvalid(path, 'Expected a local binding name of at most 64 characters');
     }
-    return LocalBinding(input);
+    return LocalAlias(input);
 }
 function validateGraphSpec(nodes, edges) {
     const ids = new Set();

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

@@ -13,5 +13,5 @@ export declare const GraphSpec: {
     encode(spec: GraphSpecValue): GraphSpecJson;
 };
 export type { AnonymousNodeSpec, GraphSpecEdge, GraphSpecEndpoint, GraphSpecJson, GraphSpecNode, } from './model.js';
-export { LocalBinding, isLocalBinding } from './model.js';
+export { LocalAlias, isLocalAlias } from './model.js';
 export { GraphSpecDecodeError } from './codec.js';

package/dist/graph/graph/model/index.js

@@ -2,5 +2,5 @@ import { decodeGraphData, decodeGraphSpec, encodeGraphData, encodeGraphSpec } fr
 export const GraphData = Object.freeze({ decode: decodeGraphData, encode: encodeGraphData });
 export { GraphDataDecodeError } from './codec.js';
 export const GraphSpec = Object.freeze({ decode: decodeGraphSpec, encode: encodeGraphSpec });
-export { LocalBinding, isLocalBinding } from './model.js';
+export { LocalAlias, isLocalAlias } from './model.js';
 export { GraphSpecDecodeError } from './codec.js';

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

@@ -2,21 +2,21 @@ import type { EdgeSpec } from '../../edge/index.js';
 import type { Node, NodeId, NodeSpec } from '../../node/index.js';
 import type { NodePath } from '../../path/index.js';
 import type { Properties } from '../../properties/index.js';
-declare const LOCAL_BINDING_BRAND: unique symbol;
+declare const LOCAL_ALIAS_BRAND: unique symbol;
 /** A graph-local lexical name. It is never Node identity. */
-export type LocalBinding = string & {
-    readonly [LOCAL_BINDING_BRAND]: true;
+export type LocalAlias = string & {
+    readonly [LOCAL_ALIAS_BRAND]: true;
 };
-export declare function LocalBinding(input: string): LocalBinding;
-export declare function isLocalBinding(input: unknown): input is LocalBinding;
+export declare function LocalAlias(input: string): LocalAlias;
+export declare function isLocalAlias(input: unknown): input is LocalAlias;
 export interface AnonymousNodeSpec extends NodeSpec {
-    readonly as: LocalBinding;
+    readonly as: LocalAlias;
 }
 export type GraphSpecNode = Node | AnonymousNodeSpec;
 export type GraphSpecEndpoint = NodeId | {
     readonly path: NodePath;
 } | {
-    readonly created: LocalBinding;
+    readonly created: LocalAlias;
 };
 export type GraphSpecEdge = EdgeSpec<GraphSpecEndpoint>;
 /** Detached structural graph values, including graph-local anonymous Nodes. */

package/dist/graph/graph/model/model.js

@@ -1,10 +1,10 @@
-const LOCAL_BINDING_PATTERN = /^[A-Za-z][A-Za-z0-9_]{0,63}$/u;
-export function LocalBinding(input) {
-    if (!isLocalBinding(input)) {
-        throw new TypeError(`Invalid local binding ${JSON.stringify(input)}.`);
+const LOCAL_ALIAS_PATTERN = /^[A-Za-z][A-Za-z0-9_]{0,63}$/u;
+export function LocalAlias(input) {
+    if (!isLocalAlias(input)) {
+        throw new TypeError(`Invalid local alias ${JSON.stringify(input)}.`);
     }
     return input;
 }
-export function isLocalBinding(input) {
-    return typeof input === 'string' && LOCAL_BINDING_PATTERN.test(input);
+export function isLocalAlias(input) {
+    return typeof input === 'string' && LOCAL_ALIAS_PATTERN.test(input);
 }

package/dist/graph/graph/model/wire.d.ts

@@ -1,79 +1,59 @@
-import { z } from 'zod';
+import { type ZodType } from 'zod';
 import { type EdgeSlug } from '../../edge/index.js';
-export declare const graphNodeSchema: z.ZodObject<{
-    id: z.ZodString;
-    class: z.ZodString;
-    props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-}, z.core.$strict>;
-export declare const anonymousGraphNodeSchema: z.ZodObject<{
-    as: z.ZodString;
-    class: z.ZodString;
-    props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-}, z.core.$strict>;
-export declare const edgeKeySchema: z.ZodObject<{
-    source: z.ZodString;
-    target: z.ZodString;
-    class: z.ZodString;
-}, z.core.$strict>;
-export declare const graphEdgeSchema: z.ZodObject<{
-    source: z.ZodString;
-    target: z.ZodString;
-    class: z.ZodString;
-    slug: z.ZodOptional<z.ZodType<EdgeSlug, unknown, z.core.$ZodTypeInternals<EdgeSlug, unknown>>>;
-    props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-}, z.core.$strict>;
-export declare const graphSpecEdgeSchema: z.ZodObject<{
-    source: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-        path: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        created: z.ZodString;
-    }, z.core.$strict>]>;
-    target: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-        path: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        created: z.ZodString;
-    }, z.core.$strict>]>;
-    class: z.ZodString;
-    slug: z.ZodOptional<z.ZodType<EdgeSlug, unknown, z.core.$ZodTypeInternals<EdgeSlug, unknown>>>;
-    props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-}, z.core.$strict>;
-export declare const graphSpecSchema: z.ZodObject<{
-    nodes: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        id: z.ZodString;
-        class: z.ZodString;
-        props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    }, z.core.$strict>, z.ZodObject<{
-        as: z.ZodString;
-        class: z.ZodString;
-        props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    }, z.core.$strict>]>>;
-    edges: z.ZodArray<z.ZodObject<{
-        source: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-            path: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            created: z.ZodString;
-        }, z.core.$strict>]>;
-        target: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-            path: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            created: z.ZodString;
-        }, z.core.$strict>]>;
-        class: z.ZodString;
-        slug: z.ZodOptional<z.ZodType<EdgeSlug, unknown, z.core.$ZodTypeInternals<EdgeSlug, unknown>>>;
-        props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export declare const graphDataSchema: 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<EdgeSlug, unknown, z.core.$ZodTypeInternals<EdgeSlug, unknown>>>;
-        props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
+export declare const graphNodeSchema: 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>;
+export declare const edgeKeySchema: import("zod").ZodObject<{
+    source: import("zod").ZodString;
+    target: import("zod").ZodString;
+    class: import("zod").ZodString;
+}, import("zod/v4/core").$strict>;
+export declare const graphEdgeSchema: import("zod").ZodObject<{
+    source: import("zod").ZodString;
+    target: import("zod").ZodString;
+    class: import("zod").ZodString;
+    slug: import("zod").ZodOptional<ZodType<EdgeSlug, unknown, import("zod/v4/core").$ZodTypeInternals<EdgeSlug, unknown>>>;
+    props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+}, import("zod/v4/core").$strict>;
+export declare const graphSpecSchema: import("zod").ZodObject<{
+    nodes: import("zod").ZodArray<import("zod").ZodUnion<readonly [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").ZodObject<{
+        as: 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").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
+            path: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            created: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>]>;
+        target: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
+            path: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            created: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>]>;
+        class: import("zod").ZodString;
+        slug: import("zod").ZodOptional<ZodType<EdgeSlug, unknown, import("zod/v4/core").$ZodTypeInternals<EdgeSlug, unknown>>>;
+        props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strict>>;
+}, import("zod/v4/core").$strict>;
+export declare const graphDataSchema: 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<ZodType<EdgeSlug, unknown, import("zod/v4/core").$ZodTypeInternals<EdgeSlug, unknown>>>;
+        props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strict>>;
+}, import("zod/v4/core").$strict>;

package/dist/graph/graph/model/wire.js

@@ -1,35 +1,34 @@
 import { fullMatch } from '@astrale-os/kernel-dsl/v1/value/full-match';
-import { z } from 'zod';
+import { array, record, strictObject, string, union, unknown as unknownSchema, } from 'zod';
 import { edgeSlugSchema } from '../../edge/index.js';
-const text = z.string().min(1);
-const props = z.record(z.string(), z.unknown());
-const binding = z.string().regex(/^[A-Za-z][A-Za-z0-9_]{0,63}$/u);
-const edgeSlug = z
-    .string()
+const text = string().min(1);
+const props = record(string(), unknownSchema());
+const binding = string().regex(/^[A-Za-z][A-Za-z0-9_]{0,63}$/u);
+const edgeSlug = string()
     .min(edgeSlugSchema.minLength)
     .max(edgeSlugSchema.maxLength)
     .check(fullMatch(edgeSlugSchema.fullMatch));
-export const graphNodeSchema = z.strictObject({ id: text, class: text, props });
-export const anonymousGraphNodeSchema = z.strictObject({ as: binding, class: text, props });
-export const edgeKeySchema = z.strictObject({ source: text, target: text, class: text });
+export const graphNodeSchema = strictObject({ id: text, class: text, props });
+const anonymousGraphNodeSchema = strictObject({ as: binding, class: text, props });
+export const edgeKeySchema = strictObject({ source: text, target: text, class: text });
 export const graphEdgeSchema = edgeKeySchema.extend({ slug: edgeSlug.optional(), props });
-const graphSpecEndpointSchema = z.union([
+const graphSpecEndpointSchema = union([
     text,
-    z.strictObject({ path: text }),
-    z.strictObject({ created: binding }),
+    strictObject({ path: text }),
+    strictObject({ created: binding }),
 ]);
-export const graphSpecEdgeSchema = z.strictObject({
+const graphSpecEdgeSchema = strictObject({
     source: graphSpecEndpointSchema,
     target: graphSpecEndpointSchema,
     class: text,
     slug: edgeSlug.optional(),
     props,
 });
-export const graphSpecSchema = z.strictObject({
-    nodes: z.array(z.union([graphNodeSchema, anonymousGraphNodeSchema])),
-    edges: z.array(graphSpecEdgeSchema),
+export const graphSpecSchema = strictObject({
+    nodes: array(union([graphNodeSchema, anonymousGraphNodeSchema])),
+    edges: array(graphSpecEdgeSchema),
 });
-export const graphDataSchema = z.strictObject({
-    nodes: z.array(graphNodeSchema),
-    edges: z.array(graphEdgeSchema),
+export const graphDataSchema = strictObject({
+    nodes: array(graphNodeSchema),
+    edges: array(graphEdgeSchema),
 });

package/dist/graph/mutate/authoring/builder.d.ts

@@ -6,7 +6,7 @@ import type { DeltaInput } from '../../properties/index.js';
 import type { QueryEdgeAST, QueryNodeAST } from '../../query/index.js';
 import type { MutationAST } from '../language/index.js';
 import type { MutationInputEdgeSelector, MutationInputEndpoint, MutationPropertyConditionsInput, MutationPropsInput } from './model.js';
-import { LocalBinding } from '../../graph/index.js';
+import { LocalAlias } from '../../graph/index.js';
 export type MutationQueryPreconditionInput = {
     readonly query: QueryNodeAST;
     readonly equals: {
@@ -39,7 +39,7 @@ export interface MutationBuilder {
         readonly class: ClassKey;
         readonly props?: MutationPropsInput;
     }): {
-        readonly created: LocalBinding;
+        readonly created: LocalAlias;
     };
     updateNode(input: {
         readonly node: NodeTarget;

package/dist/graph/mutate/authoring/builder.js

@@ -1,4 +1,4 @@
-import { LocalBinding } from '../../graph/index.js';
+import { LocalAlias } from '../../graph/index.js';
 import { createMutationAST } from './create.js';
 /** Run one synchronous author and admit its complete operation set. */
 export function buildMutationAST(author) {
@@ -38,7 +38,7 @@ export function buildMutationAST(author) {
         expect: expectation,
         createNode(input) {
             requireOpen();
-            const created = LocalBinding(input.as);
+            const created = LocalAlias(input.as);
             operations.push({
                 op: 'node.create',
                 as: created,

package/dist/graph/mutate/authoring/create.js

@@ -1,5 +1,4 @@
-import { isNodeId } from '../../node/index.js';
-import { Path } from '../../path/index.js';
+import { Path, PathError } from '../../path/index.js';
 import { MutationLanguage } from '../language/index.js';
 /** Lower rich TypeScript inputs into the one canonical public MutationAST representation. */
 export function createMutationAST(input) {
@@ -69,6 +68,9 @@ function lowerOperation(operation) {
     }
 }
 function lowerEndpoint(endpoint) {
+    if (typeof endpoint === 'object' && endpoint !== null && 'kind' in endpoint) {
+        return nodeTargetText(endpoint);
+    }
     return typeof endpoint === 'object' && endpoint !== null && 'created' in endpoint
         ? endpoint
         : nodeTargetText(endpoint);
@@ -84,9 +86,15 @@ function pathText(path) {
     return nodeTargetText(path);
 }
 function nodeTargetText(target) {
-    if (target instanceof Path)
-        return target.raw;
-    return isNodeId(target) ? Path.id(target).raw : target;
+    try {
+        return Path.target(target).raw;
+    }
+    catch (cause) {
+        // The Mutation codec owns invalid-input errors and their operation/precondition coordinates.
+        if (cause instanceof PathError)
+            return target;
+        throw cause;
+    }
 }
 function mutationProps(input) {
     return input;

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

@@ -2,7 +2,7 @@ import type { GraphSpec } from '../graph/index.js';
 import type { MutationBuilder, MutationInput } from './authoring/index.js';
 import type { MutationAST as MutationASTValue, MutationStructuralLimits } from './language/index.js';
 export type { MutationBuilder, MutationInput, MutationInputEdgeSelector, MutationInputEndpoint, MutationInputOperation, MutationInputPrecondition, MutationPropertyConditionsInput, MutationPropsInput, MutationQueryPreconditionInput, } from './authoring/index.js';
-export type { EdgeCreateOperation, EdgeDeleteOperation, EdgeUpdateOperation, LocalBinding, MutationEdgeSelector, MutationEndpoint, MutationOperation, MutationPrecondition, MutationPropertyConditions, MutationProps, MutationQueryPrecondition, MutationStructuralLimits, NodeCreateOperation, NodeDeleteOperation, NodeUpdateOperation, QueryExpectedSelection, } from './language/index.js';
+export type { EdgeCreateOperation, EdgeDeleteOperation, EdgeUpdateOperation, LocalAlias, MutationEdgeSelector, MutationEndpoint, MutationOperation, MutationPrecondition, MutationPropertyConditions, MutationProps, MutationQueryPrecondition, MutationStructuralLimits, NodeCreateOperation, NodeDeleteOperation, NodeUpdateOperation, QueryExpectedSelection, } from './language/index.js';
 export { MutationASTDecodeError } from './language/index.js';
 export type MutationAST = MutationASTValue;
 export declare const MutationAST: {