@astrale-domains/shell 0.1.0-beta.4 → 0.1.0-beta.40

package/dist/runtime.d.ts

@@ -0,0 +1,462 @@
+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";
+            }>;
+        }>>;
+    };
+};
+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 extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Identity">];
+            readonly properties: {
+                readonly creationKey: 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>>;
+            };
+        }>;
+        readonly Group: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            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>>;
+                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>>;
+            };
+        }>;
+        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 outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "group";
+                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>>;
+    };
+    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 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 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";
+        }>;
+    }>;
+}, {
+    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 extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Identity">];
+            readonly properties: {
+                readonly creationKey: 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>>;
+            };
+        }>;
+        readonly Group: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            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>>;
+                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>>;
+            };
+        }>;
+        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 outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "group";
+                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>>;
+    };
+    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 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 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 extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Identity">];
+            readonly properties: {
+                readonly creationKey: 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>>;
+            };
+        }>;
+        readonly Group: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            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>>;
+                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>>;
+            };
+        }>;
+        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 outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "group";
+                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>>;
+    };
+    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 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 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 extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Identity">];
+            readonly properties: {
+                readonly creationKey: 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>>;
+            };
+        }>;
+        readonly Group: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            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>>;
+                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>>;
+            };
+        }>;
+        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 outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "group";
+                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>>;
+    };
+    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 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 kernel: "kernel.astrale.ai";
+}]>, "listEntrypoints", 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;

package/dist/runtime.js

@@ -0,0 +1,16 @@
+import { defineRuntime } from '@astrale-os/sdk/runtime';
+import { listEntrypoints } from './functions/application/index.js';
+import { assignMember, unassignMember } from './functions/group/index.js';
+import { invite } from './functions/user/index.js';
+import { integrations } from './integrations/index.js';
+import { enrollmentProvider } from './providers/admin-enrollment/index.js';
+const initialize = (environment) => ({
+    providers: { enrollment: enrollmentProvider(environment) },
+});
+const functions = [invite, assignMember, unassignMember, listEntrypoints];
+const runtime = defineRuntime()({
+    integrations,
+    initialize,
+    functions,
+});
+export default runtime;

package/dist/schema/index.d.ts

@@ -1,7 +1,5 @@
-export { Application, applicationCore, applicationInstall, applicationUninstall, applicationView, application_of, installed_in, mayAdministerApplication, shellApplication, type InstallApplicationInput, type InstallApplicationResult, type UninstallApplicationInput, type UninstallApplicationResult, } from '#schema/application';
-export { ORIGIN, S, ShellCore, ShellSchema, type Shell, type ShellCoreName, type ShellDomainOperations, type ShellEdgeName, type ShellNodeName, type ShellSchemaInput, } from '#schema/domain';
-export { Group, adminGroup, administers_group, groupAssignUser, groupCore, groupUnassignUser, groupView, mayAdministerGroup, memberGroup, member_of_group, type GroupMembershipInput, type GroupMembershipResult, } from '#schema/group';
-export { homeView } from '#schema/home';
-export { Space, administers_space, belongsToSpace, default_space, defaultSpace, mayAdministerSpace, member_of_space, owns_space, ownsSpace, spaceAddUser, spaceCore, spaceRemoveUser, spaceSetDefault, spaceView, type SetDefaultSpaceInput, type SetDefaultSpaceResult, type SpaceUserAccess, type SpaceUserAccessInput, type SpaceUserAccessResult, type SpaceUserInput, type SpaceUserResult, } from '#schema/space';
-export { User, ensureAdministrator, ensureUser, iUser, userView, type EnsureShellAdministratorInput, type EnsureShellAdministratorResult, type EnsureShellUserResult, } from '#schema/user';
-//# sourceMappingURL=index.d.ts.map
+export { ShellSchema, S, type Shell, type ShellClasses, type ShellSchemaInput } from './schema.js';
+export { User } from './modules/user/index.js';
+export type { InvitationSummary } from './modules/user/index.js';
+export { Group, member_of_group, adminGroup, applicationsGroup, memberGroup, } from './modules/group/index.js';
+export { listEntrypoints, type EntrypointEntry } from './modules/application/index.js';

package/dist/schema/index.js

@@ -1,7 +1,4 @@
-export { Application, applicationCore, applicationInstall, applicationUninstall, applicationView, application_of, installed_in, mayAdministerApplication, shellApplication, } from '#schema/application';
-export { ORIGIN, S, ShellCore, ShellSchema, } from '#schema/domain';
-export { Group, adminGroup, administers_group, groupAssignUser, groupCore, groupUnassignUser, groupView, mayAdministerGroup, memberGroup, member_of_group, } from '#schema/group';
-export { homeView } from '#schema/home';
-export { Space, administers_space, belongsToSpace, default_space, defaultSpace, mayAdministerSpace, member_of_space, owns_space, ownsSpace, spaceAddUser, spaceCore, spaceRemoveUser, spaceSetDefault, spaceView, } from '#schema/space';
-export { User, ensureAdministrator, ensureUser, iUser, userView, } from '#schema/user';
-//# sourceMappingURL=index.js.map
+export { ShellSchema, S } from './schema.js';
+export { User } from './modules/user/index.js';
+export { Group, member_of_group, adminGroup, applicationsGroup, memberGroup, } from './modules/group/index.js';
+export { listEntrypoints } from './modules/application/index.js';

package/dist/schema/modules/application/functions/index.d.ts

@@ -0,0 +1 @@
+export { listEntrypoints } from './list-entrypoints.js';

package/dist/schema/modules/application/functions/index.js

@@ -0,0 +1 @@
+export { listEntrypoints } from './list-entrypoints.js';

package/dist/schema/modules/application/functions/list-entrypoints.d.ts

@@ -0,0 +1,15 @@
+import { type Function as SchemaFunction } from '@astrale-os/sdk/schema';
+/**
+ * The entrypoint View of every installed Domain that declares one, with its Domain name. Shell
+ * reads the Kernel `entrypoint` Edges with its own authority; a Domain without one is not listed.
+ */
+export declare const listEntrypoints: SchemaFunction<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>>;

package/dist/schema/modules/application/functions/list-entrypoints.js

@@ -0,0 +1,16 @@
+import { func } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { usesFunction } from '../../../policies/index.js';
+import { entrypointEntry } from '../types/index.js';
+/**
+ * The entrypoint View of every installed Domain that declares one, with its Domain name. Shell
+ * reads the Kernel `entrypoint` Edges with its own authority; a Domain without one is not listed.
+ */
+export const listEntrypoints = func({
+    description: 'List the entrypoint View and name of every installed Domain that declares one.',
+    auth: 'authorized',
+    input: z.strictObject({}),
+    output: z.object({ entrypoints: z.array(entrypointEntry) }),
+    // Holding can_use is enough: membership of the Applications Group shares it dynamically.
+    policy: ({ check, ref }) => check(usesFunction, ref(() => listEntrypoints)),
+});

package/dist/schema/modules/application/index.d.ts

@@ -0,0 +1,2 @@
+export { listEntrypoints } from './functions/index.js';
+export { entrypointEntry, type EntrypointEntry } from './types/index.js';

package/dist/schema/modules/application/index.js

@@ -0,0 +1,2 @@
+export { listEntrypoints } from './functions/index.js';
+export { entrypointEntry } from './types/index.js';

package/dist/schema/modules/application/types/entrypoint-entry.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+/** One installed Domain entrypoint: the Domain origin, its display name, and its View key. */
+export declare const entrypointEntry: z.ZodObject<{
+    origin: z.ZodString;
+    name: z.ZodString;
+    view: z.ZodString;
+}, z.core.$strip>;
+export type EntrypointEntry = z.infer<typeof entrypointEntry>;

package/dist/schema/modules/application/types/entrypoint-entry.js

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+/** One installed Domain entrypoint: the Domain origin, its display name, and its View key. */
+export const entrypointEntry = z.object({
+    origin: z.string().min(1),
+    name: z.string().min(1),
+    view: z.string().min(1),
+});

package/dist/schema/modules/application/types/index.d.ts

@@ -0,0 +1 @@
+export { entrypointEntry, type EntrypointEntry } from './entrypoint-entry.js';

package/dist/schema/modules/application/types/index.js

@@ -0,0 +1 @@
+export { entrypointEntry } from './entrypoint-entry.js';

package/dist/schema/modules/group/classes/group.d.ts

@@ -0,0 +1,20 @@
+export declare const Group: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+    readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+    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>>;
+        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>>;
+    };
+}>;

package/dist/schema/modules/group/classes/group.js

@@ -0,0 +1,8 @@
+import { K, classIcon, nodeClass } from '@astrale-os/sdk/schema';
+import { UsersRound } from '@astrale-os/sdk/schema/icons';
+import { assignMember, unassignMember } from '../functions/index.js';
+export const Group = nodeClass({
+    icon: classIcon.lucide(UsersRound),
+    extends: [K.classes.Identity, K.classes.Named, K.classes.Descriptable],
+    methods: { assignMember, unassignMember },
+});

package/dist/schema/modules/group/classes/index.d.ts

@@ -0,0 +1,2 @@
+export { Group } from './group.js';
+export { member_of_group } from './member-of-group.js';

package/dist/schema/modules/group/classes/index.js

@@ -0,0 +1,2 @@
+export { Group } from './group.js';
+export { member_of_group } from './member-of-group.js';

package/dist/schema/modules/group/classes/member-of-group.d.ts

@@ -0,0 +1,16 @@
+export declare const 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 outgoing: "0..*";
+    };
+    readonly target: {
+        readonly as: "group";
+        readonly incoming: "0..*";
+    };
+    readonly constraints: Record<never, never>;
+    readonly effectiveProperties: never;
+}>;