@astrale-os/kernel-core 0.9.0-beta.25 → 0.9.0-beta.27

package/dist/graph/node/identity/id.d.ts

@@ -1,4 +1,3 @@
-import { z } from 'zod';
 declare const NODE_ID_BRAND: unique symbol;
 /** Stable opaque identity: 1-255 ASCII characters from [A-Za-z0-9._-]. */
 export type NodeId = string & {
@@ -12,7 +11,7 @@ export declare class NodeIdError extends TypeError {
 /** Admit opaque 1-255 character ASCII NodeId text without repair or format-specific semantics. */
 export declare function NodeId(input: string): NodeId;
 export declare function isNodeId(input: unknown): input is NodeId;
-export declare const nodeIdSchema: z.ZodPipe<z.ZodString & z.ZodType<NodeId, string, z.core.$ZodTypeInternals<NodeId, string>>, z.ZodTransform<NodeId, string & {
+export declare const nodeIdSchema: import("zod").ZodPipe<import("zod").ZodString & import("zod").ZodType<NodeId, string, import("zod/v4/core").$ZodTypeInternals<NodeId, string>>, import("zod").ZodTransform<NodeId, string & {
     readonly [NODE_ID_BRAND]: true;
 }>>;
 export {};

package/dist/graph/node/identity/id.js

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { string } from 'zod';
 const NODE_ID_MAX_LENGTH = 255;
 const NODE_ID_INVALID_CHARACTER = /[^A-Za-z0-9._-]/u;
 const NODE_ID_ERROR_MESSAGE = 'NodeId must be 1-255 ASCII characters drawn from [A-Za-z0-9._-].';
@@ -23,7 +23,6 @@ export function isNodeId(input) {
         input.length <= NODE_ID_MAX_LENGTH &&
         !NODE_ID_INVALID_CHARACTER.test(input));
 }
-export const nodeIdSchema = z
-    .string()
+export const nodeIdSchema = string()
     .refine(isNodeId, NODE_ID_ERROR_MESSAGE)
     .transform((value) => value);

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

@@ -1,149 +1,148 @@
-import { z } from 'zod';
 /** Structural JSON contract; decodeQueryAST owns canonical identities and binding dependencies. */
-export declare const queryAstSchema: z.ZodObject<{
-    format: z.ZodLiteral<"astrale.graph.query">;
-    version: z.ZodLiteral<"v6">;
-    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"node">;
-        terms: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"path">;
-            path: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"class">;
-            class: z.ZodObject<{
-                origin: z.ZodString;
-                kind: z.ZodLiteral<"class">;
-                name: z.ZodString;
-            }, z.core.$strict>;
-        }, z.core.$strict>], "kind">>;
-        binding: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"edge">;
-        terms: z.ZodArray<z.ZodObject<{
-            kind: z.ZodLiteral<"class">;
-            class: z.ZodObject<{
-                origin: z.ZodString;
-                kind: z.ZodLiteral<"class">;
-                name: z.ZodString;
-            }, z.core.$strict>;
-        }, z.core.$strict>>;
-        bindings: z.ZodObject<{
-            source: z.ZodString;
-            edge: z.ZodString;
-            target: z.ZodString;
-        }, z.core.$strict>;
-    }, z.core.$strict>], "kind">;
-    steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        op: z.ZodLiteral<"filter">;
-        binding: z.ZodString;
-        predicate: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"class.satisfies">;
-            class: z.ZodObject<{
-                origin: z.ZodString;
-                kind: z.ZodLiteral<"class">;
-                name: z.ZodString;
-            }, z.core.$strict>;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"class.equal">;
-            class: z.ZodObject<{
-                origin: z.ZodString;
-                kind: z.ZodLiteral<"class">;
-                name: z.ZodString;
-            }, z.core.$strict>;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"property.equal">;
-            property: z.ZodString;
-            value: z.ZodUnknown;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"property.present">;
-            property: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"identity.equal">;
-            identity: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                source: z.ZodString;
-                target: z.ZodString;
-                class: z.ZodString;
-            }, z.core.$strict>]>;
-        }, z.core.$strict>], "kind">;
-    }, z.core.$strict>, z.ZodObject<{
-        op: z.ZodLiteral<"expand">;
-        from: z.ZodString;
-        via: z.ZodArray<z.ZodObject<{
-            origin: z.ZodString;
-            kind: z.ZodLiteral<"class">;
-            name: z.ZodString;
-        }, z.core.$strict>>;
-        direction: z.ZodEnum<{
+export declare const queryAstSchema: import("zod").ZodObject<{
+    format: import("zod").ZodLiteral<"astrale.graph.query">;
+    version: import("zod").ZodLiteral<"v6">;
+    source: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"node">;
+        terms: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"path">;
+            path: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"class">;
+            class: import("zod").ZodObject<{
+                origin: import("zod").ZodString;
+                kind: import("zod").ZodLiteral<"class">;
+                name: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strict>], "kind">>;
+        binding: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"edge">;
+        terms: import("zod").ZodArray<import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"class">;
+            class: import("zod").ZodObject<{
+                origin: import("zod").ZodString;
+                kind: import("zod").ZodLiteral<"class">;
+                name: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strict>>;
+        bindings: import("zod").ZodObject<{
+            source: import("zod").ZodString;
+            edge: import("zod").ZodString;
+            target: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+    }, import("zod/v4/core").$strict>], "kind">;
+    steps: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        op: import("zod").ZodLiteral<"filter">;
+        binding: import("zod").ZodString;
+        predicate: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"class.satisfies">;
+            class: import("zod").ZodObject<{
+                origin: import("zod").ZodString;
+                kind: import("zod").ZodLiteral<"class">;
+                name: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"class.equal">;
+            class: import("zod").ZodObject<{
+                origin: import("zod").ZodString;
+                kind: import("zod").ZodLiteral<"class">;
+                name: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"property.equal">;
+            property: import("zod").ZodString;
+            value: import("zod").ZodUnknown;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"property.present">;
+            property: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"identity.equal">;
+            identity: import("zod").ZodUnion<readonly [import("zod").ZodString, 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<{
+        op: import("zod").ZodLiteral<"expand">;
+        from: import("zod").ZodString;
+        via: import("zod").ZodArray<import("zod").ZodObject<{
+            origin: import("zod").ZodString;
+            kind: import("zod").ZodLiteral<"class">;
+            name: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>>;
+        direction: import("zod").ZodEnum<{
             incident: "incident";
             incoming: "incoming";
             outgoing: "outgoing";
         }>;
-        bindings: z.ZodObject<{
-            edge: z.ZodString;
-            node: z.ZodString;
-        }, z.core.$strict>;
-    }, z.core.$strict>], "op">>;
-    select: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"graph">;
-        binding: z.ZodString;
-        order: z.ZodOptional<z.ZodObject<{
-            property: z.ZodString;
-            direction: z.ZodEnum<{
+        bindings: import("zod").ZodObject<{
+            edge: import("zod").ZodString;
+            node: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+    }, import("zod/v4/core").$strict>], "op">>;
+    select: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"graph">;
+        binding: import("zod").ZodString;
+        order: import("zod").ZodOptional<import("zod").ZodObject<{
+            property: import("zod").ZodString;
+            direction: import("zod").ZodEnum<{
                 asc: "asc";
                 desc: "desc";
             }>;
-            unranked: z.ZodEnum<{
+            unranked: import("zod").ZodEnum<{
                 first: "first";
                 last: "last";
             }>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"nodes">;
-        binding: z.ZodString;
-        projection: z.ZodObject<{
-            kind: z.ZodEnum<{
+        }, import("zod/v4/core").$strict>>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"nodes">;
+        binding: import("zod").ZodString;
+        projection: import("zod").ZodObject<{
+            kind: import("zod").ZodEnum<{
                 reference: "reference";
                 value: "value";
             }>;
-        }, z.core.$strict>;
-        order: z.ZodOptional<z.ZodObject<{
-            property: z.ZodString;
-            direction: z.ZodEnum<{
+        }, import("zod/v4/core").$strict>;
+        order: import("zod").ZodOptional<import("zod").ZodObject<{
+            property: import("zod").ZodString;
+            direction: import("zod").ZodEnum<{
                 asc: "asc";
                 desc: "desc";
             }>;
-            unranked: z.ZodEnum<{
+            unranked: import("zod").ZodEnum<{
                 first: "first";
                 last: "last";
             }>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"edges">;
-        binding: z.ZodString;
-        projection: z.ZodObject<{
-            edge: z.ZodEnum<{
+        }, import("zod/v4/core").$strict>>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"edges">;
+        binding: import("zod").ZodString;
+        projection: import("zod").ZodObject<{
+            edge: import("zod").ZodEnum<{
                 reference: "reference";
                 value: "value";
             }>;
-            source: z.ZodEnum<{
+            source: import("zod").ZodEnum<{
                 reference: "reference";
                 value: "value";
             }>;
-            target: z.ZodEnum<{
+            target: import("zod").ZodEnum<{
                 reference: "reference";
                 value: "value";
             }>;
-        }, z.core.$strict>;
-        order: z.ZodOptional<z.ZodObject<{
-            property: z.ZodString;
-            direction: z.ZodEnum<{
+        }, import("zod/v4/core").$strict>;
+        order: import("zod").ZodOptional<import("zod").ZodObject<{
+            property: import("zod").ZodString;
+            direction: import("zod").ZodEnum<{
                 asc: "asc";
                 desc: "desc";
             }>;
-            unranked: z.ZodEnum<{
+            unranked: import("zod").ZodEnum<{
                 first: "first";
                 last: "last";
             }>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>], "kind">;
-}, z.core.$strict>;
+        }, import("zod/v4/core").$strict>>;
+    }, import("zod/v4/core").$strict>], "kind">;
+}, import("zod/v4/core").$strict>;

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

@@ -1,68 +1,68 @@
-import { z } from 'zod';
+import { array, discriminatedUnion, enum as enumeration, literal, strictObject, string, union, unknown as unknownSchema, } from 'zod';
 import { QUERY_AST_FORMAT, QUERY_AST_LIMITS, QUERY_AST_VERSION } from './model.js';
-const text = z.string().min(1);
+const text = string().min(1);
 const binding = text.max(64);
-const classRef = z.strictObject({
+const classRef = strictObject({
     origin: text.max(253),
-    kind: z.literal('class'),
+    kind: literal('class'),
     name: text,
 });
-const nodeSourceTerm = z.discriminatedUnion('kind', [
-    z.strictObject({ kind: z.literal('path'), path: text }),
-    z.strictObject({ kind: z.literal('class'), class: classRef }),
+const nodeSourceTerm = discriminatedUnion('kind', [
+    strictObject({ kind: literal('path'), path: text }),
+    strictObject({ kind: literal('class'), class: classRef }),
 ]);
-const classSourceTerm = z.strictObject({ kind: z.literal('class'), class: classRef });
-const source = z.discriminatedUnion('kind', [
-    z.strictObject({
-        kind: z.literal('node'),
-        terms: z.array(nodeSourceTerm).min(1).max(QUERY_AST_LIMITS.sourceTerms),
+const classSourceTerm = strictObject({ kind: literal('class'), class: classRef });
+const source = discriminatedUnion('kind', [
+    strictObject({
+        kind: literal('node'),
+        terms: array(nodeSourceTerm).min(1).max(QUERY_AST_LIMITS.sourceTerms),
         binding,
     }),
-    z.strictObject({
-        kind: z.literal('edge'),
-        terms: z.array(classSourceTerm).min(1).max(QUERY_AST_LIMITS.sourceTerms),
-        bindings: z.strictObject({ source: binding, edge: binding, target: binding }),
+    strictObject({
+        kind: literal('edge'),
+        terms: array(classSourceTerm).min(1).max(QUERY_AST_LIMITS.sourceTerms),
+        bindings: strictObject({ source: binding, edge: binding, target: binding }),
     }),
 ]);
-const predicate = z.discriminatedUnion('kind', [
-    z.strictObject({ kind: z.literal('class.satisfies'), class: classRef }),
-    z.strictObject({ kind: z.literal('class.equal'), class: classRef }),
-    z.strictObject({ kind: z.literal('property.equal'), property: text, value: z.unknown() }),
-    z.strictObject({ kind: z.literal('property.present'), property: text }),
-    z.strictObject({
-        kind: z.literal('identity.equal'),
-        identity: z.union([text, z.strictObject({ source: text, target: text, class: text })]),
+const predicate = discriminatedUnion('kind', [
+    strictObject({ kind: literal('class.satisfies'), class: classRef }),
+    strictObject({ kind: literal('class.equal'), class: classRef }),
+    strictObject({ kind: literal('property.equal'), property: text, value: unknownSchema() }),
+    strictObject({ kind: literal('property.present'), property: text }),
+    strictObject({
+        kind: literal('identity.equal'),
+        identity: union([text, strictObject({ source: text, target: text, class: text })]),
     }),
 ]);
-const filter = z.strictObject({ op: z.literal('filter'), binding, predicate });
-const expand = z.strictObject({
-    op: z.literal('expand'),
+const filter = strictObject({ op: literal('filter'), binding, predicate });
+const expand = strictObject({
+    op: literal('expand'),
     from: binding,
-    via: z.array(classRef).min(1).max(QUERY_AST_LIMITS.expansionClassesPerStep),
-    direction: z.enum(['outgoing', 'incoming', 'incident']),
-    bindings: z.strictObject({ edge: binding, node: binding }),
+    via: array(classRef).min(1).max(QUERY_AST_LIMITS.expansionClassesPerStep),
+    direction: enumeration(['outgoing', 'incoming', 'incident']),
+    bindings: strictObject({ edge: binding, node: binding }),
 });
-const propertyOrder = z.strictObject({
+const propertyOrder = strictObject({
     property: text,
-    direction: z.enum(['asc', 'desc']),
-    unranked: z.enum(['first', 'last']),
+    direction: enumeration(['asc', 'desc']),
+    unranked: enumeration(['first', 'last']),
 });
-const projectionShape = z.enum(['reference', 'value']);
-const graphSelect = z.strictObject({
-    kind: z.literal('graph'),
+const projectionShape = enumeration(['reference', 'value']);
+const graphSelect = strictObject({
+    kind: literal('graph'),
     binding,
     order: propertyOrder.optional(),
 });
-const nodeSelect = z.strictObject({
-    kind: z.literal('nodes'),
+const nodeSelect = strictObject({
+    kind: literal('nodes'),
     binding,
-    projection: z.strictObject({ kind: projectionShape }),
+    projection: strictObject({ kind: projectionShape }),
     order: propertyOrder.optional(),
 });
-const edgeSelect = z.strictObject({
-    kind: z.literal('edges'),
+const edgeSelect = strictObject({
+    kind: literal('edges'),
     binding,
-    projection: z.strictObject({
+    projection: strictObject({
         edge: projectionShape,
         source: projectionShape,
         target: projectionShape,
@@ -70,10 +70,10 @@ const edgeSelect = z.strictObject({
     order: propertyOrder.optional(),
 });
 /** Structural JSON contract; decodeQueryAST owns canonical identities and binding dependencies. */
-export const queryAstSchema = z.strictObject({
-    format: z.literal(QUERY_AST_FORMAT),
-    version: z.literal(QUERY_AST_VERSION),
+export const queryAstSchema = strictObject({
+    format: literal(QUERY_AST_FORMAT),
+    version: literal(QUERY_AST_VERSION),
     source,
-    steps: z.array(z.discriminatedUnion('op', [filter, expand])).max(QUERY_AST_LIMITS.steps),
-    select: z.discriminatedUnion('kind', [graphSelect, nodeSelect, edgeSelect]),
+    steps: array(discriminatedUnion('op', [filter, expand])).max(QUERY_AST_LIMITS.steps),
+    select: discriminatedUnion('kind', [graphSelect, nodeSelect, edgeSelect]),
 });

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