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

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

@@ -1,292 +0,0 @@
-import { z } from 'zod';
-export declare const provisionInput: z.ZodObject<{
-    idempotencyKey: z.ZodString;
-    mutation: 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<import("../../../../graph/edge/index.js").EdgeSlug, unknown, z.core.$ZodTypeInternals<import("../../../../graph/edge/index.js").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<{
-                        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<{
-                            asc: "asc";
-                            desc: "desc";
-                        }>;
-                        unranked: z.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<{
-                            reference: "reference";
-                            value: "value";
-                        }>;
-                    }, z.core.$strict>;
-                    order: z.ZodOptional<z.ZodObject<{
-                        property: z.ZodString;
-                        direction: z.ZodEnum<{
-                            asc: "asc";
-                            desc: "desc";
-                        }>;
-                        unranked: z.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<{
-                            reference: "reference";
-                            value: "value";
-                        }>;
-                        source: z.ZodEnum<{
-                            reference: "reference";
-                            value: "value";
-                        }>;
-                        target: z.ZodEnum<{
-                            reference: "reference";
-                            value: "value";
-                        }>;
-                    }, z.core.$strict>;
-                    order: z.ZodOptional<z.ZodObject<{
-                        property: z.ZodString;
-                        direction: z.ZodEnum<{
-                            asc: "asc";
-                            desc: "desc";
-                        }>;
-                        unranked: z.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<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.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<import("../../../../graph/edge/index.js").EdgeSlug, unknown, z.core.$ZodTypeInternals<import("../../../../graph/edge/index.js").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>;
-    identities: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
-        issuer: z.ZodString;
-        subject: z.ZodString;
-        requiredClaims: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-            claim: z.ZodString;
-            op: z.ZodLiteral<"contains">;
-            value: z.ZodNonOptional<z.ZodUnknown>;
-        }, z.core.$strict>, z.ZodObject<{
-            claim: z.ZodString;
-            op: z.ZodLiteral<"eq">;
-            value: z.ZodNonOptional<z.ZodUnknown>;
-        }, z.core.$strict>, z.ZodObject<{
-            claim: z.ZodString;
-            op: z.ZodLiteral<"exists">;
-        }, z.core.$strict>], "op">>>;
-    }, z.core.$strict>, z.ZodObject<{
-        credentials: z.ZodObject<{
-            publicKey: z.ZodUnknown;
-            proof: z.ZodString;
-        }, z.core.$strict>;
-        requiredClaims: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-            claim: z.ZodString;
-            op: z.ZodLiteral<"contains">;
-            value: z.ZodNonOptional<z.ZodUnknown>;
-        }, z.core.$strict>, z.ZodObject<{
-            claim: z.ZodString;
-            op: z.ZodLiteral<"eq">;
-            value: z.ZodNonOptional<z.ZodUnknown>;
-        }, z.core.$strict>, z.ZodObject<{
-            claim: z.ZodString;
-            op: z.ZodLiteral<"exists">;
-        }, z.core.$strict>], "op">>>;
-    }, z.core.$strict>]>>;
-}, z.core.$strict>;
-export declare const provisionOutput: z.ZodObject<{
-    createdNodes: z.ZodRecord<z.ZodString, z.ZodString>;
-    identities: z.ZodRecord<z.ZodString, z.ZodObject<{
-        issuer: z.ZodString;
-        subject: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;

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

@@ -1,19 +0,0 @@
-import { z } from 'zod';
-import { mutationAstSchema } from '#graph/mutate/wire';
-import { requiredClaimsSchema } from '../../../authority/claims.js';
-const text = z.string().min(1);
-const requiredClaims = requiredClaimsSchema.optional();
-const asserted = z.strictObject({ issuer: text, subject: text, requiredClaims });
-const self = z.strictObject({
-    credentials: z.strictObject({ publicKey: z.unknown(), proof: text }),
-    requiredClaims,
-});
-export const provisionInput = z.strictObject({
-    idempotencyKey: text,
-    mutation: mutationAstSchema,
-    identities: z.record(z.string(), z.union([asserted, self])),
-});
-export const provisionOutput = z.strictObject({
-    createdNodes: z.record(z.string(), text),
-    identities: z.record(z.string(), z.strictObject({ issuer: text, subject: text })),
-});

package/dist/schema/kernel/syscalls/declarations/define.d.ts

@@ -1,5 +0,0 @@
-import { type builder } from '@astrale-os/kernel-dsl/v1';
-export type SyscallFunctionDefinition = builder.FunctionInput;
-export type SyscallMethodDefinition = builder.MethodInput;
-export declare function defineFunction<const Config extends SyscallFunctionDefinition>(config: Config): builder.Function<Config>;
-export declare function defineMethod<const Config extends SyscallMethodDefinition>(config: Config): builder.Method<Config>;

package/dist/schema/kernel/syscalls/declarations/define.js

@@ -1,7 +0,0 @@
-import { func, method } from '@astrale-os/kernel-dsl/v1';
-export function defineFunction(config) {
-    return func(config);
-}
-export function defineMethod(config) {
-    return method(config);
-}

package/dist/schema/kernel/syscalls/declarations/provision.d.ts

@@ -1,296 +0,0 @@
-import type { builder } from '@astrale-os/kernel-dsl/v1';
-export declare const Provision: builder.Function<{
-    readonly description: "Atomically execute a graph transition whose designated Identities are born complete.";
-    readonly auth: "authorized";
-    readonly input: import("zod").ZodObject<{
-        idempotencyKey: import("zod").ZodString;
-        mutation: 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<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").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: 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: import("zod").ZodEnum<{
-                                first: "first";
-                                last: "last";
-                            }>;
-                        }, 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";
-                            }>;
-                        }, 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: import("zod").ZodEnum<{
-                                first: "first";
-                                last: "last";
-                            }>;
-                        }, 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: import("zod").ZodEnum<{
-                                reference: "reference";
-                                value: "value";
-                            }>;
-                            target: import("zod").ZodEnum<{
-                                reference: "reference";
-                                value: "value";
-                            }>;
-                        }, 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: import("zod").ZodEnum<{
-                                first: "first";
-                                last: "last";
-                            }>;
-                        }, 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<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").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<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").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>;
-        identities: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodObject<{
-            issuer: import("zod").ZodString;
-            subject: import("zod").ZodString;
-            requiredClaims: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                claim: import("zod").ZodString;
-                op: import("zod").ZodLiteral<"contains">;
-                value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                claim: import("zod").ZodString;
-                op: import("zod").ZodLiteral<"eq">;
-                value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                claim: import("zod").ZodString;
-                op: import("zod").ZodLiteral<"exists">;
-            }, import("zod/v4/core").$strict>], "op">>>;
-        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-            credentials: import("zod").ZodObject<{
-                publicKey: import("zod").ZodUnknown;
-                proof: import("zod").ZodString;
-            }, import("zod/v4/core").$strict>;
-            requiredClaims: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                claim: import("zod").ZodString;
-                op: import("zod").ZodLiteral<"contains">;
-                value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                claim: import("zod").ZodString;
-                op: import("zod").ZodLiteral<"eq">;
-                value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                claim: import("zod").ZodString;
-                op: import("zod").ZodLiteral<"exists">;
-            }, import("zod/v4/core").$strict>], "op">>>;
-        }, import("zod/v4/core").$strict>]>>;
-    }, import("zod/v4/core").$strict>;
-    readonly output: import("zod").ZodObject<{
-        createdNodes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
-        identities: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
-            issuer: import("zod").ZodString;
-            subject: import("zod").ZodString;
-        }, import("zod/v4/core").$strict>>;
-    }, import("zod/v4/core").$strict>;
-}>;

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

@@ -1,8 +0,0 @@
-import { provisionInput, provisionOutput } from '../contracts/index.js';
-import { defineFunction } from './define.js';
-export const Provision = defineFunction({
-    description: 'Atomically execute a graph transition whose designated Identities are born complete.',
-    auth: 'authorized',
-    input: provisionInput,
-    output: provisionOutput,
-});