npm - @astrale-os/kernel-core - Versions diffs - 0.9.0-beta.32 → 0.9.0-beta.33 - Mend

@astrale-os/kernel-core 0.9.0-beta.32 → 0.9.0-beta.33

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/dist/schema/kernel/schema.d.ts CHANGED Viewed

@@ -5271,12 +5271,15 @@ declare const KernelDefinitions: {
         }, "authenticated", false, "default">>;
         uninstall: builder.Function<builder.CallableProjection<{
             operation: string;
-            origin: string;
+            domains: string[];
+            data: {
+                mode: "destructive" | "safe";
+            };
         }, {
             readonly mode: 'value';
             readonly value: {
                 operation: string;
-                transition: {
+                transitions: {
                     intent: {
                         transition: string;
                         operation: string;
@@ -5304,7 +5307,7 @@ declare const KernelDefinitions: {
                             meaning: string;
                         }[];
                     } | undefined;
-                };
+                }[];
             };
         }, "authorized", false, "default">>;
         journal: builder.Function<builder.CallableProjection<{
@@ -5622,41 +5625,6 @@ export declare const AuthorityRelations: Readonly<{
 }>;
 /** Exact authorized Kernel Functions for which pristine Root receives direct can_use authority. */
 export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
-    kind: "bundle" | "inspect";
-    origin: string;
-}, {
-    readonly mode: 'binary';
-}, "authenticated", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
-    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"introspect"> & {
-        readonly origin: "kernel.astrale.ai";
-    };
-    readonly key: "kernel.astrale.ai:function.introspect";
-}) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
-    operation: string;
-    domains: ({
-        artifact: {
-            digest: string;
-            mediaType: string;
-            size: number;
-        };
-        currentRevision?: string | null | undefined;
-    } | {
-        publication: {
-            url: string;
-            token?: string | undefined;
-            etag?: string | undefined;
-        };
-        revision?: string | undefined;
-        currentRevision?: string | null | undefined;
-    })[];
-}, {
-    readonly mode: 'binary';
-}, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
-    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"install"> & {
-        readonly origin: "kernel.astrale.ai";
-    };
-    readonly key: "kernel.astrale.ai:function.install";
-}) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
     invocation?: {
         source: string;
         id: string;
@@ -5690,236 +5658,233 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
     readonly key: "kernel.astrale.ai:function.journal";
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
     ast: {
-        format: "astrale.graph.mutation";
-        version: "v3";
-        preconditions: ({
+        format: "astrale.graph.query";
+        version: "v6";
+        source: {
             kind: "node";
-            node: string;
-            class: string;
-            props?: {
-                equals: Record<string, unknown>;
-                absent?: string[] | undefined;
+            terms: ({
+                kind: "path";
+                path: string;
             } | {
-                absent: string[];
-            } | undefined;
+                kind: "class";
+                class: {
+                    origin: string;
+                    kind: "class";
+                    name: string;
+                };
+            })[];
+            binding: string;
         } | {
             kind: "edge";
-            edge: {
+            terms: {
+                kind: "class";
+                class: {
+                    origin: string;
+                    kind: "class";
+                    name: string;
+                };
+            }[];
+            bindings: {
                 source: string;
+                edge: string;
                 target: string;
-                class: string;
             };
-            slug?: unknown;
-            props?: {
-                equals: Record<string, unknown>;
-                absent?: string[] | undefined;
-            } | {
-                absent: string[];
-            } | undefined;
-        } | {
-            kind: "query";
-            query: {
-                format: "astrale.graph.query";
-                version: "v6";
-                source: {
-                    kind: "node";
-                    terms: ({
-                        kind: "path";
-                        path: string;
-                    } | {
-                        kind: "class";
-                        class: {
-                            origin: string;
-                            kind: "class";
-                            name: string;
-                        };
-                    })[];
-                    binding: string;
-                } | {
-                    kind: "edge";
-                    terms: {
-                        kind: "class";
-                        class: {
-                            origin: string;
-                            kind: "class";
-                            name: string;
-                        };
-                    }[];
-                    bindings: {
-                        source: string;
-                        edge: string;
-                        target: string;
-                    };
+        };
+        steps: ({
+            op: "filter";
+            binding: string;
+            predicate: {
+                kind: "class.satisfies";
+                class: {
+                    origin: string;
+                    kind: "class";
+                    name: string;
                 };
-                steps: ({
-                    op: "filter";
-                    binding: string;
-                    predicate: {
-                        kind: "class.satisfies";
-                        class: {
-                            origin: string;
-                            kind: "class";
-                            name: string;
-                        };
-                    } | {
-                        kind: "class.equal";
-                        class: {
-                            origin: string;
-                            kind: "class";
-                            name: string;
-                        };
-                    } | {
-                        kind: "property.equal";
-                        property: string;
-                        value: unknown;
-                    } | {
-                        kind: "property.present";
-                        property: string;
-                    } | {
-                        kind: "identity.equal";
-                        identity: string | {
-                            source: string;
-                            target: string;
-                            class: string;
-                        };
-                    };
-                } | {
-                    op: "expand";
-                    from: string;
-                    via: {
-                        origin: string;
-                        kind: "class";
-                        name: string;
-                    }[];
-                    direction: "incident" | "incoming" | "outgoing";
-                    bindings: {
-                        edge: string;
-                        node: string;
-                    };
-                })[];
-                select: {
-                    kind: "graph";
-                    binding: string;
-                    order?: {
-                        property: string;
-                        direction: "asc" | "desc";
-                        unranked: "first" | "last";
-                    } | undefined;
-                } | {
-                    kind: "nodes";
-                    binding: string;
-                    projection: {
-                        kind: "reference" | "value";
-                    };
-                    order?: {
-                        property: string;
-                        direction: "asc" | "desc";
-                        unranked: "first" | "last";
-                    } | undefined;
-                } | {
-                    kind: "edges";
-                    binding: string;
-                    projection: {
-                        edge: "reference" | "value";
-                        source: "reference" | "value";
-                        target: "reference" | "value";
-                    };
-                    order?: {
-                        property: string;
-                        direction: "asc" | "desc";
-                        unranked: "first" | "last";
-                    } | undefined;
+            } | {
+                kind: "class.equal";
+                class: {
+                    origin: string;
+                    kind: "class";
+                    name: string;
                 };
-            };
-            equals: {
-                kind: "node";
-                ids: string[];
             } | {
-                kind: "edge";
-                keys: {
+                kind: "property.equal";
+                property: string;
+                value: unknown;
+            } | {
+                kind: "property.present";
+                property: string;
+            } | {
+                kind: "identity.equal";
+                identity: string | {
                     source: string;
                     target: string;
                     class: string;
-                }[];
+                };
             };
-        })[];
-        operations: ({
-            op: "node.create";
-            as: string;
-            class: string;
-            props: Record<string, unknown>;
         } | {
-            op: "node.update";
-            node: string;
-            class: string;
-            props: {
-                set: Record<string, unknown>;
-                unset: string[];
+            op: "expand";
+            from: string;
+            via: {
+                origin: string;
+                kind: "class";
+                name: string;
+            }[];
+            direction: "incident" | "incoming" | "outgoing";
+            bindings: {
+                edge: string;
+                node: string;
             };
-        } | {
-            op: "node.delete";
-            node: string;
-            class: string;
-        } | {
-            op: "edge.create";
-            class: string;
-            source: string | {
-                created: string;
-            };
-            target: string | {
-                created: string;
-            };
-            slug?: unknown;
-            props: Record<string, unknown>;
-        } | {
-            op: "edge.update";
-            edge: {
-                source: string;
-                target: string;
-                class: string;
-            };
-            slug: unknown;
-            props?: {
-                set: Record<string, unknown>;
-                unset: string[];
+        })[];
+        select: {
+            kind: "graph";
+            binding: string;
+            order?: {
+                property: string;
+                direction: "asc" | "desc";
+                unranked: "first" | "last";
             } | undefined;
         } | {
-            op: "edge.update";
-            edge: {
-                source: string;
-                target: string;
-                class: string;
-            };
-            props: {
-                set: Record<string, unknown>;
-                unset: string[];
+            kind: "nodes";
+            binding: string;
+            projection: {
+                kind: "reference" | "value";
             };
+            order?: {
+                property: string;
+                direction: "asc" | "desc";
+                unranked: "first" | "last";
+            } | undefined;
         } | {
-            op: "edge.delete";
-            edge: {
-                source: string;
-                target: string;
-                class: string;
+            kind: "edges";
+            binding: string;
+            projection: {
+                edge: "reference" | "value";
+                source: "reference" | "value";
+                target: "reference" | "value";
             };
-        })[];
+            order?: {
+                property: string;
+                direction: "asc" | "desc";
+                unranked: "first" | "last";
+            } | undefined;
+        };
     };
     expected?: {
         origin: string;
         revision: string;
     }[] | undefined;
+    page: {
+        size: number;
+        after?: string | undefined;
+    };
 }, {
     readonly mode: 'value';
     readonly value: {
-        createdNodes: Record<string, string>;
+        result: {
+            kind: "graph";
+            graph: {
+                nodes: {
+                    id: string;
+                    class: string;
+                    props: Record<string, unknown>;
+                }[];
+                edges: {
+                    source: string;
+                    target: string;
+                    class: string;
+                    slug?: import("../../graph/edge/index.js").EdgeSlug | undefined;
+                    props: Record<string, unknown>;
+                }[];
+            };
+            selection: {
+                kind: "node";
+                ids: string[];
+            } | {
+                kind: "edge";
+                keys: {
+                    source: string;
+                    target: string;
+                    class: string;
+                }[];
+            };
+        } | {
+            kind: "nodes";
+            nodes: ({
+                kind: "reference";
+                value: {
+                    id: string;
+                    class: string;
+                };
+            } | {
+                kind: "value";
+                value: {
+                    id: string;
+                    class: string;
+                    props: Record<string, unknown>;
+                };
+            })[];
+        } | {
+            kind: "edges";
+            edges: {
+                edge: {
+                    kind: "reference";
+                    value: {
+                        source: string;
+                        target: string;
+                        class: string;
+                    };
+                } | {
+                    kind: "value";
+                    value: {
+                        source: string;
+                        target: string;
+                        class: string;
+                        slug?: import("../../graph/edge/index.js").EdgeSlug | undefined;
+                        props: Record<string, unknown>;
+                    };
+                };
+                source: {
+                    kind: "reference";
+                    value: {
+                        id: string;
+                        class: string;
+                    };
+                } | {
+                    kind: "value";
+                    value: {
+                        id: string;
+                        class: string;
+                        props: Record<string, unknown>;
+                    };
+                };
+                target: {
+                    kind: "reference";
+                    value: {
+                        id: string;
+                        class: string;
+                    };
+                } | {
+                    kind: "value";
+                    value: {
+                        id: string;
+                        class: string;
+                        props: Record<string, unknown>;
+                    };
+                };
+            }[];
+        };
+        page: {
+            next?: string | undefined;
+        };
     };
 }, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
-    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"mutate"> & {
+    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"query"> & {
         readonly origin: "kernel.astrale.ai";
     };
-    readonly key: "kernel.astrale.ai:function.mutate";
+    readonly key: "kernel.astrale.ai:function.query";
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
-    idempotencyKey: string;
-    mutation?: {
+    ast: {
         format: "astrale.graph.mutation";
         version: "v3";
         preconditions: ({
@@ -6132,299 +6097,340 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
                 class: string;
             };
         })[];
-    } | undefined;
-    identities: ({
-        identity: {
-            created: string;
-        };
-        authentication?: {
-            iss: string;
-            sub: string;
-        } | {
-            credentials: {
-                publicKey: unknown;
-                proof: string;
-            };
-        } | undefined;
-        requiredClaims?: ({
-            claim: string;
-            op: "contains";
-            value: unknown;
-        } | {
-            claim: string;
-            op: "eq";
-            value: unknown;
-        } | {
-            claim: string;
-            op: "exists";
-        })[] | undefined;
-    } | {
-        identity: {
-            id: string;
-            class: string;
-        };
-        authentication: {
-            iss: string;
-            sub: string;
-        } | {
-            credentials: {
-                publicKey: unknown;
-                proof: string;
-            };
-        };
-    })[];
+    };
+    expected?: {
+        origin: string;
+        revision: string;
+    }[] | undefined;
 }, {
     readonly mode: 'value';
     readonly value: {
         createdNodes: Record<string, string>;
-        identities: ({
-            id: string;
-        } | {
-            id: string;
-            iss: string;
-            sub: string;
-        })[];
     };
 }, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
-    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"provision"> & {
+    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"mutate"> & {
         readonly origin: "kernel.astrale.ai";
     };
-    readonly key: "kernel.astrale.ai:function.provision";
+    readonly key: "kernel.astrale.ai:function.mutate";
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
-    ast: {
-        format: "astrale.graph.query";
-        version: "v6";
-        source: {
+    idempotencyKey: string;
+    mutation?: {
+        format: "astrale.graph.mutation";
+        version: "v3";
+        preconditions: ({
             kind: "node";
-            terms: ({
-                kind: "path";
-                path: string;
+            node: string;
+            class: string;
+            props?: {
+                equals: Record<string, unknown>;
+                absent?: string[] | undefined;
             } | {
-                kind: "class";
-                class: {
-                    origin: string;
-                    kind: "class";
-                    name: string;
-                };
-            })[];
-            binding: string;
+                absent: string[];
+            } | undefined;
         } | {
             kind: "edge";
-            terms: {
-                kind: "class";
-                class: {
-                    origin: string;
-                    kind: "class";
-                    name: string;
-                };
-            }[];
-            bindings: {
+            edge: {
                 source: string;
-                edge: string;
                 target: string;
+                class: string;
             };
-        };
-        steps: ({
-            op: "filter";
-            binding: string;
-            predicate: {
-                kind: "class.satisfies";
-                class: {
-                    origin: string;
-                    kind: "class";
-                    name: string;
-                };
+            slug?: unknown;
+            props?: {
+                equals: Record<string, unknown>;
+                absent?: string[] | undefined;
             } | {
-                kind: "class.equal";
-                class: {
-                    origin: string;
-                    kind: "class";
-                    name: string;
+                absent: string[];
+            } | undefined;
+        } | {
+            kind: "query";
+            query: {
+                format: "astrale.graph.query";
+                version: "v6";
+                source: {
+                    kind: "node";
+                    terms: ({
+                        kind: "path";
+                        path: string;
+                    } | {
+                        kind: "class";
+                        class: {
+                            origin: string;
+                            kind: "class";
+                            name: string;
+                        };
+                    })[];
+                    binding: string;
+                } | {
+                    kind: "edge";
+                    terms: {
+                        kind: "class";
+                        class: {
+                            origin: string;
+                            kind: "class";
+                            name: string;
+                        };
+                    }[];
+                    bindings: {
+                        source: string;
+                        edge: string;
+                        target: string;
+                    };
                 };
+                steps: ({
+                    op: "filter";
+                    binding: string;
+                    predicate: {
+                        kind: "class.satisfies";
+                        class: {
+                            origin: string;
+                            kind: "class";
+                            name: string;
+                        };
+                    } | {
+                        kind: "class.equal";
+                        class: {
+                            origin: string;
+                            kind: "class";
+                            name: string;
+                        };
+                    } | {
+                        kind: "property.equal";
+                        property: string;
+                        value: unknown;
+                    } | {
+                        kind: "property.present";
+                        property: string;
+                    } | {
+                        kind: "identity.equal";
+                        identity: string | {
+                            source: string;
+                            target: string;
+                            class: string;
+                        };
+                    };
+                } | {
+                    op: "expand";
+                    from: string;
+                    via: {
+                        origin: string;
+                        kind: "class";
+                        name: string;
+                    }[];
+                    direction: "incident" | "incoming" | "outgoing";
+                    bindings: {
+                        edge: string;
+                        node: string;
+                    };
+                })[];
+                select: {
+                    kind: "graph";
+                    binding: string;
+                    order?: {
+                        property: string;
+                        direction: "asc" | "desc";
+                        unranked: "first" | "last";
+                    } | undefined;
+                } | {
+                    kind: "nodes";
+                    binding: string;
+                    projection: {
+                        kind: "reference" | "value";
+                    };
+                    order?: {
+                        property: string;
+                        direction: "asc" | "desc";
+                        unranked: "first" | "last";
+                    } | undefined;
+                } | {
+                    kind: "edges";
+                    binding: string;
+                    projection: {
+                        edge: "reference" | "value";
+                        source: "reference" | "value";
+                        target: "reference" | "value";
+                    };
+                    order?: {
+                        property: string;
+                        direction: "asc" | "desc";
+                        unranked: "first" | "last";
+                    } | undefined;
+                };
+            };
+            equals: {
+                kind: "node";
+                ids: string[];
             } | {
-                kind: "property.equal";
-                property: string;
-                value: unknown;
-            } | {
-                kind: "property.present";
-                property: string;
-            } | {
-                kind: "identity.equal";
-                identity: string | {
+                kind: "edge";
+                keys: {
                     source: string;
                     target: string;
                     class: string;
-                };
+                }[];
             };
+        })[];
+        operations: ({
+            op: "node.create";
+            as: string;
+            class: string;
+            props: Record<string, unknown>;
         } | {
-            op: "expand";
-            from: string;
-            via: {
-                origin: string;
-                kind: "class";
-                name: string;
-            }[];
-            direction: "incident" | "incoming" | "outgoing";
-            bindings: {
-                edge: string;
-                node: string;
+            op: "node.update";
+            node: string;
+            class: string;
+            props: {
+                set: Record<string, unknown>;
+                unset: string[];
             };
-        })[];
-        select: {
-            kind: "graph";
-            binding: string;
-            order?: {
-                property: string;
-                direction: "asc" | "desc";
-                unranked: "first" | "last";
-            } | undefined;
         } | {
-            kind: "nodes";
-            binding: string;
-            projection: {
-                kind: "reference" | "value";
+            op: "node.delete";
+            node: string;
+            class: string;
+        } | {
+            op: "edge.create";
+            class: string;
+            source: string | {
+                created: string;
             };
-            order?: {
-                property: string;
-                direction: "asc" | "desc";
-                unranked: "first" | "last";
-            } | undefined;
+            target: string | {
+                created: string;
+            };
+            slug?: unknown;
+            props: Record<string, unknown>;
         } | {
-            kind: "edges";
-            binding: string;
-            projection: {
-                edge: "reference" | "value";
-                source: "reference" | "value";
-                target: "reference" | "value";
+            op: "edge.update";
+            edge: {
+                source: string;
+                target: string;
+                class: string;
             };
-            order?: {
-                property: string;
-                direction: "asc" | "desc";
-                unranked: "first" | "last";
+            slug: unknown;
+            props?: {
+                set: Record<string, unknown>;
+                unset: string[];
             } | undefined;
-        };
-    };
-    expected?: {
-        origin: string;
-        revision: string;
-    }[] | undefined;
-    page: {
-        size: number;
-        after?: string | undefined;
-    };
-}, {
-    readonly mode: 'value';
-    readonly value: {
-        result: {
-            kind: "graph";
-            graph: {
-                nodes: {
-                    id: string;
-                    class: string;
-                    props: Record<string, unknown>;
-                }[];
-                edges: {
-                    source: string;
-                    target: string;
-                    class: string;
-                    slug?: import("../../graph/edge/index.js").EdgeSlug | undefined;
-                    props: Record<string, unknown>;
-                }[];
+        } | {
+            op: "edge.update";
+            edge: {
+                source: string;
+                target: string;
+                class: string;
             };
-            selection: {
-                kind: "node";
-                ids: string[];
-            } | {
-                kind: "edge";
-                keys: {
-                    source: string;
-                    target: string;
-                    class: string;
-                }[];
+            props: {
+                set: Record<string, unknown>;
+                unset: string[];
             };
         } | {
-            kind: "nodes";
-            nodes: ({
-                kind: "reference";
-                value: {
-                    id: string;
-                    class: string;
-                };
-            } | {
-                kind: "value";
-                value: {
-                    id: string;
-                    class: string;
-                    props: Record<string, unknown>;
-                };
-            })[];
+            op: "edge.delete";
+            edge: {
+                source: string;
+                target: string;
+                class: string;
+            };
+        })[];
+    } | undefined;
+    identities: ({
+        identity: {
+            created: string;
+        };
+        authentication?: {
+            iss: string;
+            sub: string;
         } | {
-            kind: "edges";
-            edges: {
-                edge: {
-                    kind: "reference";
-                    value: {
-                        source: string;
-                        target: string;
-                        class: string;
-                    };
-                } | {
-                    kind: "value";
-                    value: {
-                        source: string;
-                        target: string;
-                        class: string;
-                        slug?: import("../../graph/edge/index.js").EdgeSlug | undefined;
-                        props: Record<string, unknown>;
-                    };
-                };
-                source: {
-                    kind: "reference";
-                    value: {
-                        id: string;
-                        class: string;
-                    };
-                } | {
-                    kind: "value";
-                    value: {
-                        id: string;
-                        class: string;
-                        props: Record<string, unknown>;
-                    };
-                };
-                target: {
-                    kind: "reference";
-                    value: {
-                        id: string;
-                        class: string;
-                    };
-                } | {
-                    kind: "value";
-                    value: {
-                        id: string;
-                        class: string;
-                        props: Record<string, unknown>;
-                    };
-                };
-            }[];
+            credentials: {
+                publicKey: unknown;
+                proof: string;
+            };
+        } | undefined;
+        requiredClaims?: ({
+            claim: string;
+            op: "contains";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "eq";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "exists";
+        })[] | undefined;
+    } | {
+        identity: {
+            id: string;
+            class: string;
         };
-        page: {
-            next?: string | undefined;
+        authentication: {
+            iss: string;
+            sub: string;
+        } | {
+            credentials: {
+                publicKey: unknown;
+                proof: string;
+            };
         };
+    })[];
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        createdNodes: Record<string, string>;
+        identities: ({
+            id: string;
+        } | {
+            id: string;
+            iss: string;
+            sub: string;
+        })[];
     };
 }, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
-    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"query"> & {
+    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"provision"> & {
         readonly origin: "kernel.astrale.ai";
     };
-    readonly key: "kernel.astrale.ai:function.query";
+    readonly key: "kernel.astrale.ai:function.provision";
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
     operation: string;
+    domains: ({
+        artifact: {
+            digest: string;
+            mediaType: string;
+            size: number;
+        };
+        currentRevision?: string | null | undefined;
+    } | {
+        publication: {
+            url: string;
+            token?: string | undefined;
+            etag?: string | undefined;
+        };
+        revision?: string | undefined;
+        currentRevision?: string | null | undefined;
+    })[];
+}, {
+    readonly mode: 'binary';
+}, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
+    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"install"> & {
+        readonly origin: "kernel.astrale.ai";
+    };
+    readonly key: "kernel.astrale.ai:function.install";
+}) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
+    kind: "bundle" | "inspect";
     origin: string;
+}, {
+    readonly mode: 'binary';
+}, "authenticated", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
+    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"introspect"> & {
+        readonly origin: "kernel.astrale.ai";
+    };
+    readonly key: "kernel.astrale.ai:function.introspect";
+}) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
+    operation: string;
+    domains: string[];
+    data: {
+        mode: "destructive" | "safe";
+    };
 }, {
     readonly mode: 'value';
     readonly value: {
         operation: string;
-        transition: {
+        transitions: {
             intent: {
                 transition: string;
                 operation: string;
@@ -6452,7 +6458,7 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
                     meaning: string;
                 }[];
             } | undefined;
-        };
+        }[];
     };
 }, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
     readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"uninstall"> & {
@@ -6468,31 +6474,6 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
     readonly value: string;
 }, true, "default", "authenticated", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
     readonly name: "mint";
-}) | (import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
-    iss: string;
-    sub: string;
-}, {
-    readonly mode: 'value';
-    readonly value: {
-        id: string;
-        iss: string;
-        sub: string;
-        frozen: boolean;
-        requiredClaims: ({
-            claim: string;
-            op: "contains";
-            value: unknown;
-        } | {
-            claim: string;
-            op: "eq";
-            value: unknown;
-        } | {
-            claim: string;
-            op: "exists";
-        })[];
-    } | null;
-}, true, "default", "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
-    readonly name: "whois";
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
     target: string;
 }, {
@@ -6527,6 +6508,31 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
     };
 }, true, "sealed", "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>, "kernel.astrale.ai:class.View.method.resolve"> & {
     readonly name: "resolve";
+}) | (import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
+    iss: string;
+    sub: string;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        id: string;
+        iss: string;
+        sub: string;
+        frozen: boolean;
+        requiredClaims: ({
+            claim: string;
+            op: "contains";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "eq";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "exists";
+        })[];
+    } | null;
+}, true, "default", "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+    readonly name: "whois";
 }))[];
 export { AuthorityOperationOrder, AuthorityOperations, operationOf } from '../authority/index.js';
 export type { AuthorityOperation, AuthorityRelation } from '../authority/index.js';

package/dist/schema/kernel/syscalls/contracts/uninstall.d.ts CHANGED Viewed

@@ -2,11 +2,14 @@ import type { OperationId } from '../../../installation/operation-id.js';
 import type { TransitionReceipt } from './install.js';
 export declare const uninstallInput: import("zod").ZodObject<{
     operation: import("zod").ZodString;
-    origin: import("zod").ZodString;
+    domains: import("zod").ZodArray<import("zod").ZodString>;
+    data: import("zod").ZodObject<{
+        mode: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"safe">, import("zod").ZodLiteral<"destructive">]>;
+    }, import("zod/v4/core").$strict>;
 }, import("zod/v4/core").$strict>;
 export declare const uninstallOutput: import("zod").ZodObject<{
     operation: import("zod").ZodString;
-    transition: import("zod").ZodObject<{
+    transitions: import("zod").ZodArray<import("zod").ZodObject<{
         intent: import("zod").ZodObject<{
             transition: import("zod").ZodString;
             operation: import("zod").ZodString;
@@ -37,13 +40,16 @@ export declare const uninstallOutput: import("zod").ZodObject<{
                 meaning: import("zod").ZodString;
             }, import("zod/v4/core").$strict>>;
         }, import("zod/v4/core").$strict>>;
-    }, import("zod/v4/core").$strict>;
+    }, import("zod/v4/core").$strict>>;
 }, import("zod/v4/core").$strict>;
 export interface UninstallInput {
     readonly operation: OperationId;
-    readonly origin: string;
+    readonly domains: readonly [string, ...string[]];
+    readonly data: {
+        readonly mode: 'safe' | 'destructive';
+    };
 }
 export interface UninstallOutput {
     readonly operation: OperationId;
-    readonly transition: TransitionReceipt;
+    readonly transitions: readonly [TransitionReceipt, ...TransitionReceipt[]];
 }

package/dist/schema/kernel/syscalls/contracts/uninstall.js CHANGED Viewed

@@ -1,10 +1,11 @@
-import { strictObject } from 'zod';
+import { array, literal, strictObject, union } from 'zod';
 import { installationText, operationIdSchema, transitionReceipt } from './installation.js';
 export const uninstallInput = strictObject({
     operation: operationIdSchema,
-    origin: installationText,
+    domains: array(installationText).min(1),
+    data: strictObject({ mode: union([literal('safe'), literal('destructive')]) }),
 });
 export const uninstallOutput = strictObject({
     operation: operationIdSchema,
-    transition: transitionReceipt,
+    transitions: array(transitionReceipt).min(1),
 });

package/dist/schema/kernel/syscalls/declarations/index.d.ts CHANGED Viewed

@@ -746,12 +746,15 @@ export declare const Functions: Readonly<{
     }, "authenticated", false, "default">>;
     uninstall: builder.Function<builder.CallableProjection<{
         operation: string;
-        origin: string;
+        domains: string[];
+        data: {
+            mode: "destructive" | "safe";
+        };
     }, {
         readonly mode: 'value';
         readonly value: {
             operation: string;
-            transition: {
+            transitions: {
                 intent: {
                     transition: string;
                     operation: string;
@@ -779,7 +782,7 @@ export declare const Functions: Readonly<{
                         meaning: string;
                     }[];
                 } | undefined;
-            };
+            }[];
         };
     }, "authorized", false, "default">>;
     journal: builder.Function<builder.CallableProjection<{

package/dist/schema/kernel/syscalls/declarations/uninstall.d.ts CHANGED Viewed

@@ -1,12 +1,15 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Uninstall: builder.Function<builder.CallableProjection<{
     operation: string;
-    origin: string;
+    domains: string[];
+    data: {
+        mode: "destructive" | "safe";
+    };
 }, {
     readonly mode: 'value';
     readonly value: {
         operation: string;
-        transition: {
+        transitions: {
             intent: {
                 transition: string;
                 operation: string;
@@ -34,6 +37,6 @@ export declare const Uninstall: builder.Function<builder.CallableProjection<{
                     meaning: string;
                 }[];
             } | undefined;
-        };
+        }[];
     };
 }, "authorized", false, "default">>;

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-core",
-  "version": "0.9.0-beta.32",
+  "version": "0.9.0-beta.33",
   "description": "Astrale Kernel Core - Types, Invariants, and Pure Logic",
   "license": "Apache-2.0",
   "repository": {