@astrale-domains/shell 0.1.0-beta.8 → 0.1.1

package/dist/runtime.d.ts

@@ -1,4 +1,2176 @@
-declare const runtime: import("@astrale-os/sdk/runtime").Runtime<import("@astrale-os/sdk/schema").DomainSchema<"shell.astrale.ai", import("./schema/domain/index.js").ShellSchemaInput, import("@astrale-os/sdk/schema").DomainOfInput<"shell.astrale.ai", import("./schema/domain/index.js").ShellSchemaInput>>, {}, () => {
-    providers: {};
-}, readonly [import("@astrale-os/sdk/action").ActionDefinition<import("@astrale-os/sdk/schema").DomainSchema<"shell.astrale.ai", import("./schema/domain/index.js").ShellSchemaInput, import("@astrale-os/sdk/schema").DomainOfInput<"shell.astrale.ai", import("./schema/domain/index.js").ShellSchemaInput>>, "User.resolveHome", Readonly<Record<never, never>>>], readonly [import("@astrale-os/sdk/workflow").WorkflowDefinition<import("@astrale-os/sdk/schema").DomainSchema<"shell.astrale.ai", import("./schema/domain/index.js").ShellSchemaInput, import("@astrale-os/sdk/schema").DomainOfInput<"shell.astrale.ai", import("./schema/domain/index.js").ShellSchemaInput>>, "setupAdmin", Readonly<Record<never, never>>>, import("@astrale-os/sdk/workflow").WorkflowDefinition<import("@astrale-os/sdk/schema").DomainSchema<"shell.astrale.ai", import("./schema/domain/index.js").ShellSchemaInput, import("@astrale-os/sdk/schema").DomainOfInput<"shell.astrale.ai", import("./schema/domain/index.js").ShellSchemaInput>>, "setupMember", Readonly<Record<never, never>>>, import("@astrale-os/sdk/workflow").WorkflowDefinition<import("@astrale-os/sdk/schema").DomainSchema<"shell.astrale.ai", import("./schema/domain/index.js").ShellSchemaInput, import("@astrale-os/sdk/schema").DomainOfInput<"shell.astrale.ai", import("./schema/domain/index.js").ShellSchemaInput>>, "Group.assignUser", Readonly<Record<never, never>>>, import("@astrale-os/sdk/workflow").WorkflowDefinition<import("@astrale-os/sdk/schema").DomainSchema<"shell.astrale.ai", import("./schema/domain/index.js").ShellSchemaInput, import("@astrale-os/sdk/schema").DomainOfInput<"shell.astrale.ai", import("./schema/domain/index.js").ShellSchemaInput>>, "Group.unassignUser", Readonly<Record<never, never>>>, import("@astrale-os/sdk/workflow").WorkflowDefinition<import("@astrale-os/sdk/schema").DomainSchema<"shell.astrale.ai", import("./schema/domain/index.js").ShellSchemaInput, import("@astrale-os/sdk/schema").DomainOfInput<"shell.astrale.ai", import("./schema/domain/index.js").ShellSchemaInput>>, "Space.addUser", Readonly<Record<never, never>>>, import("@astrale-os/sdk/workflow").WorkflowDefinition<import("@astrale-os/sdk/schema").DomainSchema<"shell.astrale.ai", import("./schema/domain/index.js").ShellSchemaInput, import("@astrale-os/sdk/schema").DomainOfInput<"shell.astrale.ai", import("./schema/domain/index.js").ShellSchemaInput>>, "Space.removeUser", Readonly<Record<never, never>>>, import("@astrale-os/sdk/workflow").WorkflowDefinition<import("@astrale-os/sdk/schema").DomainSchema<"shell.astrale.ai", import("./schema/domain/index.js").ShellSchemaInput, import("@astrale-os/sdk/schema").DomainOfInput<"shell.astrale.ai", import("./schema/domain/index.js").ShellSchemaInput>>, "Space.setDefault", Readonly<Record<never, never>>>]>;
+import { type Runtime } from '@astrale-os/sdk/runtime';
+import type { ShellSchema } from './schema/index.js';
+import { integrations } from './integrations/index.js';
+declare const initialize: (environment: unknown) => {
+    providers: {
+        enrollment: import("@astrale-os/sdk/integration").Provider<import("@astrale-os/sdk/integration").IntegrationDefinition<"shell.enrollment", {
+            invite: import("@astrale-os/sdk/integration").IntegrationOperation<import("./integrations/user-invitation/index.js").InviteRequest, {
+                invitationId: string;
+                user: string;
+                state: "accepted" | "cancelled" | "completed" | "expired" | "failed" | "pending" | "registered" | "registering";
+            }, "keyed" | "safe">;
+        }>>;
+    };
+};
+declare const functions: readonly [import("@astrale-os/sdk/workflow").WorkflowDefinition<import("@astrale-os/sdk/schema").AuthoredSchema<"shell.astrale.ai", readonly ["kernel.astrale.ai", import("@astrale-os/sdk/schema").KernelSchema] | readonly ["shell.astrale.ai", {
+    readonly name: 'Shell';
+    readonly entrypoint: 'application';
+    readonly classes: {
+        readonly User: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly inheritance: "open";
+            readonly policies: {
+                readonly read: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Identity">];
+            readonly properties: {
+                readonly creationKey: import("zod").ZodOptional<import("zod").ZodString>;
+                readonly claimedEmail: import("zod").ZodOptional<import("zod").ZodString>;
+                readonly claimedName: import("zod").ZodOptional<import("zod").ZodString>;
+            };
+            readonly methods: {
+                readonly invite: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    user: string;
+                    email: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        invitationId: string;
+                        user: string;
+                        state: "accepted" | "cancelled" | "completed" | "expired" | "failed" | "pending" | "registered" | "registering";
+                    };
+                }, "authorized", true, false, undefined, undefined>>;
+                readonly recordProfile: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    email?: string | undefined;
+                    displayName?: string | undefined;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+            };
+        }>;
+        readonly Group: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly inheritance: "open";
+            readonly policies: {
+                readonly read: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Identity">, import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">];
+            readonly methods: {
+                readonly assignMember: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    member: string;
+                    group: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", true, false, undefined, undefined>>;
+                readonly unassignMember: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    member: string;
+                    group: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", true, false, undefined, undefined>>;
+            };
+        }>;
+        readonly member_of_group: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "member";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "group";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+        readonly Namespace: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly policies: {
+                readonly read: true;
+                readonly traverse: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">];
+            readonly methods: {
+                readonly link: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                    target: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+                readonly unlink: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+                readonly rename: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                    to: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+            };
+        }>;
+        readonly alias: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "namespace";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "node";
+                readonly accepts: readonly (import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+                    readonly origin: "kernel.astrale.ai";
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+        readonly view_access: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "holder";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "view";
+                readonly accepts: readonly (import("@astrale-os/sdk/schema").ClassRef<"View"> & {
+                    readonly origin: "kernel.astrale.ai";
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+    };
+    readonly functions: {
+        readonly listEntrypoints: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+            readonly mode: 'value';
+            readonly value: {
+                entrypoints: {
+                    origin: string;
+                    name: string;
+                    view: string;
+                }[];
+            };
+        }, "authorized", false, false, undefined, undefined>>;
+        readonly assignViews: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<{
+            assignments: {
+                identity: string;
+                set?: string[] | undefined;
+                unset?: string[] | undefined;
+            }[];
+        }, {
+            readonly mode: 'value';
+            readonly value: Record<string, never>;
+        }, "authorized", false, false, undefined, undefined>>;
+    };
+    readonly policies: {
+        readonly belongsToGroup: import("@astrale-os/sdk/schema").Policy;
+        readonly ownsClass: import("@astrale-os/sdk/schema").Policy;
+        readonly administersShellClass: import("@astrale-os/sdk/schema").Policy;
+        readonly usesFunction: import("@astrale-os/sdk/schema").Policy;
+        readonly isSelf: import("@astrale-os/sdk/schema").Policy;
+    };
+    readonly views: {
+        readonly application: import("@astrale-os/sdk/schema").View;
+    };
+    readonly core: {
+        readonly nodes: {
+            readonly admin: import("@astrale-os/sdk/schema").CoreNode;
+            readonly applications: import("@astrale-os/sdk/schema").CoreNode;
+            readonly member: import("@astrale-os/sdk/schema").CoreNode;
+            readonly views: import("@astrale-os/sdk/schema").CoreNode;
+            readonly 'view-only': import("@astrale-os/sdk/schema").CoreNode;
+        };
+    };
+}, {
+    readonly kernel: "kernel.astrale.ai";
+}]>, "User.invite", {
+    enrollment: import("@astrale-os/sdk/integration").IntegrationDefinition<"shell.enrollment", {
+        invite: import("@astrale-os/sdk/integration").IntegrationOperation<import("./integrations/user-invitation/index.js").InviteRequest, {
+            invitationId: string;
+            user: string;
+            state: "accepted" | "cancelled" | "completed" | "expired" | "failed" | "pending" | "registered" | "registering";
+        }, "keyed" | "safe">;
+    }>;
+}, {
+    readonly INVALID_INVITATION_REFERENCE: {
+        readonly family: "VALIDATION_ERROR";
+        readonly message: "User must be an exact canonical @NodeId path.";
+        readonly details: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+    };
+    readonly INVITATION_CONFLICT: {
+        readonly family: "CONFLICT";
+        readonly message: "The invitation conflicts with an existing request.";
+        readonly details: import("zod").ZodObject<{
+            requestId: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+    };
+    readonly INVITATION_REJECTED: {
+        readonly family: "VALIDATION_ERROR";
+        readonly message: "Admin rejected the invitation request.";
+        readonly details: import("zod").ZodObject<{
+            requestId: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+    };
+}>, import("@astrale-os/sdk/workflow").WorkflowDefinition<import("@astrale-os/sdk/schema").AuthoredSchema<"shell.astrale.ai", readonly ["kernel.astrale.ai", import("@astrale-os/sdk/schema").KernelSchema] | readonly ["shell.astrale.ai", {
+    readonly name: 'Shell';
+    readonly entrypoint: 'application';
+    readonly classes: {
+        readonly User: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly inheritance: "open";
+            readonly policies: {
+                readonly read: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Identity">];
+            readonly properties: {
+                readonly creationKey: import("zod").ZodOptional<import("zod").ZodString>;
+                readonly claimedEmail: import("zod").ZodOptional<import("zod").ZodString>;
+                readonly claimedName: import("zod").ZodOptional<import("zod").ZodString>;
+            };
+            readonly methods: {
+                readonly invite: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    user: string;
+                    email: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        invitationId: string;
+                        user: string;
+                        state: "accepted" | "cancelled" | "completed" | "expired" | "failed" | "pending" | "registered" | "registering";
+                    };
+                }, "authorized", true, false, undefined, undefined>>;
+                readonly recordProfile: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    email?: string | undefined;
+                    displayName?: string | undefined;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+            };
+        }>;
+        readonly Group: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly inheritance: "open";
+            readonly policies: {
+                readonly read: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Identity">, import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">];
+            readonly methods: {
+                readonly assignMember: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    member: string;
+                    group: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", true, false, undefined, undefined>>;
+                readonly unassignMember: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    member: string;
+                    group: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", true, false, undefined, undefined>>;
+            };
+        }>;
+        readonly member_of_group: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "member";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "group";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+        readonly Namespace: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly policies: {
+                readonly read: true;
+                readonly traverse: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">];
+            readonly methods: {
+                readonly link: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                    target: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+                readonly unlink: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+                readonly rename: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                    to: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+            };
+        }>;
+        readonly alias: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "namespace";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "node";
+                readonly accepts: readonly (import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+                    readonly origin: "kernel.astrale.ai";
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+        readonly view_access: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "holder";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "view";
+                readonly accepts: readonly (import("@astrale-os/sdk/schema").ClassRef<"View"> & {
+                    readonly origin: "kernel.astrale.ai";
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+    };
+    readonly functions: {
+        readonly listEntrypoints: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+            readonly mode: 'value';
+            readonly value: {
+                entrypoints: {
+                    origin: string;
+                    name: string;
+                    view: string;
+                }[];
+            };
+        }, "authorized", false, false, undefined, undefined>>;
+        readonly assignViews: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<{
+            assignments: {
+                identity: string;
+                set?: string[] | undefined;
+                unset?: string[] | undefined;
+            }[];
+        }, {
+            readonly mode: 'value';
+            readonly value: Record<string, never>;
+        }, "authorized", false, false, undefined, undefined>>;
+    };
+    readonly policies: {
+        readonly belongsToGroup: import("@astrale-os/sdk/schema").Policy;
+        readonly ownsClass: import("@astrale-os/sdk/schema").Policy;
+        readonly administersShellClass: import("@astrale-os/sdk/schema").Policy;
+        readonly usesFunction: import("@astrale-os/sdk/schema").Policy;
+        readonly isSelf: import("@astrale-os/sdk/schema").Policy;
+    };
+    readonly views: {
+        readonly application: import("@astrale-os/sdk/schema").View;
+    };
+    readonly core: {
+        readonly nodes: {
+            readonly admin: import("@astrale-os/sdk/schema").CoreNode;
+            readonly applications: import("@astrale-os/sdk/schema").CoreNode;
+            readonly member: import("@astrale-os/sdk/schema").CoreNode;
+            readonly views: import("@astrale-os/sdk/schema").CoreNode;
+            readonly 'view-only': import("@astrale-os/sdk/schema").CoreNode;
+        };
+    };
+}, {
+    readonly kernel: "kernel.astrale.ai";
+}]>, "Group.assignMember", Readonly<Record<never, never>>, {
+    readonly GROUP_MEMBERSHIP_ENDPOINTS_UNAVAILABLE: {
+        readonly family: 'CONFLICT';
+        readonly message: 'Shell must be able to traverse both membership endpoints before confirming membership.';
+        readonly details: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+    };
+    readonly INVALID_GROUP_MEMBERSHIP_REFERENCE: {
+        readonly family: 'VALIDATION_ERROR';
+        readonly message: 'Member and group must be exact canonical @NodeId paths.';
+        readonly details: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+    };
+    readonly GROUP_MEMBERSHIP_CONFLICT: {
+        readonly family: 'CONFLICT';
+        readonly message: 'Membership changed concurrently; retry the operation.';
+        readonly details: import("zod").ZodObject<{
+            cause: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+    };
+    readonly GROUP_MEMBERSHIP_UNCONFIRMED: {
+        readonly family: 'CONFLICT';
+        readonly message: 'The requested membership could not be confirmed; retry the operation.';
+        readonly details: import("zod").ZodObject<{
+            cause: import("zod").ZodString;
+            outcomeKnown: import("zod").ZodLiteral<false>;
+        }, import("zod/v4/core").$strict>;
+    };
+}>, import("@astrale-os/sdk/workflow").WorkflowDefinition<import("@astrale-os/sdk/schema").AuthoredSchema<"shell.astrale.ai", readonly ["kernel.astrale.ai", import("@astrale-os/sdk/schema").KernelSchema] | readonly ["shell.astrale.ai", {
+    readonly name: 'Shell';
+    readonly entrypoint: 'application';
+    readonly classes: {
+        readonly User: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly inheritance: "open";
+            readonly policies: {
+                readonly read: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Identity">];
+            readonly properties: {
+                readonly creationKey: import("zod").ZodOptional<import("zod").ZodString>;
+                readonly claimedEmail: import("zod").ZodOptional<import("zod").ZodString>;
+                readonly claimedName: import("zod").ZodOptional<import("zod").ZodString>;
+            };
+            readonly methods: {
+                readonly invite: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    user: string;
+                    email: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        invitationId: string;
+                        user: string;
+                        state: "accepted" | "cancelled" | "completed" | "expired" | "failed" | "pending" | "registered" | "registering";
+                    };
+                }, "authorized", true, false, undefined, undefined>>;
+                readonly recordProfile: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    email?: string | undefined;
+                    displayName?: string | undefined;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+            };
+        }>;
+        readonly Group: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly inheritance: "open";
+            readonly policies: {
+                readonly read: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Identity">, import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">];
+            readonly methods: {
+                readonly assignMember: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    member: string;
+                    group: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", true, false, undefined, undefined>>;
+                readonly unassignMember: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    member: string;
+                    group: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", true, false, undefined, undefined>>;
+            };
+        }>;
+        readonly member_of_group: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "member";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "group";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+        readonly Namespace: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly policies: {
+                readonly read: true;
+                readonly traverse: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">];
+            readonly methods: {
+                readonly link: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                    target: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+                readonly unlink: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+                readonly rename: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                    to: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+            };
+        }>;
+        readonly alias: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "namespace";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "node";
+                readonly accepts: readonly (import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+                    readonly origin: "kernel.astrale.ai";
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+        readonly view_access: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "holder";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "view";
+                readonly accepts: readonly (import("@astrale-os/sdk/schema").ClassRef<"View"> & {
+                    readonly origin: "kernel.astrale.ai";
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+    };
+    readonly functions: {
+        readonly listEntrypoints: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+            readonly mode: 'value';
+            readonly value: {
+                entrypoints: {
+                    origin: string;
+                    name: string;
+                    view: string;
+                }[];
+            };
+        }, "authorized", false, false, undefined, undefined>>;
+        readonly assignViews: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<{
+            assignments: {
+                identity: string;
+                set?: string[] | undefined;
+                unset?: string[] | undefined;
+            }[];
+        }, {
+            readonly mode: 'value';
+            readonly value: Record<string, never>;
+        }, "authorized", false, false, undefined, undefined>>;
+    };
+    readonly policies: {
+        readonly belongsToGroup: import("@astrale-os/sdk/schema").Policy;
+        readonly ownsClass: import("@astrale-os/sdk/schema").Policy;
+        readonly administersShellClass: import("@astrale-os/sdk/schema").Policy;
+        readonly usesFunction: import("@astrale-os/sdk/schema").Policy;
+        readonly isSelf: import("@astrale-os/sdk/schema").Policy;
+    };
+    readonly views: {
+        readonly application: import("@astrale-os/sdk/schema").View;
+    };
+    readonly core: {
+        readonly nodes: {
+            readonly admin: import("@astrale-os/sdk/schema").CoreNode;
+            readonly applications: import("@astrale-os/sdk/schema").CoreNode;
+            readonly member: import("@astrale-os/sdk/schema").CoreNode;
+            readonly views: import("@astrale-os/sdk/schema").CoreNode;
+            readonly 'view-only': import("@astrale-os/sdk/schema").CoreNode;
+        };
+    };
+}, {
+    readonly kernel: "kernel.astrale.ai";
+}]>, "Group.unassignMember", Readonly<Record<never, never>>, {
+    readonly GROUP_MEMBERSHIP_ENDPOINTS_UNAVAILABLE: {
+        readonly family: 'CONFLICT';
+        readonly message: 'Shell must be able to traverse both membership endpoints before confirming membership.';
+        readonly details: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+    };
+    readonly INVALID_GROUP_MEMBERSHIP_REFERENCE: {
+        readonly family: 'VALIDATION_ERROR';
+        readonly message: 'Member and group must be exact canonical @NodeId paths.';
+        readonly details: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+    };
+    readonly GROUP_MEMBERSHIP_CONFLICT: {
+        readonly family: 'CONFLICT';
+        readonly message: 'Membership changed concurrently; retry the operation.';
+        readonly details: import("zod").ZodObject<{
+            cause: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+    };
+    readonly GROUP_MEMBERSHIP_UNCONFIRMED: {
+        readonly family: 'CONFLICT';
+        readonly message: 'The requested membership could not be confirmed; retry the operation.';
+        readonly details: import("zod").ZodObject<{
+            cause: import("zod").ZodString;
+            outcomeKnown: import("zod").ZodLiteral<false>;
+        }, import("zod/v4/core").$strict>;
+    };
+}>, import("@astrale-os/sdk/action").ActionDefinition<import("@astrale-os/sdk/schema").AuthoredSchema<"shell.astrale.ai", readonly ["kernel.astrale.ai", import("@astrale-os/sdk/schema").KernelSchema] | readonly ["shell.astrale.ai", {
+    readonly name: 'Shell';
+    readonly entrypoint: 'application';
+    readonly classes: {
+        readonly User: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly inheritance: "open";
+            readonly policies: {
+                readonly read: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Identity">];
+            readonly properties: {
+                readonly creationKey: import("zod").ZodOptional<import("zod").ZodString>;
+                readonly claimedEmail: import("zod").ZodOptional<import("zod").ZodString>;
+                readonly claimedName: import("zod").ZodOptional<import("zod").ZodString>;
+            };
+            readonly methods: {
+                readonly invite: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    user: string;
+                    email: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        invitationId: string;
+                        user: string;
+                        state: "accepted" | "cancelled" | "completed" | "expired" | "failed" | "pending" | "registered" | "registering";
+                    };
+                }, "authorized", true, false, undefined, undefined>>;
+                readonly recordProfile: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    email?: string | undefined;
+                    displayName?: string | undefined;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+            };
+        }>;
+        readonly Group: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly inheritance: "open";
+            readonly policies: {
+                readonly read: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Identity">, import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">];
+            readonly methods: {
+                readonly assignMember: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    member: string;
+                    group: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", true, false, undefined, undefined>>;
+                readonly unassignMember: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    member: string;
+                    group: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", true, false, undefined, undefined>>;
+            };
+        }>;
+        readonly member_of_group: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "member";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "group";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+        readonly Namespace: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly policies: {
+                readonly read: true;
+                readonly traverse: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">];
+            readonly methods: {
+                readonly link: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                    target: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+                readonly unlink: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+                readonly rename: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                    to: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+            };
+        }>;
+        readonly alias: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "namespace";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "node";
+                readonly accepts: readonly (import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+                    readonly origin: "kernel.astrale.ai";
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+        readonly view_access: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "holder";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "view";
+                readonly accepts: readonly (import("@astrale-os/sdk/schema").ClassRef<"View"> & {
+                    readonly origin: "kernel.astrale.ai";
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+    };
+    readonly functions: {
+        readonly listEntrypoints: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+            readonly mode: 'value';
+            readonly value: {
+                entrypoints: {
+                    origin: string;
+                    name: string;
+                    view: string;
+                }[];
+            };
+        }, "authorized", false, false, undefined, undefined>>;
+        readonly assignViews: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<{
+            assignments: {
+                identity: string;
+                set?: string[] | undefined;
+                unset?: string[] | undefined;
+            }[];
+        }, {
+            readonly mode: 'value';
+            readonly value: Record<string, never>;
+        }, "authorized", false, false, undefined, undefined>>;
+    };
+    readonly policies: {
+        readonly belongsToGroup: import("@astrale-os/sdk/schema").Policy;
+        readonly ownsClass: import("@astrale-os/sdk/schema").Policy;
+        readonly administersShellClass: import("@astrale-os/sdk/schema").Policy;
+        readonly usesFunction: import("@astrale-os/sdk/schema").Policy;
+        readonly isSelf: import("@astrale-os/sdk/schema").Policy;
+    };
+    readonly views: {
+        readonly application: import("@astrale-os/sdk/schema").View;
+    };
+    readonly core: {
+        readonly nodes: {
+            readonly admin: import("@astrale-os/sdk/schema").CoreNode;
+            readonly applications: import("@astrale-os/sdk/schema").CoreNode;
+            readonly member: import("@astrale-os/sdk/schema").CoreNode;
+            readonly views: import("@astrale-os/sdk/schema").CoreNode;
+            readonly 'view-only': import("@astrale-os/sdk/schema").CoreNode;
+        };
+    };
+}, {
+    readonly kernel: "kernel.astrale.ai";
+}]>, "listEntrypoints", Readonly<Record<never, never>>, Readonly<Record<never, never>>>, import("@astrale-os/sdk/action").ActionDefinition<import("@astrale-os/sdk/schema").AuthoredSchema<"shell.astrale.ai", readonly ["kernel.astrale.ai", import("@astrale-os/sdk/schema").KernelSchema] | readonly ["shell.astrale.ai", {
+    readonly name: 'Shell';
+    readonly entrypoint: 'application';
+    readonly classes: {
+        readonly User: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly inheritance: "open";
+            readonly policies: {
+                readonly read: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Identity">];
+            readonly properties: {
+                readonly creationKey: import("zod").ZodOptional<import("zod").ZodString>;
+                readonly claimedEmail: import("zod").ZodOptional<import("zod").ZodString>;
+                readonly claimedName: import("zod").ZodOptional<import("zod").ZodString>;
+            };
+            readonly methods: {
+                readonly invite: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    user: string;
+                    email: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        invitationId: string;
+                        user: string;
+                        state: "accepted" | "cancelled" | "completed" | "expired" | "failed" | "pending" | "registered" | "registering";
+                    };
+                }, "authorized", true, false, undefined, undefined>>;
+                readonly recordProfile: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    email?: string | undefined;
+                    displayName?: string | undefined;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+            };
+        }>;
+        readonly Group: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly inheritance: "open";
+            readonly policies: {
+                readonly read: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Identity">, import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">];
+            readonly methods: {
+                readonly assignMember: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    member: string;
+                    group: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", true, false, undefined, undefined>>;
+                readonly unassignMember: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    member: string;
+                    group: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", true, false, undefined, undefined>>;
+            };
+        }>;
+        readonly member_of_group: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "member";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "group";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+        readonly Namespace: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly policies: {
+                readonly read: true;
+                readonly traverse: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">];
+            readonly methods: {
+                readonly link: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                    target: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+                readonly unlink: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+                readonly rename: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                    to: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+            };
+        }>;
+        readonly alias: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "namespace";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "node";
+                readonly accepts: readonly (import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+                    readonly origin: "kernel.astrale.ai";
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+        readonly view_access: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "holder";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "view";
+                readonly accepts: readonly (import("@astrale-os/sdk/schema").ClassRef<"View"> & {
+                    readonly origin: "kernel.astrale.ai";
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+    };
+    readonly functions: {
+        readonly listEntrypoints: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+            readonly mode: 'value';
+            readonly value: {
+                entrypoints: {
+                    origin: string;
+                    name: string;
+                    view: string;
+                }[];
+            };
+        }, "authorized", false, false, undefined, undefined>>;
+        readonly assignViews: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<{
+            assignments: {
+                identity: string;
+                set?: string[] | undefined;
+                unset?: string[] | undefined;
+            }[];
+        }, {
+            readonly mode: 'value';
+            readonly value: Record<string, never>;
+        }, "authorized", false, false, undefined, undefined>>;
+    };
+    readonly policies: {
+        readonly belongsToGroup: import("@astrale-os/sdk/schema").Policy;
+        readonly ownsClass: import("@astrale-os/sdk/schema").Policy;
+        readonly administersShellClass: import("@astrale-os/sdk/schema").Policy;
+        readonly usesFunction: import("@astrale-os/sdk/schema").Policy;
+        readonly isSelf: import("@astrale-os/sdk/schema").Policy;
+    };
+    readonly views: {
+        readonly application: import("@astrale-os/sdk/schema").View;
+    };
+    readonly core: {
+        readonly nodes: {
+            readonly admin: import("@astrale-os/sdk/schema").CoreNode;
+            readonly applications: import("@astrale-os/sdk/schema").CoreNode;
+            readonly member: import("@astrale-os/sdk/schema").CoreNode;
+            readonly views: import("@astrale-os/sdk/schema").CoreNode;
+            readonly 'view-only': import("@astrale-os/sdk/schema").CoreNode;
+        };
+    };
+}, {
+    readonly kernel: "kernel.astrale.ai";
+}]>, "Namespace.link", Readonly<Record<never, never>>, {
+    readonly INVALID_NAME: {
+        readonly family: 'VALIDATION_ERROR';
+        readonly message: 'A name uses lower-case letters, digits, ".", "_" and "-", and starts and ends with a letter or digit.';
+        readonly details: import("zod").ZodObject<{
+            name: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+    };
+    readonly TARGET_NOT_FOUND: {
+        readonly family: 'NOT_FOUND';
+        readonly message: 'The target Path reaches no Node.';
+        readonly details: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+    };
+    readonly NAME_TAKEN: {
+        readonly family: 'CONFLICT';
+        readonly message: 'This name already designates a Node in this Namespace.';
+        readonly details: import("zod").ZodObject<{
+            name: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+    };
+    readonly TARGET_ALREADY_ALIASED: {
+        readonly family: 'CONFLICT';
+        readonly message: 'This Node already has an alias in this Namespace; rename it instead.';
+        readonly details: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+    };
+    readonly NAME_NOT_FOUND: {
+        readonly family: 'NOT_FOUND';
+        readonly message: 'No alias of this Namespace has this name.';
+        readonly details: import("zod").ZodObject<{
+            name: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+    };
+}>, import("@astrale-os/sdk/action").ActionDefinition<import("@astrale-os/sdk/schema").AuthoredSchema<"shell.astrale.ai", readonly ["kernel.astrale.ai", import("@astrale-os/sdk/schema").KernelSchema] | readonly ["shell.astrale.ai", {
+    readonly name: 'Shell';
+    readonly entrypoint: 'application';
+    readonly classes: {
+        readonly User: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly inheritance: "open";
+            readonly policies: {
+                readonly read: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Identity">];
+            readonly properties: {
+                readonly creationKey: import("zod").ZodOptional<import("zod").ZodString>;
+                readonly claimedEmail: import("zod").ZodOptional<import("zod").ZodString>;
+                readonly claimedName: import("zod").ZodOptional<import("zod").ZodString>;
+            };
+            readonly methods: {
+                readonly invite: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    user: string;
+                    email: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        invitationId: string;
+                        user: string;
+                        state: "accepted" | "cancelled" | "completed" | "expired" | "failed" | "pending" | "registered" | "registering";
+                    };
+                }, "authorized", true, false, undefined, undefined>>;
+                readonly recordProfile: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    email?: string | undefined;
+                    displayName?: string | undefined;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+            };
+        }>;
+        readonly Group: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly inheritance: "open";
+            readonly policies: {
+                readonly read: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Identity">, import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">];
+            readonly methods: {
+                readonly assignMember: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    member: string;
+                    group: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", true, false, undefined, undefined>>;
+                readonly unassignMember: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    member: string;
+                    group: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", true, false, undefined, undefined>>;
+            };
+        }>;
+        readonly member_of_group: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "member";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "group";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+        readonly Namespace: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly policies: {
+                readonly read: true;
+                readonly traverse: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">];
+            readonly methods: {
+                readonly link: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                    target: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+                readonly unlink: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+                readonly rename: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                    to: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+            };
+        }>;
+        readonly alias: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "namespace";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "node";
+                readonly accepts: readonly (import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+                    readonly origin: "kernel.astrale.ai";
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+        readonly view_access: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "holder";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "view";
+                readonly accepts: readonly (import("@astrale-os/sdk/schema").ClassRef<"View"> & {
+                    readonly origin: "kernel.astrale.ai";
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+    };
+    readonly functions: {
+        readonly listEntrypoints: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+            readonly mode: 'value';
+            readonly value: {
+                entrypoints: {
+                    origin: string;
+                    name: string;
+                    view: string;
+                }[];
+            };
+        }, "authorized", false, false, undefined, undefined>>;
+        readonly assignViews: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<{
+            assignments: {
+                identity: string;
+                set?: string[] | undefined;
+                unset?: string[] | undefined;
+            }[];
+        }, {
+            readonly mode: 'value';
+            readonly value: Record<string, never>;
+        }, "authorized", false, false, undefined, undefined>>;
+    };
+    readonly policies: {
+        readonly belongsToGroup: import("@astrale-os/sdk/schema").Policy;
+        readonly ownsClass: import("@astrale-os/sdk/schema").Policy;
+        readonly administersShellClass: import("@astrale-os/sdk/schema").Policy;
+        readonly usesFunction: import("@astrale-os/sdk/schema").Policy;
+        readonly isSelf: import("@astrale-os/sdk/schema").Policy;
+    };
+    readonly views: {
+        readonly application: import("@astrale-os/sdk/schema").View;
+    };
+    readonly core: {
+        readonly nodes: {
+            readonly admin: import("@astrale-os/sdk/schema").CoreNode;
+            readonly applications: import("@astrale-os/sdk/schema").CoreNode;
+            readonly member: import("@astrale-os/sdk/schema").CoreNode;
+            readonly views: import("@astrale-os/sdk/schema").CoreNode;
+            readonly 'view-only': import("@astrale-os/sdk/schema").CoreNode;
+        };
+    };
+}, {
+    readonly kernel: "kernel.astrale.ai";
+}]>, "Namespace.unlink", Readonly<Record<never, never>>, {
+    readonly INVALID_NAME: {
+        readonly family: 'VALIDATION_ERROR';
+        readonly message: 'A name uses lower-case letters, digits, ".", "_" and "-", and starts and ends with a letter or digit.';
+        readonly details: import("zod").ZodObject<{
+            name: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+    };
+    readonly TARGET_NOT_FOUND: {
+        readonly family: 'NOT_FOUND';
+        readonly message: 'The target Path reaches no Node.';
+        readonly details: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+    };
+    readonly NAME_TAKEN: {
+        readonly family: 'CONFLICT';
+        readonly message: 'This name already designates a Node in this Namespace.';
+        readonly details: import("zod").ZodObject<{
+            name: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+    };
+    readonly TARGET_ALREADY_ALIASED: {
+        readonly family: 'CONFLICT';
+        readonly message: 'This Node already has an alias in this Namespace; rename it instead.';
+        readonly details: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+    };
+    readonly NAME_NOT_FOUND: {
+        readonly family: 'NOT_FOUND';
+        readonly message: 'No alias of this Namespace has this name.';
+        readonly details: import("zod").ZodObject<{
+            name: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+    };
+}>, import("@astrale-os/sdk/action").ActionDefinition<import("@astrale-os/sdk/schema").AuthoredSchema<"shell.astrale.ai", readonly ["kernel.astrale.ai", import("@astrale-os/sdk/schema").KernelSchema] | readonly ["shell.astrale.ai", {
+    readonly name: 'Shell';
+    readonly entrypoint: 'application';
+    readonly classes: {
+        readonly User: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly inheritance: "open";
+            readonly policies: {
+                readonly read: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Identity">];
+            readonly properties: {
+                readonly creationKey: import("zod").ZodOptional<import("zod").ZodString>;
+                readonly claimedEmail: import("zod").ZodOptional<import("zod").ZodString>;
+                readonly claimedName: import("zod").ZodOptional<import("zod").ZodString>;
+            };
+            readonly methods: {
+                readonly invite: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    user: string;
+                    email: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        invitationId: string;
+                        user: string;
+                        state: "accepted" | "cancelled" | "completed" | "expired" | "failed" | "pending" | "registered" | "registering";
+                    };
+                }, "authorized", true, false, undefined, undefined>>;
+                readonly recordProfile: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    email?: string | undefined;
+                    displayName?: string | undefined;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+            };
+        }>;
+        readonly Group: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly inheritance: "open";
+            readonly policies: {
+                readonly read: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Identity">, import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">];
+            readonly methods: {
+                readonly assignMember: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    member: string;
+                    group: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", true, false, undefined, undefined>>;
+                readonly unassignMember: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    member: string;
+                    group: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", true, false, undefined, undefined>>;
+            };
+        }>;
+        readonly member_of_group: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "member";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "group";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+        readonly Namespace: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly policies: {
+                readonly read: true;
+                readonly traverse: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">];
+            readonly methods: {
+                readonly link: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                    target: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+                readonly unlink: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+                readonly rename: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                    to: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+            };
+        }>;
+        readonly alias: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "namespace";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "node";
+                readonly accepts: readonly (import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+                    readonly origin: "kernel.astrale.ai";
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+        readonly view_access: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "holder";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "view";
+                readonly accepts: readonly (import("@astrale-os/sdk/schema").ClassRef<"View"> & {
+                    readonly origin: "kernel.astrale.ai";
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+    };
+    readonly functions: {
+        readonly listEntrypoints: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+            readonly mode: 'value';
+            readonly value: {
+                entrypoints: {
+                    origin: string;
+                    name: string;
+                    view: string;
+                }[];
+            };
+        }, "authorized", false, false, undefined, undefined>>;
+        readonly assignViews: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<{
+            assignments: {
+                identity: string;
+                set?: string[] | undefined;
+                unset?: string[] | undefined;
+            }[];
+        }, {
+            readonly mode: 'value';
+            readonly value: Record<string, never>;
+        }, "authorized", false, false, undefined, undefined>>;
+    };
+    readonly policies: {
+        readonly belongsToGroup: import("@astrale-os/sdk/schema").Policy;
+        readonly ownsClass: import("@astrale-os/sdk/schema").Policy;
+        readonly administersShellClass: import("@astrale-os/sdk/schema").Policy;
+        readonly usesFunction: import("@astrale-os/sdk/schema").Policy;
+        readonly isSelf: import("@astrale-os/sdk/schema").Policy;
+    };
+    readonly views: {
+        readonly application: import("@astrale-os/sdk/schema").View;
+    };
+    readonly core: {
+        readonly nodes: {
+            readonly admin: import("@astrale-os/sdk/schema").CoreNode;
+            readonly applications: import("@astrale-os/sdk/schema").CoreNode;
+            readonly member: import("@astrale-os/sdk/schema").CoreNode;
+            readonly views: import("@astrale-os/sdk/schema").CoreNode;
+            readonly 'view-only': import("@astrale-os/sdk/schema").CoreNode;
+        };
+    };
+}, {
+    readonly kernel: "kernel.astrale.ai";
+}]>, "Namespace.rename", Readonly<Record<never, never>>, {
+    readonly INVALID_NAME: {
+        readonly family: 'VALIDATION_ERROR';
+        readonly message: 'A name uses lower-case letters, digits, ".", "_" and "-", and starts and ends with a letter or digit.';
+        readonly details: import("zod").ZodObject<{
+            name: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+    };
+    readonly TARGET_NOT_FOUND: {
+        readonly family: 'NOT_FOUND';
+        readonly message: 'The target Path reaches no Node.';
+        readonly details: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+    };
+    readonly NAME_TAKEN: {
+        readonly family: 'CONFLICT';
+        readonly message: 'This name already designates a Node in this Namespace.';
+        readonly details: import("zod").ZodObject<{
+            name: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+    };
+    readonly TARGET_ALREADY_ALIASED: {
+        readonly family: 'CONFLICT';
+        readonly message: 'This Node already has an alias in this Namespace; rename it instead.';
+        readonly details: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+    };
+    readonly NAME_NOT_FOUND: {
+        readonly family: 'NOT_FOUND';
+        readonly message: 'No alias of this Namespace has this name.';
+        readonly details: import("zod").ZodObject<{
+            name: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+    };
+}>, import("@astrale-os/sdk/action").ActionDefinition<import("@astrale-os/sdk/schema").AuthoredSchema<"shell.astrale.ai", readonly ["kernel.astrale.ai", import("@astrale-os/sdk/schema").KernelSchema] | readonly ["shell.astrale.ai", {
+    readonly name: 'Shell';
+    readonly entrypoint: 'application';
+    readonly classes: {
+        readonly User: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly inheritance: "open";
+            readonly policies: {
+                readonly read: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Identity">];
+            readonly properties: {
+                readonly creationKey: import("zod").ZodOptional<import("zod").ZodString>;
+                readonly claimedEmail: import("zod").ZodOptional<import("zod").ZodString>;
+                readonly claimedName: import("zod").ZodOptional<import("zod").ZodString>;
+            };
+            readonly methods: {
+                readonly invite: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    user: string;
+                    email: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        invitationId: string;
+                        user: string;
+                        state: "accepted" | "cancelled" | "completed" | "expired" | "failed" | "pending" | "registered" | "registering";
+                    };
+                }, "authorized", true, false, undefined, undefined>>;
+                readonly recordProfile: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    email?: string | undefined;
+                    displayName?: string | undefined;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+            };
+        }>;
+        readonly Group: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly inheritance: "open";
+            readonly policies: {
+                readonly read: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Identity">, import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">];
+            readonly methods: {
+                readonly assignMember: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    member: string;
+                    group: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", true, false, undefined, undefined>>;
+                readonly unassignMember: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    member: string;
+                    group: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", true, false, undefined, undefined>>;
+            };
+        }>;
+        readonly member_of_group: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "member";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "group";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+        readonly Namespace: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly policies: {
+                readonly read: true;
+                readonly traverse: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">];
+            readonly methods: {
+                readonly link: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                    target: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+                readonly unlink: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+                readonly rename: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                    to: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+            };
+        }>;
+        readonly alias: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "namespace";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "node";
+                readonly accepts: readonly (import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+                    readonly origin: "kernel.astrale.ai";
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+        readonly view_access: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "holder";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "view";
+                readonly accepts: readonly (import("@astrale-os/sdk/schema").ClassRef<"View"> & {
+                    readonly origin: "kernel.astrale.ai";
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+    };
+    readonly functions: {
+        readonly listEntrypoints: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+            readonly mode: 'value';
+            readonly value: {
+                entrypoints: {
+                    origin: string;
+                    name: string;
+                    view: string;
+                }[];
+            };
+        }, "authorized", false, false, undefined, undefined>>;
+        readonly assignViews: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<{
+            assignments: {
+                identity: string;
+                set?: string[] | undefined;
+                unset?: string[] | undefined;
+            }[];
+        }, {
+            readonly mode: 'value';
+            readonly value: Record<string, never>;
+        }, "authorized", false, false, undefined, undefined>>;
+    };
+    readonly policies: {
+        readonly belongsToGroup: import("@astrale-os/sdk/schema").Policy;
+        readonly ownsClass: import("@astrale-os/sdk/schema").Policy;
+        readonly administersShellClass: import("@astrale-os/sdk/schema").Policy;
+        readonly usesFunction: import("@astrale-os/sdk/schema").Policy;
+        readonly isSelf: import("@astrale-os/sdk/schema").Policy;
+    };
+    readonly views: {
+        readonly application: import("@astrale-os/sdk/schema").View;
+    };
+    readonly core: {
+        readonly nodes: {
+            readonly admin: import("@astrale-os/sdk/schema").CoreNode;
+            readonly applications: import("@astrale-os/sdk/schema").CoreNode;
+            readonly member: import("@astrale-os/sdk/schema").CoreNode;
+            readonly views: import("@astrale-os/sdk/schema").CoreNode;
+            readonly 'view-only': import("@astrale-os/sdk/schema").CoreNode;
+        };
+    };
+}, {
+    readonly kernel: "kernel.astrale.ai";
+}]>, "assignViews", Readonly<Record<never, never>>, {
+    readonly INVALID_VIEW_ASSIGNMENT_REFERENCE: {
+        readonly family: 'VALIDATION_ERROR';
+        readonly message: 'Identities and Views must be exact canonical @NodeId paths.';
+        readonly details: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+    };
+    readonly CONTRADICTORY_VIEW_ASSIGNMENT: {
+        readonly family: 'VALIDATION_ERROR';
+        readonly message: 'One View is both given to and withdrawn from the same identity.';
+        readonly details: import("zod").ZodObject<{
+            identity: import("zod").ZodString;
+            view: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+    };
+    readonly VIEW_ASSIGNMENT_ENDPOINT_NOT_FOUND: {
+        readonly family: 'NOT_FOUND';
+        readonly message: 'An identity is not a User or a Group, or a View to give is not a View.';
+        readonly details: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+    };
+    readonly VIEW_ACCESS_CONFLICT: {
+        readonly family: 'CONFLICT';
+        readonly message: 'The Views of these identities changed concurrently; retry the operation.';
+        readonly details: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+    };
+    readonly VIEW_ACCESS_UNCONFIRMED: {
+        readonly family: 'CONFLICT';
+        readonly message: 'The Views asked for could not be confirmed; retry the operation.';
+        readonly details: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+    };
+}>, import("@astrale-os/sdk/action").ActionDefinition<import("@astrale-os/sdk/schema").AuthoredSchema<"shell.astrale.ai", readonly ["kernel.astrale.ai", import("@astrale-os/sdk/schema").KernelSchema] | readonly ["shell.astrale.ai", {
+    readonly name: 'Shell';
+    readonly entrypoint: 'application';
+    readonly classes: {
+        readonly User: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly inheritance: "open";
+            readonly policies: {
+                readonly read: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Identity">];
+            readonly properties: {
+                readonly creationKey: import("zod").ZodOptional<import("zod").ZodString>;
+                readonly claimedEmail: import("zod").ZodOptional<import("zod").ZodString>;
+                readonly claimedName: import("zod").ZodOptional<import("zod").ZodString>;
+            };
+            readonly methods: {
+                readonly invite: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    user: string;
+                    email: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        invitationId: string;
+                        user: string;
+                        state: "accepted" | "cancelled" | "completed" | "expired" | "failed" | "pending" | "registered" | "registering";
+                    };
+                }, "authorized", true, false, undefined, undefined>>;
+                readonly recordProfile: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    email?: string | undefined;
+                    displayName?: string | undefined;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+            };
+        }>;
+        readonly Group: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly inheritance: "open";
+            readonly policies: {
+                readonly read: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Identity">, import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">];
+            readonly methods: {
+                readonly assignMember: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    member: string;
+                    group: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", true, false, undefined, undefined>>;
+                readonly unassignMember: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    member: string;
+                    group: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", true, false, undefined, undefined>>;
+            };
+        }>;
+        readonly member_of_group: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "member";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "group";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+        readonly Namespace: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly policies: {
+                readonly read: true;
+                readonly traverse: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">];
+            readonly methods: {
+                readonly link: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                    target: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+                readonly unlink: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+                readonly rename: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                    to: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+            };
+        }>;
+        readonly alias: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "namespace";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "node";
+                readonly accepts: readonly (import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+                    readonly origin: "kernel.astrale.ai";
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+        readonly view_access: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "holder";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "view";
+                readonly accepts: readonly (import("@astrale-os/sdk/schema").ClassRef<"View"> & {
+                    readonly origin: "kernel.astrale.ai";
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+    };
+    readonly functions: {
+        readonly listEntrypoints: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+            readonly mode: 'value';
+            readonly value: {
+                entrypoints: {
+                    origin: string;
+                    name: string;
+                    view: string;
+                }[];
+            };
+        }, "authorized", false, false, undefined, undefined>>;
+        readonly assignViews: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<{
+            assignments: {
+                identity: string;
+                set?: string[] | undefined;
+                unset?: string[] | undefined;
+            }[];
+        }, {
+            readonly mode: 'value';
+            readonly value: Record<string, never>;
+        }, "authorized", false, false, undefined, undefined>>;
+    };
+    readonly policies: {
+        readonly belongsToGroup: import("@astrale-os/sdk/schema").Policy;
+        readonly ownsClass: import("@astrale-os/sdk/schema").Policy;
+        readonly administersShellClass: import("@astrale-os/sdk/schema").Policy;
+        readonly usesFunction: import("@astrale-os/sdk/schema").Policy;
+        readonly isSelf: import("@astrale-os/sdk/schema").Policy;
+    };
+    readonly views: {
+        readonly application: import("@astrale-os/sdk/schema").View;
+    };
+    readonly core: {
+        readonly nodes: {
+            readonly admin: import("@astrale-os/sdk/schema").CoreNode;
+            readonly applications: import("@astrale-os/sdk/schema").CoreNode;
+            readonly member: import("@astrale-os/sdk/schema").CoreNode;
+            readonly views: import("@astrale-os/sdk/schema").CoreNode;
+            readonly 'view-only': import("@astrale-os/sdk/schema").CoreNode;
+        };
+    };
+}, {
+    readonly kernel: "kernel.astrale.ai";
+}]>, "User.recordProfile", Readonly<Record<never, never>>, Readonly<Record<never, never>>>];
+export type ShellRuntime = Runtime<ShellSchema, typeof integrations, typeof initialize, typeof functions>;
+declare const runtime: ShellRuntime;
 export default runtime;