@astrale-domains/shell 0.1.0-beta.10

package/dist/schema/domain/index.js

@@ -0,0 +1,39 @@
+import { defineSchema, KernelSchema, schema, } from '@astrale-os/sdk/schema';
+import { Group, adminGroup, groupAssignUser, groupCore, groupUnassignUser, groupView, maySetupUsers, memberGroup, member_of_group, } from '#schema/group';
+import { homeView } from '#schema/home';
+import { setupAdmin, setupMember } from '#schema/setup';
+import { Space, administers_space, belongsToSpace, default_space, defaultSpace, mayAdministerSpace, member_of_space, owns_space, ownsSpace, spaceAddUser, spaceCore, spaceRemoveUser, spaceSetDefault, spaceView, } from '#schema/space';
+import { User, resolveHome, userView } from '#schema/user';
+export const ORIGIN = 'shell.astrale.ai';
+export const ShellCore = {
+    nodes: {
+        admin: adminGroup,
+        member: memberGroup,
+        'default-space': defaultSpace,
+    },
+    edges: [...(groupCore.edges ?? []), ...(spaceCore.edges ?? [])],
+};
+const dependencies = { kernel: KernelSchema };
+const functions = { setupAdmin, setupMember };
+const classes = {
+    Group,
+    Space,
+    User,
+    administers_space,
+    default_space,
+    member_of_group,
+    member_of_space,
+    owns_space,
+};
+const policies = { belongsToSpace, mayAdministerSpace, maySetupUsers, ownsSpace };
+const views = { group: groupView, home: homeView, space: spaceView, user: userView };
+export const ShellSchema = defineSchema(ORIGIN, {
+    dependencies,
+    functions,
+    classes,
+    policies,
+    views,
+    core: ShellCore,
+});
+export const S = schema.resolve(ShellSchema);
+export { groupAssignUser, groupUnassignUser, resolveHome, setupAdmin, setupMember, spaceAddUser, spaceRemoveUser, spaceSetDefault, };

package/dist/schema/group/class.d.ts

@@ -0,0 +1,323 @@
+export declare const Group: import("@astrale-os/sdk/schema").NodeClass<{
+    readonly depth: 1;
+    readonly abstract: false;
+    readonly extends: readonly [import("@astrale-os/sdk/schema").ClassProjection<"node", import("@astrale-os/sdk/schema").NodeClassDefinition & {
+        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
+            readonly origin: "kernel.astrale.ai";
+        };
+        readonly kind: 'node';
+        readonly abstract: true;
+    }, import("@astrale-os/sdk/schema").ClassRef & import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
+        readonly origin: "kernel.astrale.ai";
+    }, "kernel.astrale.ai:class.Identity", readonly [import("@astrale-os/sdk/schema").ClassProjection<"node", import("@astrale-os/sdk/schema").NodeClassDefinition & {
+        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+            readonly origin: "kernel.astrale.ai";
+        };
+        readonly kind: 'node';
+        readonly abstract: true;
+    }, import("@astrale-os/sdk/schema").ClassRef & import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+        readonly origin: "kernel.astrale.ai";
+    }, "kernel.astrale.ai:class.Node", readonly import("@astrale-os/sdk/schema").AnyResolvedClass[], never, never, never, never, never, never>, ...never[]], import("@astrale-os/sdk/schema").PropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", "kernel.astrale.ai:class.Identity.property.requiredClaims"> | import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, false, "frozen", "kernel.astrale.ai:class.Identity.property.frozen"> | import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, true, "iss", "kernel.astrale.ai:class.Identity.property.iss"> | import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, true, "sub", "kernel.astrale.ai:class.Identity.property.sub">, import("@astrale-os/sdk/schema").MethodProjection<{
+        audience: string;
+        ttlSeconds: number;
+        attenuation: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, false, "default", "authenticated", "delegate", "kernel.astrale.ai:class.Identity.method.delegate">, import("@astrale-os/sdk/schema").MethodProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            issuer: string;
+            subject: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, true, "default", "authenticated", "whoami", "kernel.astrale.ai:class.Identity.method.whoami"> | import("@astrale-os/sdk/schema").MethodProjection<{
+        policy: string;
+        object: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            allowed: boolean;
+        };
+    }, true, "default", "authenticated", "can", "kernel.astrale.ai:class.Identity.method.can"> | import("@astrale-os/sdk/schema").MethodProjection<{
+        issuer: string;
+        subject: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            issuer: string;
+            subject: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        } | null;
+    }, true, "default", "authorized", "whois", "kernel.astrale.ai:class.Identity.method.whois"> | import("@astrale-os/sdk/schema").MethodProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, true, "default", "authorized", "mint", "kernel.astrale.ai:class.Identity.method.mint">, import("@astrale-os/sdk/schema").PropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", "kernel.astrale.ai:class.Identity.property.requiredClaims"> | import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, false, "frozen", "kernel.astrale.ai:class.Identity.property.frozen"> | import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, true, "iss", "kernel.astrale.ai:class.Identity.property.iss"> | import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, true, "sub", "kernel.astrale.ai:class.Identity.property.sub">, import("@astrale-os/sdk/schema").MethodProjection<{
+        audience: string;
+        ttlSeconds: number;
+        attenuation: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, false, "default", "authenticated", "delegate", "kernel.astrale.ai:class.Identity.method.delegate">, import("@astrale-os/sdk/schema").MethodProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            issuer: string;
+            subject: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, true, "default", "authenticated", "whoami", "kernel.astrale.ai:class.Identity.method.whoami"> | import("@astrale-os/sdk/schema").MethodProjection<{
+        policy: string;
+        object: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            allowed: boolean;
+        };
+    }, true, "default", "authenticated", "can", "kernel.astrale.ai:class.Identity.method.can"> | import("@astrale-os/sdk/schema").MethodProjection<{
+        issuer: string;
+        subject: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            issuer: string;
+            subject: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        } | null;
+    }, true, "default", "authorized", "whois", "kernel.astrale.ai:class.Identity.method.whois"> | import("@astrale-os/sdk/schema").MethodProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, true, "default", "authorized", "mint", "kernel.astrale.ai:class.Identity.method.mint">>, import("@astrale-os/sdk/schema").ClassProjection<"node", import("@astrale-os/sdk/schema").NodeClassDefinition & {
+        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Named"> & {
+            readonly origin: "kernel.astrale.ai";
+        };
+        readonly kind: 'node';
+        readonly abstract: true;
+    }, import("@astrale-os/sdk/schema").ClassRef & import("@astrale-os/sdk/schema").ClassRef<"Named"> & {
+        readonly origin: "kernel.astrale.ai";
+    }, "kernel.astrale.ai:class.Named", readonly [import("@astrale-os/sdk/schema").ClassProjection<"node", import("@astrale-os/sdk/schema").NodeClassDefinition & {
+        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+            readonly origin: "kernel.astrale.ai";
+        };
+        readonly kind: 'node';
+        readonly abstract: true;
+    }, import("@astrale-os/sdk/schema").ClassRef & import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+        readonly origin: "kernel.astrale.ai";
+    }, "kernel.astrale.ai:class.Node", readonly import("@astrale-os/sdk/schema").AnyResolvedClass[], never, never, never, never, never, never>, ...never[]], import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, true, "name", "kernel.astrale.ai:class.Named.property.name">, never, never, import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, true, "name", "kernel.astrale.ai:class.Named.property.name">, never, never>, import("@astrale-os/sdk/schema").ClassProjection<"node", import("@astrale-os/sdk/schema").NodeClassDefinition & {
+        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Descriptable"> & {
+            readonly origin: "kernel.astrale.ai";
+        };
+        readonly kind: 'node';
+        readonly abstract: true;
+    }, import("@astrale-os/sdk/schema").ClassRef & import("@astrale-os/sdk/schema").ClassRef<"Descriptable"> & {
+        readonly origin: "kernel.astrale.ai";
+    }, "kernel.astrale.ai:class.Descriptable", readonly [import("@astrale-os/sdk/schema").ClassProjection<"node", import("@astrale-os/sdk/schema").NodeClassDefinition & {
+        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+            readonly origin: "kernel.astrale.ai";
+        };
+        readonly kind: 'node';
+        readonly abstract: true;
+    }, import("@astrale-os/sdk/schema").ClassRef & import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+        readonly origin: "kernel.astrale.ai";
+    }, "kernel.astrale.ai:class.Node", readonly import("@astrale-os/sdk/schema").AnyResolvedClass[], never, never, never, never, never, never>, ...never[]], import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, false, "description", "kernel.astrale.ai:class.Descriptable.property.description">, never, never, import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, false, "description", "kernel.astrale.ai:class.Descriptable.property.description">, never, never>];
+    readonly properties: never;
+    readonly methods: {
+        readonly assignUser: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            user: string;
+        }, {
+            readonly mode: 'value';
+            readonly value: import("@astrale-os/sdk/schema").Value;
+        }, "authorized", false, "default">>;
+        readonly unassignUser: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            user: string;
+        }, {
+            readonly mode: 'value';
+            readonly value: import("@astrale-os/sdk/schema").Value;
+        }, "authorized", false, "default">>;
+    };
+    readonly effectiveProperties: (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+        readonly name: "description";
+        readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
+    }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+        readonly name: "frozen";
+        readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+    }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+        readonly name: "iss";
+        readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+    }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+        readonly name: "name";
+        readonly key: "kernel.astrale.ai:class.Named.property.name";
+    }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+        readonly name: "sub";
+        readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+    });
+    readonly effectiveInstanceMethods: (import("@astrale-os/sdk/schema").AuthoredMethodProjection<import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+        user: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: import("@astrale-os/sdk/schema").Value;
+    }, "authorized", false, "default">>, "assignUser", "self"> | import("@astrale-os/sdk/schema").AuthoredMethodProjection<import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+        user: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: import("@astrale-os/sdk/schema").Value;
+    }, "authorized", false, "default">>, "unassignUser", "self">) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
+        audience: string;
+        ttlSeconds: number;
+        attenuation: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, false, "default", "authenticated", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+        readonly name: "delegate";
+    });
+    readonly effectiveStaticMethods: (import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            issuer: string;
+            subject: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, true, "default", "authenticated", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+        readonly name: "whoami";
+    }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
+        policy: string;
+        object: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            allowed: boolean;
+        };
+    }, true, "default", "authenticated", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.can"> & {
+        readonly name: "can";
+    }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
+        issuer: string;
+        subject: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            issuer: string;
+            subject: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        } | null;
+    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+        readonly name: "whois";
+    }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+        readonly name: "mint";
+    });
+}>;

package/dist/schema/group/class.js

@@ -0,0 +1,7 @@
+import { K, nodeClass } from '@astrale-os/sdk/schema';
+import { groupAssignUser, groupUnassignUser } from './methods.js';
+export const Group = nodeClass({
+    description: 'A named compositional Shell Identity.',
+    extends: [K.classes.Identity, K.classes.Named, K.classes.Descriptable],
+    methods: { assignUser: groupAssignUser, unassignUser: groupUnassignUser },
+});

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

@@ -0,0 +1,10 @@
+import { type builder } from '@astrale-os/sdk/schema';
+export declare const adminGroup: builder.CoreNode;
+export declare const memberGroup: builder.CoreNode;
+export declare const groupCore: {
+    nodes: {
+        admin: builder.CoreNode;
+        member: builder.CoreNode;
+    };
+    edges: never[];
+};

package/dist/schema/group/core.js

@@ -0,0 +1,14 @@
+import { K, core } from '@astrale-os/sdk/schema';
+import { Group } from './class.js';
+const identity = (subject, name, description) => core.node(() => Group, {
+    [K.classes.Identity.self.properties.iss.key]: 'shell.astrale.ai',
+    [K.classes.Identity.self.properties.sub.key]: subject,
+    [K.classes.Named.self.properties.name.key]: name,
+    [K.classes.Descriptable.self.properties.description.key]: description,
+});
+export const adminGroup = identity('core.admin', 'Administrators', 'Users entrusted with Shell application-plane administration.');
+export const memberGroup = identity('core.member', 'Members', 'Users admitted to the common Shell application plane.');
+export const groupCore = {
+    nodes: { admin: adminGroup, member: memberGroup },
+    edges: [],
+};

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

@@ -0,0 +1,6 @@
+export { Group } from './class.js';
+export { adminGroup, groupCore, memberGroup } from './core.js';
+export { groupAssignUser, groupUnassignUser } from './methods.js';
+export { maySetupUsers } from './policies.js';
+export { member_of_group } from './relationships.js';
+export { groupView } from './view.js';

package/dist/schema/group/index.js

@@ -0,0 +1,6 @@
+export { Group } from './class.js';
+export { adminGroup, groupCore, memberGroup } from './core.js';
+export { groupAssignUser, groupUnassignUser } from './methods.js';
+export { maySetupUsers } from './policies.js';
+export { member_of_group } from './relationships.js';
+export { groupView } from './view.js';

package/dist/schema/group/methods.d.ts

@@ -0,0 +1,13 @@
+import { type builder } from '@astrale-os/sdk/schema';
+export declare const groupAssignUser: builder.Method<builder.CallableProjection<{
+    user: string;
+}, {
+    readonly mode: 'value';
+    readonly value: import("@astrale-os/sdk/schema").Value;
+}, "authorized", false, "default">>;
+export declare const groupUnassignUser: builder.Method<builder.CallableProjection<{
+    user: string;
+}, {
+    readonly mode: 'value';
+    readonly value: import("@astrale-os/sdk/schema").Value;
+}, "authorized", false, "default">>;

package/dist/schema/group/methods.js

@@ -0,0 +1,22 @@
+import { method, path } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { User } from '#schema/user';
+import { adminGroup } from './core.js';
+import { maySetupUsers } from './policies.js';
+const emptyObject = {
+    type: 'object',
+    properties: {},
+    additionalProperties: false,
+};
+const setupPolicy = ({ check, ref }) => check(maySetupUsers, ref(adminGroup));
+function membershipMethod(description) {
+    return method({
+        description,
+        input: z.strictObject({ user: path(User) }),
+        output: emptyObject,
+        auth: 'authorized',
+        policy: setupPolicy,
+    });
+}
+export const groupAssignUser = membershipMethod('Assign one User to this Group.');
+export const groupUnassignUser = membershipMethod('Remove one User from this Group.');

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

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

package/dist/schema/group/policies.js

@@ -0,0 +1,6 @@
+import { policy } from '@astrale-os/sdk/schema';
+import { member_of_group } from './relationships.js';
+export const maySetupUsers = policy({
+    description: 'The effective User Grant belongs to the selected Administrators Group.',
+    match: ({ edge, object, subject }) => edge({ source: subject, class: member_of_group, target: object }),
+});

package/dist/schema/group/relationships.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: "user";
+        readonly outgoing: "0..*";
+    };
+    readonly target: {
+        readonly as: "group";
+        readonly incoming: "0..*";
+    };
+    readonly constraints: Record<never, never>;
+    readonly effectiveProperties: never;
+}>;

package/dist/schema/group/relationships.js

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

package/dist/schema/group/view.d.ts

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

package/dist/schema/group/view.js

@@ -0,0 +1,6 @@
+import { view } from '@astrale-os/sdk/schema';
+import { Group } from './class.js';
+export const groupView = view({
+    description: 'Shell Group membership and administration.',
+    target: Group,
+});

package/dist/schema/home/index.d.ts

@@ -0,0 +1 @@
+export { homeView } from './view.js';

package/dist/schema/home/index.js

@@ -0,0 +1 @@
+export { homeView } from './view.js';

package/dist/schema/home/view.d.ts

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

package/dist/schema/home/view.js

@@ -0,0 +1,4 @@
+import { view } from '@astrale-os/sdk/schema';
+export const homeView = view({
+    description: 'Shell home and browser-local Space navigation.',
+});

package/dist/schema/index.d.ts

@@ -0,0 +1,6 @@
+export { ORIGIN, S, ShellCore, ShellSchema, type GroupMembershipInput, type GroupMembershipResult, type ResolveHomeResult, type SetDefaultSpaceInput, type SetDefaultSpaceResult, type SetupUserInput, type SetupUserResult, type Shell, type SpaceUserAccess, type SpaceUserAccessInput, type SpaceUserAccessResult, type SpaceUserInput, type SpaceUserResult, } from '#schema/domain';
+export { Group, adminGroup, groupAssignUser, groupCore, groupUnassignUser, groupView, maySetupUsers, memberGroup, member_of_group, } from '#schema/group';
+export { homeView } from '#schema/home';
+export { setupAdmin, setupMember } from '#schema/setup';
+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, resolveHome, userView } from '#schema/user';

package/dist/schema/index.js

@@ -0,0 +1,6 @@
+export { ORIGIN, S, ShellCore, ShellSchema, } from '#schema/domain';
+export { Group, adminGroup, groupAssignUser, groupCore, groupUnassignUser, groupView, maySetupUsers, memberGroup, member_of_group, } from '#schema/group';
+export { homeView } from '#schema/home';
+export { setupAdmin, setupMember } from '#schema/setup';
+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, resolveHome, userView } from '#schema/user';

package/dist/schema/setup/functions.d.ts

@@ -0,0 +1,28 @@
+export declare const setupMember: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<{
+    operationId: string;
+    issuer: string;
+    subject: string;
+    displayName: string;
+    personalSpaceName: string;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        userId: string;
+        personalSpaceId: string;
+        changed: boolean;
+    };
+}, "authorized", false, "default">>;
+export declare const setupAdmin: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<{
+    operationId: string;
+    issuer: string;
+    subject: string;
+    displayName: string;
+    personalSpaceName: string;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        userId: string;
+        personalSpaceId: string;
+        changed: boolean;
+    };
+}, "authorized", false, "default">>;

package/dist/schema/setup/functions.js

@@ -0,0 +1,27 @@
+import { func, fullMatch } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { adminGroup, maySetupUsers } from '#schema/group';
+const operationId = z.string().min(1).max(256).check(fullMatch('[A-Za-z0-9][A-Za-z0-9._:-]{0,255}'));
+const input = z.strictObject({
+    operationId,
+    issuer: z.string().min(1).max(2_048),
+    subject: z.string().min(1).max(2_048),
+    displayName: z.string().min(1).max(160),
+    personalSpaceName: z.string().min(1).max(160),
+});
+const output = z.strictObject({
+    userId: z.string().min(1),
+    personalSpaceId: z.string().min(1),
+    changed: z.boolean(),
+});
+function setup(description) {
+    return func({
+        description,
+        auth: 'authorized',
+        input,
+        output,
+        policy: ({ check, ref }) => check(maySetupUsers, ref(adminGroup)),
+    });
+}
+export const setupMember = setup('Converge one asserted external identity as a Shell member.');
+export const setupAdmin = setup('Converge one asserted external identity as a Shell administrator.');

package/dist/schema/setup/index.d.ts

@@ -0,0 +1 @@
+export { setupAdmin, setupMember } from './functions.js';

package/dist/schema/setup/index.js

@@ -0,0 +1 @@
+export { setupAdmin, setupMember } from './functions.js';