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

package/dist/schema/kernel/syscalls/contracts/provision.js

@@ -1,30 +1,28 @@
-import { z } from 'zod';
+import { array, record, strictObject, string, union, unknown as unknownSchema } from 'zod';
 import { mutationAstSchema } from '#graph/mutate/wire';
 import { requiredClaimsSchema } from '../../../authority/claims.js';
-const text = z.string().min(1);
+const text = string().min(1);
 const requiredClaims = requiredClaimsSchema.optional();
-const asserted = z.strictObject({ iss: text, sub: text });
-const self = z.strictObject({
-    credentials: z.strictObject({ publicKey: z.unknown(), proof: text }),
+const asserted = strictObject({ iss: text, sub: text });
+const self = strictObject({
+    credentials: strictObject({ publicKey: unknownSchema(), proof: text }),
 });
-const authentication = z.union([asserted, self]);
-const createdIdentity = z.strictObject({
-    identity: z.strictObject({ created: text }),
+const authentication = union([asserted, self]);
+const createdIdentity = strictObject({
+    identity: strictObject({ created: text }),
     authentication: authentication.optional(),
     requiredClaims,
 });
-const existingIdentity = z.strictObject({
-    identity: z.strictObject({ id: text, class: text }),
+const existingIdentity = strictObject({
+    identity: strictObject({ id: text, class: text }),
     authentication,
 });
-export const provisionInput = z.strictObject({
+export const provisionInput = strictObject({
     idempotencyKey: text,
     mutation: mutationAstSchema.optional(),
-    identities: z.array(z.union([createdIdentity, existingIdentity])).nonempty(),
+    identities: array(union([createdIdentity, existingIdentity])).nonempty(),
 });
-export const provisionOutput = z.strictObject({
-    createdNodes: z.record(z.string(), text),
-    identities: z
-        .array(z.union([z.strictObject({ id: text }), z.strictObject({ id: text, iss: text, sub: text })]))
-        .nonempty(),
+export const provisionOutput = strictObject({
+    createdNodes: record(string(), text),
+    identities: array(union([strictObject({ id: text }), strictObject({ id: text, iss: text, sub: text })])).nonempty(),
 });

package/dist/schema/kernel/syscalls/contracts/query.d.ts

@@ -1,257 +1,256 @@
-import { z } from 'zod';
 export declare const MAXIMUM_QUERY_EXPECTATIONS = 256;
-export declare const queryInput: z.ZodObject<{
-    ast: 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 queryInput: import("zod").ZodObject<{
+    ast: 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>;
-    expected: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        origin: z.ZodString;
-        revision: z.ZodString;
-    }, z.core.$strict>>>;
-    page: z.ZodObject<{
-        size: z.ZodNumber;
-        after: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export declare const queryOutput: z.ZodObject<{
-    result: 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("../../../../graph/edge/index.js").EdgeSlug, unknown, z.core.$ZodTypeInternals<import("../../../../graph/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("../../../../graph/edge/index.js").EdgeSlug, unknown, z.core.$ZodTypeInternals<import("../../../../graph/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">;
-    page: z.ZodObject<{
-        next: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>], "kind">;
+    }, import("zod/v4/core").$strict>;
+    expected: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        origin: import("zod").ZodString;
+        revision: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>>>;
+    page: import("zod").ZodObject<{
+        size: import("zod").ZodNumber;
+        after: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strict>;
+}, import("zod/v4/core").$strict>;
+export declare const queryOutput: import("zod").ZodObject<{
+    result: 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("../../../../graph/edge/index.js").EdgeSlug, unknown, import("zod/v4/core").$ZodTypeInternals<import("../../../../graph/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("../../../../graph/edge/index.js").EdgeSlug, unknown, import("zod/v4/core").$ZodTypeInternals<import("../../../../graph/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">;
+    page: import("zod").ZodObject<{
+        next: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strict>;
+}, import("zod/v4/core").$strict>;

package/dist/schema/kernel/syscalls/contracts/query.js

@@ -1,16 +1,16 @@
-import { z } from 'zod';
+import { number, strictObject, string } from 'zod';
 import { queryAstSchema, queryResultSchema } from '#graph/query/wire';
 import { domainExpectations, MAXIMUM_DOMAIN_EXPECTATIONS } from './expected.js';
 export const MAXIMUM_QUERY_EXPECTATIONS = MAXIMUM_DOMAIN_EXPECTATIONS;
-export const queryInput = z.strictObject({
+export const queryInput = strictObject({
     ast: queryAstSchema,
     expected: domainExpectations.optional(),
-    page: z.strictObject({
-        size: z.number().int().min(1).max(Number.MAX_SAFE_INTEGER),
-        after: z.string().min(1).optional(),
+    page: strictObject({
+        size: number().int().min(1).max(Number.MAX_SAFE_INTEGER),
+        after: string().min(1).optional(),
     }),
 });
-export const queryOutput = z.strictObject({
+export const queryOutput = strictObject({
     result: queryResultSchema,
-    page: z.strictObject({ next: z.string().min(1).optional() }),
+    page: strictObject({ next: string().min(1).optional() }),
 });