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

package/dist/events/journal/types.js

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

package/dist/events/payloads.d.ts

@@ -53,4 +53,3 @@ export type OpPayload<P = unknown, R = unknown> = {
     };
 };
 export type PayloadFor<T extends EventTopic> = T extends `graph:node:${KernelNodeRef}:created` ? NodeCreatedPayload : T extends `graph:node:${KernelNodeRef}:updated` ? NodeUpdatedPayload : T extends `graph:node:${infer K extends KernelNodeRef}:deleted` ? NodeDeletedPayload<K> : T extends `graph:edge:${KernelEdgeRef}:created` ? EdgeCreatedPayload : T extends `graph:edge:${infer K extends KernelEdgeRef}:deleted` ? EdgeDeletedPayload<K> : T extends `graph:edge:${KernelEdgeRef}:updated` ? EdgeUpdatedPayload : T extends keyof SystemPayloads ? SystemPayloads[T] : T extends `op:${string}:${OpAction}` ? OpPayload : never;
-//# sourceMappingURL=payloads.d.ts.map

package/dist/events/payloads.js

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

package/dist/events/subscription.d.ts

@@ -6,4 +6,3 @@ export type EventFilter = {
     rootId?: NodeId;
 };
 export type EventHandler<T extends EventTopic = EventTopic> = (event: EventEnvelope<T>) => void | Promise<void>;
-//# sourceMappingURL=subscription.d.ts.map

package/dist/events/subscription.js

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

package/dist/events/topics.d.ts

@@ -21,4 +21,3 @@ export declare const Topics: {
     readonly edge: <K extends KernelEdgeRef, A extends EdgeAction>(kind: K, action: A) => `graph:edge:${K}:${A}`;
     readonly op: <N extends string, A extends OpAction>(name: N, action: A) => `op:${N}:${A}`;
 };
-//# sourceMappingURL=topics.d.ts.map

package/dist/events/topics.js

@@ -3,4 +3,3 @@ export const Topics = {
     edge: (kind, action) => `graph:edge:${kind}:${action}`,
     op: (name, action) => `op:${name}:${action}`,
 };
-//# sourceMappingURL=topics.js.map

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

@@ -10,4 +10,3 @@ export declare function equalEdgeKeys(left: EdgeKey, right: EdgeKey): boolean;
 /** Private collision-free Map key; never exposed as Edge identity. */
 export declare function encodeEdgeKey(key: EdgeKey): string;
 export { compareEdgeKeys } from './order.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/edge/identity/index.js

@@ -6,4 +6,3 @@ export function encodeEdgeKey(key) {
     return JSON.stringify([key.source, key.target, key.class]);
 }
 export { compareEdgeKeys } from './order.js';
-//# sourceMappingURL=index.js.map

package/dist/graph/edge/identity/order.d.ts

@@ -1,4 +1,3 @@
 import type { EdgeKey } from './index.js';
 /** Compare Edge identity by source, target, then canonical ClassKey text. */
 export declare function compareEdgeKeys(left: EdgeKey, right: EdgeKey): number;
-//# sourceMappingURL=order.d.ts.map

package/dist/graph/edge/identity/order.js

@@ -8,4 +8,3 @@ export function compareEdgeKeys(left, right) {
 function compareAscii(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
 }
-//# sourceMappingURL=order.js.map

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

@@ -8,4 +8,3 @@ export { compareEdgeKeys, encodeEdgeKey, equalEdgeKeys } from './identity/index.
 export { EdgeSlug, EdgeSlugError, edgeSlugSchema, isEdgeSlug } from './slug/index.js';
 /** Return the complete logical identity of one Edge. */
 export declare function edgeKeyOf(edge: Edge): EdgeKey;
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/edge/index.js

@@ -6,4 +6,3 @@ export { EdgeSlug, EdgeSlugError, edgeSlugSchema, isEdgeSlug } from './slug/inde
 export function edgeKeyOf(edge) {
     return Object.freeze({ source: edge.source, target: edge.target, class: edge.class });
 }
-//# sourceMappingURL=index.js.map

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

@@ -17,4 +17,3 @@ export interface Edge extends EdgeSpec<NodeId>, EdgeKey {
 /** Construct one immutable Edge record from canonical components. */
 export declare function edge(value: Edge): Edge;
 export type EdgeCollection = readonly Edge[];
-//# sourceMappingURL=index.d.ts.map

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

@@ -8,4 +8,3 @@ export function edge(value) {
         props: value.props,
     });
 }
-//# sourceMappingURL=index.js.map

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

@@ -19,4 +19,3 @@ export declare class EdgeSlugError extends TypeError {
 export declare function isEdgeSlug(input: unknown): input is EdgeSlug;
 export declare function EdgeSlug(input: string): EdgeSlug;
 export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/edge/slug/index.js

@@ -24,4 +24,3 @@ export function EdgeSlug(input) {
         throw new EdgeSlugError(input);
     return input;
 }
-//# sourceMappingURL=index.js.map

package/dist/graph/graph/admission/admit.d.ts

@@ -6,4 +6,3 @@ export interface AdmittedGraphData {
     readonly classes: ReadonlyMap<ClassKey, GraphClassInfo>;
 }
 export declare function admitGraphData(data: GraphData, context: GraphAdmissionContext): AdmittedGraphData;
-//# sourceMappingURL=admit.d.ts.map

package/dist/graph/graph/admission/admit.js

@@ -190,4 +190,3 @@ function safeJson(value) {
         return '<non-json>';
     }
 }
-//# sourceMappingURL=admit.js.map

package/dist/graph/graph/admission/error.d.ts

@@ -4,4 +4,3 @@ export declare class GraphAdmissionError extends TypeError {
     readonly code: 'GRAPH_ADMISSION_REJECTED';
     constructor(diagnostics: readonly GraphDiagnostic[]);
 }
-//# sourceMappingURL=error.d.ts.map

package/dist/graph/graph/admission/error.js

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

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

@@ -2,4 +2,3 @@ export { admitGraphData } from './admit.js';
 export type { AdmittedGraphData } from './admit.js';
 export type { GraphAdmissionContext, GraphClassInfo, GraphDiagnostic } from './model.js';
 export { GraphAdmissionError } from './error.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/graph/admission/index.js

@@ -1,3 +1,2 @@
 export { admitGraphData } from './admit.js';
 export { GraphAdmissionError } from './error.js';
-//# sourceMappingURL=index.js.map

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

@@ -24,4 +24,3 @@ export interface GraphAdmissionContext {
 }
 export declare function graphDiagnostic(code: string, path: string, message: string): GraphDiagnostic;
 export declare function sortGraphDiagnostics(diagnostics: readonly GraphDiagnostic[]): readonly GraphDiagnostic[];
-//# sourceMappingURL=model.d.ts.map

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

@@ -9,4 +9,3 @@ export function sortGraphDiagnostics(diagnostics) {
 function compareText(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
 }
-//# sourceMappingURL=model.js.map

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

@@ -30,4 +30,3 @@ export type DeltaResult = {
 };
 export declare function delta(left: GraphDeltaSource, right: GraphDeltaSource): DeltaResult;
 export declare function apply(left: GraphDeltaSource, change: Delta): GraphData;
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/graph/delta/index.js

@@ -79,4 +79,3 @@ function data(nodes, edges) {
 function invalid(message) {
     throw new TypeError(message);
 }
-//# sourceMappingURL=index.js.map

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,8 +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;
 }
-//# sourceMappingURL=graph.d.ts.map

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;
     }
@@ -95,4 +71,3 @@ function equalEdge(left, right) {
         left.slug === right.slug &&
         equalProperties(left.props, right.props));
 }
-//# sourceMappingURL=graph.js.map

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

@@ -1,13 +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';
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/graph/index.js

@@ -1,7 +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';
-//# sourceMappingURL=index.js.map

package/dist/graph/graph/indexes/collection.d.ts

@@ -8,4 +8,3 @@ export declare function createCollections(nodes: NodeCollection, edges: EdgeColl
     readonly edges: GraphEdges;
 };
 export declare function buildIndexes(nodes: NodeCollection, edges: EdgeCollection, classes: ReadonlyMap<ClassKey, GraphClassInfo>): GraphIndexes;
-//# sourceMappingURL=collection.d.ts.map

package/dist/graph/graph/indexes/collection.js

@@ -68,4 +68,3 @@ function freezeBuckets(map) {
     for (const [key, bucket] of map)
         map.set(key, Object.freeze(bucket));
 }
-//# sourceMappingURL=collection.js.map

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

@@ -1,3 +1,2 @@
 export type { GraphClassIndex, GraphEdgeIndex, GraphEdges, GraphIndexes, GraphNodeIndex, GraphNodes, } from './model.js';
 export { buildIndexes, createCollections } from './collection.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/graph/indexes/index.js

@@ -1,2 +1 @@
 export { buildIndexes, createCollections } from './collection.js';
-//# sourceMappingURL=index.js.map

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

@@ -32,4 +32,3 @@ export interface GraphIndexes {
     readonly edges: GraphEdgeIndex;
     readonly classes: GraphClassIndex;
 }
-//# sourceMappingURL=model.d.ts.map

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

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

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

@@ -32,4 +32,3 @@ export type MergeResult = {
 };
 /** Apply exact three-way merge semantics to already canonical finite GraphData values. */
 export declare function mergeData(base: GraphData, current: GraphData, target: GraphData): MergeResult;
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/graph/merge/index.js

@@ -127,4 +127,3 @@ function edgeIndex(edges) {
 function data(nodes, edges) {
     return Object.freeze({ nodes: Object.freeze(nodes), edges: Object.freeze(edges) });
 }
-//# sourceMappingURL=index.js.map

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

@@ -21,4 +21,3 @@ export declare function encodeGraphSpec(input: GraphSpecValue): GraphSpecJson;
 /** Strengthen unknown JSON into detached immutable structural graph facts. */
 export declare function decodeGraphData(input: unknown): GraphData;
 export declare function encodeGraphData(input: GraphData): GraphDataJson;
-//# sourceMappingURL=codec.d.ts.map

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();
@@ -234,4 +234,3 @@ function decodeProperties(input, path) {
 function errorPointer(error, fallback = '') {
     return error instanceof portable.BoundaryError ? error.pointer : fallback;
 }
-//# sourceMappingURL=codec.js.map

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

@@ -13,6 +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';
-//# sourceMappingURL=index.d.ts.map

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

@@ -2,6 +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';
-//# sourceMappingURL=index.js.map

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. */
@@ -65,4 +65,3 @@ export interface GraphDataJson extends GraphSpecJson {
     }[];
 }
 export {};
-//# sourceMappingURL=model.d.ts.map

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

@@ -1,11 +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);
 }
-//# sourceMappingURL=model.js.map

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

@@ -1,80 +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>;
-//# sourceMappingURL=wire.d.ts.map
+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>;