@astrale-domains/shell 0.1.0-beta.26 → 0.1.0-beta.28

package/dist/application.js

@@ -25,8 +25,8 @@ const applicationRequirements = requirements({
             functions: [
                 ...KernelRootFunctions,
                 S.classes.User.static.methods.invite,
-                S.classes.Group.static.methods.assignUser,
-                S.classes.Group.static.methods.unassignUser,
+                S.classes.Group.static.methods.assignMember,
+                S.classes.Group.static.methods.unassignMember,
             ],
             classes: [
                 { class: S.classes.User, operations: ['create', 'read', 'traverse', 'update', 'delete'] },

package/dist/functions/group/assign-member-to-group.d.ts

@@ -0,0 +1,102 @@
+export declare const assignMember: 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 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>>;
+            };
+        }>;
+        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>>;
+                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>>;
+            };
+        }>;
+        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 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 views: {
+        readonly application: import("@astrale-os/sdk/schema").View;
+    };
+    readonly core: {
+        readonly nodes: {
+            readonly admin: 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>;
+    };
+}>;

package/dist/functions/group/{unassign-user-from-group.js → assign-member-to-group.js}

@@ -1,4 +1,4 @@
 import { defineWorkflow } from '@astrale-os/sdk/workflow';
-import { changeGroupMembership } from './change-user-group-membership.js';
+import { changeGroupMembership } from './change-group-membership.js';
 import { groupMembershipErrors } from './group-membership-errors.js';
-export const unassignUser = defineWorkflow()('Group.unassignUser', { errors: groupMembershipErrors }, (context) => changeGroupMembership(context, false));
+export const assignMember = defineWorkflow()('Group.assignMember', { errors: groupMembershipErrors }, (context) => changeGroupMembership(context, true));

package/dist/functions/group/{change-user-group-membership.d.ts → change-group-membership.d.ts}

@@ -1,7 +1,7 @@
 import type { WorkflowContext } from '@astrale-os/sdk/workflow';
 import type { S, Shell } from '../../schema/index.js';
 import type { groupMembershipErrors } from './group-membership-errors.js';
-type GroupCallable = typeof S.classes.Group.static.methods.assignUser | typeof S.classes.Group.static.methods.unassignUser;
+type GroupCallable = typeof S.classes.Group.static.methods.assignMember | typeof S.classes.Group.static.methods.unassignMember;
 type Context = WorkflowContext<GroupCallable, Shell, Readonly<Record<never, never>>, typeof groupMembershipErrors>;
 export declare function changeGroupMembership(context: Context, present: boolean): Promise<{}>;
 export {};

package/dist/functions/group/{change-user-group-membership.js → change-group-membership.js}

@@ -5,7 +5,7 @@ const matches = (state, present) => state.membership === present && state.author
 export async function changeGroupMembership(context, present) {
     const invalid = () => context.error('INVALID_GROUP_MEMBERSHIP_REFERENCE', {});
     const membership = {
-        user: canonicalNodeId(context.input.user, invalid),
+        member: canonicalNodeId(context.input.member, invalid),
         group: canonicalNodeId(context.input.group, invalid),
     };
     const observe = async () => {

package/dist/functions/group/group-membership-errors.d.ts

@@ -7,7 +7,7 @@ export declare const groupMembershipErrors: {
     };
     readonly INVALID_GROUP_MEMBERSHIP_REFERENCE: {
         readonly family: 'VALIDATION_ERROR';
-        readonly message: 'User and group must be exact canonical @NodeId paths.';
+        readonly message: 'Member and group must be exact canonical @NodeId paths.';
         readonly details: z.ZodObject<{}, z.core.$strict>;
     };
     readonly GROUP_MEMBERSHIP_CONFLICT: {

package/dist/functions/group/group-membership-errors.js

@@ -7,7 +7,7 @@ export const groupMembershipErrors = {
     },
     INVALID_GROUP_MEMBERSHIP_REFERENCE: {
         family: 'VALIDATION_ERROR',
-        message: 'User and group must be exact canonical @NodeId paths.',
+        message: 'Member and group must be exact canonical @NodeId paths.',
         details: z.strictObject({}),
     },
     GROUP_MEMBERSHIP_CONFLICT: {

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

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

package/dist/functions/group/index.js

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

package/dist/functions/group/unassign-member-from-group.d.ts

@@ -0,0 +1,102 @@
+export declare const unassignMember: 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 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>>;
+            };
+        }>;
+        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>>;
+                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>>;
+            };
+        }>;
+        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 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 views: {
+        readonly application: import("@astrale-os/sdk/schema").View;
+    };
+    readonly core: {
+        readonly nodes: {
+            readonly admin: 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>;
+    };
+}>;

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

@@ -0,0 +1,4 @@
+import { defineWorkflow } from '@astrale-os/sdk/workflow';
+import { changeGroupMembership } from './change-group-membership.js';
+import { groupMembershipErrors } from './group-membership-errors.js';
+export const unassignMember = defineWorkflow()('Group.unassignMember', { errors: groupMembershipErrors }, (context) => changeGroupMembership(context, false));