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

package/dist/schema/modules/group/classes/member-of-group.js

@@ -0,0 +1,11 @@
+import { edgeClass } from '@astrale-os/sdk/schema';
+import { User } from '../../user/index.js';
+import { Group } from './group.js';
+export const member_of_group = edgeClass.directed({
+    source: {
+        as: 'member',
+        accepts: [() => User, () => Group],
+        outgoing: '0..*',
+    },
+    target: { as: 'group', accepts: [() => Group], incoming: '0..*' },
+});

package/dist/schema/modules/group/core/administrators-group.d.ts

@@ -0,0 +1 @@
+export declare const adminGroup: import("@astrale-os/sdk/schema").CoreNode;

package/dist/schema/modules/group/core/administrators-group.js

@@ -0,0 +1,6 @@
+import { K, core } from '@astrale-os/sdk/schema';
+import { Group } from '../classes/group.js';
+export const adminGroup = core.node(() => Group, {
+    [K.classes.Named.properties.name.key]: 'Administrators',
+    [K.classes.Descriptable.properties.description.key]: 'Instance administrators.',
+});

package/dist/schema/modules/group/core/applications-group.d.ts

@@ -0,0 +1 @@
+export declare const applicationsGroup: import("@astrale-os/sdk/schema").CoreNode;

package/dist/schema/modules/group/core/applications-group.js

@@ -0,0 +1,6 @@
+import { K, core } from '@astrale-os/sdk/schema';
+import { Group } from '../classes/group.js';
+export const applicationsGroup = core.node(() => Group, {
+    [K.classes.Named.properties.name.key]: 'Applications',
+    [K.classes.Descriptable.properties.description.key]: 'May list the installed applications they can open.',
+});

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

@@ -0,0 +1,3 @@
+export { adminGroup } from './administrators-group.js';
+export { applicationsGroup } from './applications-group.js';
+export { memberGroup } from './members-group.js';

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

@@ -0,0 +1,3 @@
+export { adminGroup } from './administrators-group.js';
+export { applicationsGroup } from './applications-group.js';
+export { memberGroup } from './members-group.js';

package/dist/schema/modules/group/core/members-group.d.ts

@@ -0,0 +1 @@
+export declare const memberGroup: import("@astrale-os/sdk/schema").CoreNode;

package/dist/schema/modules/group/core/members-group.js

@@ -0,0 +1,6 @@
+import { K, core } from '@astrale-os/sdk/schema';
+import { Group } from '../classes/group.js';
+export const memberGroup = core.node(() => Group, {
+    [K.classes.Named.properties.name.key]: 'Members',
+    [K.classes.Descriptable.properties.description.key]: 'Instance members.',
+});

package/dist/schema/modules/group/functions/assign-member-to-group.js

@@ -0,0 +1,11 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { ownsClass, administersShellClass } from '../../../policies/index.js';
+import { groupMembershipInput } from '../types/index.js';
+export const assignMember = method({
+    static: true,
+    auth: 'authorized',
+    input: groupMembershipInput,
+    output: z.object({}),
+    policy: ({ anyOf, check, input }) => anyOf(check(administersShellClass, input.group), check(ownsClass, input.group)),
+});

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

@@ -0,0 +1,2 @@
+export { assignMember } from './assign-member-to-group.js';
+export { unassignMember } from './unassign-member-from-group.js';

package/dist/schema/modules/group/functions/unassign-member-from-group.js

@@ -0,0 +1,11 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { ownsClass, administersShellClass } from '../../../policies/index.js';
+import { groupMembershipInput } from '../types/index.js';
+export const unassignMember = method({
+    static: true,
+    auth: 'authorized',
+    input: groupMembershipInput,
+    output: z.object({}),
+    policy: ({ anyOf, check, input }) => anyOf(check(administersShellClass, input.group), check(ownsClass, input.group)),
+});

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

@@ -0,0 +1,3 @@
+export { Group, member_of_group } from './classes/index.js';
+export { adminGroup, applicationsGroup, memberGroup } from './core/index.js';
+export { belongsToGroup } from './policies/index.js';

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

@@ -0,0 +1,3 @@
+export { Group, member_of_group } from './classes/index.js';
+export { adminGroup, applicationsGroup, memberGroup } from './core/index.js';
+export { belongsToGroup } from './policies/index.js';

package/dist/schema/modules/group/policies/belongs-to-group.d.ts

@@ -0,0 +1 @@
+export declare const belongsToGroup: import("@astrale-os/sdk/schema").Policy;

package/dist/schema/modules/group/policies/belongs-to-group.js

@@ -0,0 +1,5 @@
+import { policy } from '@astrale-os/sdk/schema';
+import { member_of_group } from '../classes/member-of-group.js';
+export const belongsToGroup = policy({
+    match: ({ edge, subject, object }) => edge({ source: subject, class: () => member_of_group, target: object }),
+});

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

@@ -0,0 +1 @@
+export { belongsToGroup } from './belongs-to-group.js';

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

@@ -0,0 +1 @@
+export { belongsToGroup } from './belongs-to-group.js';

package/dist/schema/modules/group/types/group-membership-input.js

@@ -0,0 +1,8 @@
+import { path } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { User } from '../../user/index.js';
+import { Group } from '../classes/group.js';
+export const groupMembershipInput = z.object({
+    member: path(() => User, () => Group),
+    group: path(() => Group),
+});

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

@@ -0,0 +1 @@
+export { groupMembershipInput } from './group-membership-input.js';

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

@@ -0,0 +1 @@
+export { User } from './user.js';

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

@@ -0,0 +1 @@
+export { User } from './user.js';

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

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+export declare const 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: z.ZodOptional<z.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>>;
+    };
+}>;

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

@@ -0,0 +1,12 @@
+import { K, classIcon, nodeClass } from '@astrale-os/sdk/schema';
+import { UserRound } from '@astrale-os/sdk/schema/icons';
+import { z } from 'zod';
+import { invite } from '../functions/index.js';
+// Correlation for Admin-owned creation; never an authentication credential.
+const creationKey = z.string().min(1).max(512).optional();
+export const User = nodeClass({
+    icon: classIcon.lucide(UserRound),
+    extends: [K.classes.Identity],
+    properties: { creationKey },
+    methods: { invite },
+});

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

@@ -0,0 +1 @@
+export { invite } from './invite-user.js';

package/dist/schema/modules/user/functions/invite-user.js

@@ -0,0 +1,12 @@
+import { method, path } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { ownsClass, administersShellClass } from '../../../policies/index.js';
+import { User } from '../classes/index.js';
+import { invitationSummary } from '../types/index.js';
+export const invite = method({
+    static: true,
+    auth: 'authorized',
+    input: z.object({ user: path(() => User), email: z.string().min(3).max(320) }),
+    output: invitationSummary,
+    policy: ({ anyOf, check, input }) => anyOf(check(administersShellClass, input.user), check(ownsClass, input.user)),
+});

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

@@ -0,0 +1,2 @@
+export { User } from './classes/index.js';
+export { invitationSummary, type InvitationSummary } from './types/index.js';

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

@@ -0,0 +1,2 @@
+export { User } from './classes/index.js';
+export { invitationSummary } from './types/index.js';

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

@@ -0,0 +1 @@
+export { invitationSummary, type InvitationSummary } from './invitation-summary.js';

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

@@ -0,0 +1 @@
+export { invitationSummary } from './invitation-summary.js';

package/dist/schema/modules/user/types/invitation-summary.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export declare const invitationSummary: z.ZodObject<{
+    invitationId: z.ZodString;
+    user: z.ZodString;
+    state: z.ZodEnum<{
+        accepted: "accepted";
+        cancelled: "cancelled";
+        completed: "completed";
+        expired: "expired";
+        failed: "failed";
+        pending: "pending";
+        registered: "registered";
+        registering: "registering";
+    }>;
+}, z.core.$strip>;
+export type InvitationSummary = z.infer<typeof invitationSummary>;

package/dist/schema/modules/user/types/invitation-summary.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export const invitationSummary = z.object({
+    invitationId: z.string().min(1),
+    user: z.string().min(1),
+    state: z.enum([
+        'pending',
+        'accepted',
+        'registering',
+        'registered',
+        'completed',
+        'cancelled',
+        'expired',
+        'failed',
+    ]),
+});

package/dist/schema/policies/administers-shell-class.js

@@ -0,0 +1,11 @@
+import { K, policy } from '@astrale-os/sdk/schema';
+import { Group, member_of_group, adminGroup } from '../modules/group/index.js';
+/** Instance administration applies to Shell's concrete classes, not foreign descendants. */
+export const administersShellClass = policy({
+    match: ({ exists, subject, object, ref, edge, allOf }) => exists(({ node }) => {
+        const concrete = node();
+        const owner = node(); // of_domain restricts this witness to a protected Domain endpoint.
+        const group = ref(() => Group);
+        return allOf(edge({ source: subject, class: () => member_of_group, target: ref(adminGroup) }), { source: ref(adminGroup), class: K.classes.instance_of.ref, target: group }, { source: group, class: K.classes.of_domain.ref, target: owner }, { source: concrete, class: K.classes.of_domain.ref, target: owner }, { source: object, class: K.classes.instance_of.ref, target: concrete });
+    }),
+});

package/dist/schema/policies/index.js

@@ -0,0 +1,3 @@
+export { ownsClass } from './owns-class.js';
+export { administersShellClass } from './administers-shell-class.js';
+export { usesFunction } from './uses-function.js';

package/dist/schema/policies/owns-class.js

@@ -0,0 +1,7 @@
+import { K, policy } from '@astrale-os/sdk/schema';
+export const ownsClass = policy({
+    match: ({ exists, subject, object, allOf }) => exists(({ node }) => {
+        const concrete = node(); // Périmètre défini par les deux edges kernel protégés.
+        return allOf({ source: object, class: K.classes.instance_of.ref, target: concrete }, { source: concrete, class: K.classes.of_domain.ref, target: subject });
+    }),
+});

package/dist/schema/policies/uses-function.js

@@ -0,0 +1,5 @@
+import { K, policy } from '@astrale-os/sdk/schema';
+/** The subject may use the object Function: its own or a composed Identity holds can_use on it. */
+export const usesFunction = policy({
+    match: ({ edge, subject, object }) => edge({ source: subject, class: () => K.classes.can_use, target: object }),
+});

package/dist/schema/schema.d.ts

@@ -0,0 +1,342 @@
+import { KernelSchema, schema } from '@astrale-os/sdk/schema';
+export declare const ORIGIN: 'shell.astrale.ai';
+declare const 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;
+    }>;
+};
+export type ShellClasses = typeof classes;
+declare const input: {
+    readonly name: 'Shell';
+    readonly entrypoint: 'application';
+    readonly dependencies: {
+        readonly kernel: KernelSchema;
+    };
+    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;
+        };
+    };
+};
+export type ShellSchemaInput = typeof input;
+export declare const ShellSchema: import("@astrale-os/sdk/schema").AuthoredSchema<"shell.astrale.ai", readonly ["kernel.astrale.ai", 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";
+}]>;
+export type ShellSchema = typeof ShellSchema;
+export declare const S: schema.ResolvedDomainOf<import("@astrale-os/sdk/schema").AuthoredSchema<"shell.astrale.ai", readonly ["kernel.astrale.ai", 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";
+}]>>;
+export type Shell = schema.DomainOf<ShellSchema>;
+export {};

package/dist/schema/schema.js

@@ -0,0 +1,27 @@
+import { defineSchema, KernelSchema, schema } from '@astrale-os/sdk/schema';
+import { listEntrypoints } from './modules/application/index.js';
+import { Group, member_of_group, adminGroup, applicationsGroup, memberGroup, belongsToGroup, } from './modules/group/index.js';
+import { User } from './modules/user/index.js';
+import { ownsClass, administersShellClass, usesFunction } from './policies/index.js';
+import { applicationView } from './views/index.js';
+export const ORIGIN = 'shell.astrale.ai';
+const dependencies = { kernel: KernelSchema };
+const classes = { User, Group, member_of_group };
+const functions = { listEntrypoints };
+const policies = { belongsToGroup, ownsClass, administersShellClass, usesFunction };
+const views = { application: applicationView };
+const core = {
+    nodes: { admin: adminGroup, applications: applicationsGroup, member: memberGroup },
+};
+const input = {
+    name: 'Shell',
+    entrypoint: 'application',
+    dependencies,
+    classes,
+    functions,
+    policies,
+    views,
+    core,
+};
+export const ShellSchema = defineSchema(ORIGIN, input);
+export const S = schema.resolve(ShellSchema);