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

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

@@ -1,251 +1,251 @@
-import { z } from 'zod';
+import { type ZodType } from 'zod';
 import { type EdgeSlug } from '../../edge/index.js';
 /** Structural JSON contract; decodeMutationAST owns paths, bindings and atomic semantics. */
-export declare const mutationAstSchema: z.ZodObject<{
-    format: z.ZodLiteral<"astrale.graph.mutation">;
-    version: z.ZodLiteral<"v3">;
-    preconditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        kind: z.ZodLiteral<"node">;
-        node: z.ZodString;
-        class: z.ZodString;
-        props: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
-            equals: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-            absent: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>, z.ZodObject<{
-            absent: z.ZodArray<z.ZodString>;
-        }, z.core.$strict>]>>;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"edge">;
-        edge: z.ZodObject<{
-            source: z.ZodString;
-            target: z.ZodString;
-            class: z.ZodString;
-        }, z.core.$strict>;
-        slug: z.ZodOptional<z.ZodNullable<z.ZodType<EdgeSlug, unknown, z.core.$ZodTypeInternals<EdgeSlug, unknown>>>>;
-        props: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
-            equals: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-            absent: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>, z.ZodObject<{
-            absent: z.ZodArray<z.ZodString>;
-        }, z.core.$strict>]>>;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"query">;
-        query: 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 mutationAstSchema: import("zod").ZodObject<{
+    format: import("zod").ZodLiteral<"astrale.graph.mutation">;
+    version: import("zod").ZodLiteral<"v3">;
+    preconditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"node">;
+        node: import("zod").ZodString;
+        class: import("zod").ZodString;
+        props: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            equals: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+            absent: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            absent: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>]>>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"edge">;
+        edge: import("zod").ZodObject<{
+            source: import("zod").ZodString;
+            target: import("zod").ZodString;
+            class: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+        slug: import("zod").ZodOptional<import("zod").ZodNullable<ZodType<EdgeSlug, unknown, import("zod/v4/core").$ZodTypeInternals<EdgeSlug, unknown>>>>;
+        props: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            equals: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+            absent: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            absent: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>]>>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"query">;
+        query: 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>;
-        equals: 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>]>>;
-    operations: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        op: z.ZodLiteral<"node.create">;
-        as: z.ZodString;
-        class: z.ZodString;
-        props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    }, z.core.$strict>, z.ZodObject<{
-        op: z.ZodLiteral<"node.update">;
-        node: z.ZodString;
-        class: z.ZodString;
-        props: z.ZodObject<{
-            set: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-            unset: z.ZodArray<z.ZodString>;
-        }, z.core.$strict>;
-    }, z.core.$strict>, z.ZodObject<{
-        op: z.ZodLiteral<"node.delete">;
-        node: z.ZodString;
-        class: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        op: z.ZodLiteral<"edge.create">;
-        class: z.ZodString;
-        source: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-            created: z.ZodString;
-        }, z.core.$strict>]>;
-        target: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-            created: z.ZodString;
-        }, z.core.$strict>]>;
-        slug: z.ZodOptional<z.ZodType<EdgeSlug, unknown, z.core.$ZodTypeInternals<EdgeSlug, unknown>>>;
-        props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    }, z.core.$strict>, z.ZodObject<{
-        op: z.ZodLiteral<"edge.update">;
-        edge: z.ZodObject<{
-            source: z.ZodString;
-            target: z.ZodString;
-            class: z.ZodString;
-        }, z.core.$strict>;
-        slug: z.ZodNullable<z.ZodType<EdgeSlug, unknown, z.core.$ZodTypeInternals<EdgeSlug, unknown>>>;
-        props: z.ZodOptional<z.ZodObject<{
-            set: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-            unset: z.ZodArray<z.ZodString>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>, z.ZodObject<{
-        op: z.ZodLiteral<"edge.update">;
-        edge: z.ZodObject<{
-            source: z.ZodString;
-            target: z.ZodString;
-            class: z.ZodString;
-        }, z.core.$strict>;
-        props: z.ZodObject<{
-            set: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-            unset: z.ZodArray<z.ZodString>;
-        }, z.core.$strict>;
-    }, z.core.$strict>, z.ZodObject<{
-        op: z.ZodLiteral<"edge.delete">;
-        edge: z.ZodObject<{
-            source: z.ZodString;
-            target: z.ZodString;
-            class: z.ZodString;
-        }, z.core.$strict>;
-    }, z.core.$strict>]>>;
-}, z.core.$strict>;
+                }, import("zod/v4/core").$strict>>;
+            }, import("zod/v4/core").$strict>], "kind">;
+        }, import("zod/v4/core").$strict>;
+        equals: 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>]>>;
+    operations: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+        op: import("zod").ZodLiteral<"node.create">;
+        as: 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<{
+        op: import("zod").ZodLiteral<"node.update">;
+        node: import("zod").ZodString;
+        class: import("zod").ZodString;
+        props: import("zod").ZodObject<{
+            set: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+            unset: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        op: import("zod").ZodLiteral<"node.delete">;
+        node: import("zod").ZodString;
+        class: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        op: import("zod").ZodLiteral<"edge.create">;
+        class: import("zod").ZodString;
+        source: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
+            created: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>]>;
+        target: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
+            created: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>]>;
+        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").ZodObject<{
+        op: import("zod").ZodLiteral<"edge.update">;
+        edge: import("zod").ZodObject<{
+            source: import("zod").ZodString;
+            target: import("zod").ZodString;
+            class: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+        slug: import("zod").ZodNullable<ZodType<EdgeSlug, unknown, import("zod/v4/core").$ZodTypeInternals<EdgeSlug, unknown>>>;
+        props: import("zod").ZodOptional<import("zod").ZodObject<{
+            set: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+            unset: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        op: import("zod").ZodLiteral<"edge.update">;
+        edge: import("zod").ZodObject<{
+            source: import("zod").ZodString;
+            target: import("zod").ZodString;
+            class: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+        props: import("zod").ZodObject<{
+            set: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+            unset: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        op: import("zod").ZodLiteral<"edge.delete">;
+        edge: 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/v4/core").$strict>;

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

@@ -1,79 +1,75 @@
 import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
 import { fullMatch } from '@astrale-os/kernel-dsl/v1/value/full-match';
-import { z } from 'zod';
+import { array, discriminatedUnion, literal, record, strictObject, string, union, unknown as unknownSchema, } from 'zod';
 import { edgeSlugSchema } from '../../edge/index.js';
 import { queryAstSchema } from '../../query/language/index.js';
 import { MUTATION_AST_FORMAT, MUTATION_AST_LIMITS, MUTATION_AST_VERSION } from './model.js';
-const text = z.string().min(1);
-const binding = z.string().min(1).max(64);
-const propertyKey = z.string().check(fullMatch(patterns.propertyKeyFullMatch));
-const props = z.record(propertyKey, z.unknown());
-const patch = z.strictObject({ set: props, unset: z.array(propertyKey) });
-const endpoint = z.union([text, z.strictObject({ created: binding })]);
-const edgeSelector = z.strictObject({ source: text, target: text, class: text });
-const edgeSlug = z
-    .string()
+const text = string().min(1);
+const binding = string().min(1).max(64);
+const propertyKey = string().check(fullMatch(patterns.propertyKeyFullMatch));
+const props = record(propertyKey, unknownSchema());
+const patch = strictObject({ set: props, unset: array(propertyKey) });
+const endpoint = union([text, strictObject({ created: binding })]);
+const edgeSelector = strictObject({ source: text, target: text, class: text });
+const edgeSlug = string()
     .min(edgeSlugSchema.minLength)
     .max(edgeSlugSchema.maxLength)
     .check(fullMatch(edgeSlugSchema.fullMatch));
-const edgeUpdateWithSlug = z.strictObject({
-    op: z.literal('edge.update'),
+const edgeUpdateWithSlug = strictObject({
+    op: literal('edge.update'),
     edge: edgeSelector,
     slug: edgeSlug.nullable(),
     props: patch.optional(),
 });
-const edgeUpdateWithProperties = z.strictObject({
-    op: z.literal('edge.update'),
+const edgeUpdateWithProperties = strictObject({
+    op: literal('edge.update'),
     edge: edgeSelector,
     props: patch,
 });
-const propertyConditions = z.union([
-    z.strictObject({ equals: props, absent: z.array(propertyKey).optional() }),
-    z.strictObject({ absent: z.array(propertyKey).min(1) }),
+const propertyConditions = union([
+    strictObject({ equals: props, absent: array(propertyKey).optional() }),
+    strictObject({ absent: array(propertyKey).min(1) }),
 ]);
-const expectedSelection = z.discriminatedUnion('kind', [
-    z.strictObject({
-        kind: z.literal('node'),
-        ids: z.array(text).max(MUTATION_AST_LIMITS.queryExpectedIdentities),
+const expectedSelection = discriminatedUnion('kind', [
+    strictObject({
+        kind: literal('node'),
+        ids: array(text).max(MUTATION_AST_LIMITS.queryExpectedIdentities),
     }),
-    z.strictObject({
-        kind: z.literal('edge'),
-        keys: z
-            .array(z.strictObject({ source: text, target: text, class: text }))
-            .max(MUTATION_AST_LIMITS.queryExpectedIdentities),
+    strictObject({
+        kind: literal('edge'),
+        keys: array(strictObject({ source: text, target: text, class: text })).max(MUTATION_AST_LIMITS.queryExpectedIdentities),
     }),
 ]);
-const precondition = z.union([
-    z.strictObject({
-        kind: z.literal('node'),
+const precondition = union([
+    strictObject({
+        kind: literal('node'),
         node: text,
         class: text,
         props: propertyConditions.optional(),
     }),
-    z.strictObject({
-        kind: z.literal('edge'),
+    strictObject({
+        kind: literal('edge'),
         edge: edgeSelector,
         slug: edgeSlug.nullable().optional(),
         props: propertyConditions.optional(),
     }),
-    z.strictObject({
-        kind: z.literal('query'),
+    strictObject({
+        kind: literal('query'),
         query: queryAstSchema,
         equals: expectedSelection,
     }),
 ]);
 /** Structural JSON contract; decodeMutationAST owns paths, bindings and atomic semantics. */
-export const mutationAstSchema = z.strictObject({
-    format: z.literal(MUTATION_AST_FORMAT),
-    version: z.literal(MUTATION_AST_VERSION),
-    preconditions: z.array(precondition).max(MUTATION_AST_LIMITS.preconditions),
-    operations: z
-        .array(z.union([
-        z.strictObject({ op: z.literal('node.create'), as: binding, class: text, props }),
-        z.strictObject({ op: z.literal('node.update'), node: text, class: text, props: patch }),
-        z.strictObject({ op: z.literal('node.delete'), node: text, class: text }),
-        z.strictObject({
-            op: z.literal('edge.create'),
+export const mutationAstSchema = strictObject({
+    format: literal(MUTATION_AST_FORMAT),
+    version: literal(MUTATION_AST_VERSION),
+    preconditions: array(precondition).max(MUTATION_AST_LIMITS.preconditions),
+    operations: array(union([
+        strictObject({ op: literal('node.create'), as: binding, class: text, props }),
+        strictObject({ op: literal('node.update'), node: text, class: text, props: patch }),
+        strictObject({ op: literal('node.delete'), node: text, class: text }),
+        strictObject({
+            op: literal('edge.create'),
             class: text,
             source: endpoint,
             target: endpoint,
@@ -82,7 +78,6 @@ export const mutationAstSchema = z.strictObject({
         }),
         edgeUpdateWithSlug,
         edgeUpdateWithProperties,
-        z.strictObject({ op: z.literal('edge.delete'), edge: edgeSelector }),
-    ]))
-        .min(1),
+        strictObject({ op: literal('edge.delete'), edge: edgeSelector }),
+    ])).min(1),
 });

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

@@ -1,4 +1,3 @@
-import { z } from 'zod';
-export declare const mutationResultSchema: z.ZodObject<{
-    createdNodes: z.ZodRecord<z.ZodString, z.ZodString>;
-}, z.core.$strict>;
+export declare const mutationResultSchema: import("zod").ZodObject<{
+    createdNodes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+}, import("zod/v4/core").$strict>;

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
-const text = z.string().min(1);
-const binding = z.string().min(1).max(64);
-export const mutationResultSchema = z.strictObject({ createdNodes: z.record(binding, text) });
+import { record, strictObject, string } from 'zod';
+const text = string().min(1);
+const binding = string().min(1).max(64);
+export const mutationResultSchema = strictObject({ createdNodes: record(binding, text) });