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

package/dist/domain.js

@@ -0,0 +1,96 @@
+import { defineDomain, defineFrontend, vite, requirements, } from '@astrale-os/sdk/domain';
+import { K, KernelRootFunctions } from '@astrale-os/sdk/schema';
+import { ShellSchema, S } from './schema/index.js';
+import runtime, {} from './runtime.js';
+const frontend = defineFrontend({
+    schema: ShellSchema,
+    source: vite({ config: './frontend/vite.config.ts' }),
+    routes: { application: { path: '/', handshake: 'shell' } },
+});
+const domainRequirements = requirements({
+    // Sujet implicite : le principal installé Shell, utilisé par kernel.self.
+    functions: KernelRootFunctions,
+    classes: [
+        { class: K.classes.extends_with, operations: ['create', 'read', 'traverse', 'delete'] },
+        // listEntrypoints reads every entrypoint View locator and its Domain as Shell.
+        { class: K.classes.Domain, operations: ['read'] },
+        { class: K.classes.of_domain, operations: ['read'] },
+        { class: K.classes.entrypoint, operations: ['traverse'] },
+        { class: K.classes.View, operations: ['traverse'] },
+    ],
+    authority: {
+        grant: ['create', 'read', 'update', 'delete', 'traverse', 'use', 'revoke'],
+        revoke: ['create', 'read', 'update', 'delete', 'traverse', 'use', 'grant'],
+    },
+    // Ces profils sont matérialisés par l'installeur, pas par un handler Shell.
+    core: [
+        {
+            subject: S.core.nodes.admin,
+            functions: [
+                ...KernelRootFunctions,
+                S.classes.User.static.methods.invite,
+                S.classes.User.methods.recordProfile,
+                S.classes.Group.static.methods.assignMember,
+                S.classes.Group.static.methods.unassignMember,
+                S.classes.Namespace.methods.link,
+                S.classes.Namespace.methods.unlink,
+                S.classes.Namespace.methods.rename,
+                // Core Edges cannot author Kernel extends_with, so administrators hold it directly.
+                S.functions.listEntrypoints,
+                S.functions.assignViews,
+            ],
+            classes: [
+                { class: S.classes.User, operations: ['create', 'read', 'traverse', 'update', 'delete'] },
+                {
+                    class: S.classes.Group,
+                    operations: ['create', 'read', 'traverse', 'update', 'delete'],
+                },
+                {
+                    class: S.classes.member_of_group,
+                    operations: ['create', 'read', 'traverse', 'update', 'delete'],
+                },
+                { class: S.classes.Namespace, operations: ['read', 'traverse'] },
+                { class: S.classes.alias, operations: ['create', 'read', 'traverse', 'update', 'delete'] },
+                // assignViews gives and withdraws Views; a Mutation may too. view_access carries no property.
+                { class: S.classes.view_access, operations: ['create', 'read', 'traverse', 'delete'] },
+                { class: K.classes.extends_with, operations: ['create', 'read', 'traverse', 'delete'] },
+            ],
+            authority: {
+                grant: ['create', 'read', 'update', 'delete', 'traverse', 'use', 'revoke'],
+                revoke: ['create', 'read', 'update', 'delete', 'traverse', 'use', 'grant'],
+            },
+        },
+        {
+            subject: S.core.nodes.member,
+            functions: [
+                // Download re-reads the holder Node with the caller's authority: no new data exposure.
+                K.functions.download,
+                K.functions.introspect,
+                K.functions.query,
+                K.functions.mutate,
+                K.classes.View.static.methods.resolve,
+                // The workspace opens only on this catalogue: an invited member must be able to read it.
+                S.functions.listEntrypoints,
+                // The GUI records the email and name each account signs in with; isSelf bounds it.
+                S.classes.User.methods.recordProfile,
+            ],
+        },
+        {
+            // For Identities outside Members: Group.assignMember(identity, applications) composes it.
+            // `query` opens `/v/<name>`: the full page reads that Path with a Query under the visitor's
+            // own rights, so read rules still decide what it sees.
+            subject: S.core.nodes.applications,
+            functions: [
+                S.functions.listEntrypoints,
+                K.classes.View.static.methods.resolve,
+                K.functions.query,
+            ],
+        },
+    ],
+});
+export const domain = defineDomain({
+    schema: ShellSchema,
+    runtime,
+    frontend,
+    requirements: domainRequirements,
+});

package/dist/functions/application/index.js

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

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

@@ -0,0 +1,6 @@
+import { defineAction } from '@astrale-os/sdk/action';
+import { readInstalledEntrypoints } from '../../queries/application/index.js';
+/** One graph read: every Domain with an `entrypoint` Edge, its name and its entrypoint View. */
+export const listEntrypoints = defineAction()('listEntrypoints', async ({ query }) => ({
+    entrypoints: [...(await query(readInstalledEntrypoints, undefined, { as: 'executor' }))],
+}));

package/dist/functions/group/assign-member-to-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 assignMember = defineWorkflow()('Group.assignMember', { errors: groupMembershipErrors }, (context) => changeGroupMembership(context, true));

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

@@ -0,0 +1,34 @@
+import { setGroupMembership } from '../../mutations/group/index.js';
+import { readGroupMembership, readGroupMembershipEndpoints, } from '../../queries/group/index.js';
+import { canonicalNodeId } from '../../utils/canonical-node-path/index.js';
+const matches = (state, present) => state.membership === present && state.authority === present;
+export async function changeGroupMembership(context, present) {
+    const invalid = () => context.error('INVALID_GROUP_MEMBERSHIP_REFERENCE', {});
+    const membership = {
+        member: canonicalNodeId(context.input.member, invalid),
+        group: canonicalNodeId(context.input.group, invalid),
+    };
+    const observe = async () => {
+        const endpoints = await context.query(readGroupMembershipEndpoints, membership);
+        if (!endpoints.visible)
+            throw context.error('GROUP_MEMBERSHIP_ENDPOINTS_UNAVAILABLE', {});
+        const current = await context.query(readGroupMembership, membership);
+        return { ...current, endpoints: endpoints.guard };
+    };
+    const current = await context.step.run('observe-membership', observe);
+    if (matches(current, present))
+        return {};
+    const result = await context.step.run('mutate-membership', () => context.mutate(setGroupMembership, { ...membership, current, present }));
+    if (result.ok)
+        return {};
+    if (result.outcomeKnown) {
+        throw context.error('GROUP_MEMBERSHIP_CONFLICT', { cause: result.code });
+    }
+    const recovered = await context.step.run('recover-membership', observe);
+    if (matches(recovered, present))
+        return {};
+    throw context.error('GROUP_MEMBERSHIP_UNCONFIRMED', {
+        cause: result.code,
+        outcomeKnown: false,
+    });
+}

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

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+export const groupMembershipErrors = {
+    GROUP_MEMBERSHIP_ENDPOINTS_UNAVAILABLE: {
+        family: 'CONFLICT',
+        message: 'Shell must be able to traverse both membership endpoints before confirming membership.',
+        details: z.strictObject({}),
+    },
+    INVALID_GROUP_MEMBERSHIP_REFERENCE: {
+        family: 'VALIDATION_ERROR',
+        message: 'Member and group must be exact canonical @NodeId paths.',
+        details: z.strictObject({}),
+    },
+    GROUP_MEMBERSHIP_CONFLICT: {
+        family: 'CONFLICT',
+        message: 'Membership changed concurrently; retry the operation.',
+        details: z.strictObject({ cause: z.string() }),
+    },
+    GROUP_MEMBERSHIP_UNCONFIRMED: {
+        family: 'CONFLICT',
+        message: 'The requested membership could not be confirmed; retry the operation.',
+        details: z.strictObject({ cause: z.string(), outcomeKnown: z.literal(false) }),
+    },
+};

package/dist/functions/group/index.js

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

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));

package/dist/functions/namespace/index.js

@@ -0,0 +1,3 @@
+export { link } from './link.js';
+export { unlink } from './unlink.js';
+export { rename } from './rename.js';

package/dist/functions/namespace/link.js

@@ -0,0 +1,30 @@
+import { defineAction } from '@astrale-os/sdk/action';
+import { Path } from '@astrale-os/sdk/graph/path';
+import { linkAlias } from '../../mutations/namespace/index.js';
+import { namespaceErrors } from './namespace-errors.js';
+import { namespaceSlug } from './namespace-name.js';
+/**
+ * One Mutation with Shell's own authority. An alias grants nothing and each reader sees only the
+ * aliases toward Nodes it may read, so `link` names any Node its target Path reaches; the `alias`
+ * key keeps a name to one Node for every author.
+ */
+export const link = defineAction()('Namespace.link', { errors: namespaceErrors }, async ({ error, mutate, input, self }) => {
+    const name = namespaceSlug(input.name);
+    if (name === undefined)
+        throw error('INVALID_NAME', { name: input.name });
+    const result = await mutate(linkAlias, {
+        namespace: self,
+        name,
+        target: Path.parse(input.target),
+    });
+    if (result.ok)
+        return {};
+    switch (result.refusal) {
+        case 'NAME_TAKEN':
+            throw error('NAME_TAKEN', { name });
+        case 'TARGET_ALREADY_ALIASED':
+            throw error('TARGET_ALREADY_ALIASED', {});
+        case 'TARGET_NOT_FOUND':
+            throw error('TARGET_NOT_FOUND', {});
+    }
+});

package/dist/functions/namespace/namespace-errors.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+export const namespaceErrors = {
+    INVALID_NAME: {
+        family: 'VALIDATION_ERROR',
+        message: 'A name uses lower-case letters, digits, ".", "_" and "-", and starts and ends with a letter or digit.',
+        details: z.strictObject({ name: z.string() }),
+    },
+    TARGET_NOT_FOUND: {
+        family: 'NOT_FOUND',
+        message: 'The target Path reaches no Node.',
+        details: z.strictObject({}),
+    },
+    NAME_TAKEN: {
+        family: 'CONFLICT',
+        message: 'This name already designates a Node in this Namespace.',
+        details: z.strictObject({ name: z.string() }),
+    },
+    TARGET_ALREADY_ALIASED: {
+        family: 'CONFLICT',
+        message: 'This Node already has an alias in this Namespace; rename it instead.',
+        details: z.strictObject({}),
+    },
+    NAME_NOT_FOUND: {
+        family: 'NOT_FOUND',
+        message: 'No alias of this Namespace has this name.',
+        details: z.strictObject({ name: z.string() }),
+    },
+};

package/dist/functions/namespace/namespace-name.js

@@ -0,0 +1,13 @@
+import { EdgeSlug, isEdgeSlug } from '@astrale-os/sdk/graph/edge';
+import { Path } from '@astrale-os/sdk/graph/path';
+/** The Edge slug a name is: an exact Edge slug, in lower case. Anything else is no name. */
+export function namespaceSlug(name) {
+    return isEdgeSlug(name) && name === name.toLowerCase() ? EdgeSlug(name) : undefined;
+}
+/**
+ * The Path of one name of a Namespace: `@<namespace>~"<alias>"(<name>)`. The `alias` key comes from
+ * the admitted Domain, so the Worker never loads the Schema's builder.
+ */
+export function aliasPath(domain, namespace, name) {
+    return Path.id(namespace).out(domain.classes.alias.key, { slug: name });
+}

package/dist/functions/namespace/rename.js

@@ -0,0 +1,31 @@
+import { defineAction } from '@astrale-os/sdk/action';
+import { renameAlias } from '../../mutations/namespace/index.js';
+import { readDesignatedNode } from '../../queries/namespace/index.js';
+import { namespaceErrors } from './namespace-errors.js';
+import { aliasPath, namespaceSlug } from './namespace-name.js';
+/**
+ * One read of the Node the name designates, then one Mutation renaming its alias while it still
+ * carries that name. Renaming a name to itself finds the Node and writes nothing.
+ */
+export const rename = defineAction()('Namespace.rename', { errors: namespaceErrors }, async ({ domain, error, query, mutate, input, self }) => {
+    const name = namespaceSlug(input.name);
+    if (name === undefined)
+        throw error('INVALID_NAME', { name: input.name });
+    const to = namespaceSlug(input.to);
+    if (to === undefined)
+        throw error('INVALID_NAME', { name: input.to });
+    const target = await query(readDesignatedNode, { path: aliasPath(domain, self, name) });
+    if (target === undefined)
+        throw error('NAME_NOT_FOUND', { name });
+    if (to === name)
+        return {};
+    const result = await mutate(renameAlias, { namespace: self, target, name, to });
+    if (result.ok)
+        return {};
+    switch (result.refusal) {
+        case 'NAME_TAKEN':
+            throw error('NAME_TAKEN', { name: to });
+        case 'NAME_NOT_FOUND':
+            throw error('NAME_NOT_FOUND', { name });
+    }
+});

package/dist/functions/namespace/unlink.js

@@ -0,0 +1,21 @@
+import { defineAction } from '@astrale-os/sdk/action';
+import { unlinkAlias } from '../../mutations/namespace/index.js';
+import { readDesignatedNode } from '../../queries/namespace/index.js';
+import { namespaceErrors } from './namespace-errors.js';
+import { aliasPath, namespaceSlug } from './namespace-name.js';
+/**
+ * One read of the Node the name designates, then one Mutation deleting its alias while it still
+ * carries that name: a concurrent rename answers NAME_NOT_FOUND instead of removing another name.
+ */
+export const unlink = defineAction()('Namespace.unlink', { errors: namespaceErrors }, async ({ domain, error, query, mutate, input, self }) => {
+    const name = namespaceSlug(input.name);
+    if (name === undefined)
+        throw error('INVALID_NAME', { name: input.name });
+    const target = await query(readDesignatedNode, { path: aliasPath(domain, self, name) });
+    if (target === undefined)
+        throw error('NAME_NOT_FOUND', { name });
+    const result = await mutate(unlinkAlias, { namespace: self, target, name });
+    if (result.ok)
+        return {};
+    throw error('NAME_NOT_FOUND', { name });
+});

package/dist/functions/user/index.js

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

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

@@ -0,0 +1,39 @@
+import { defineWorkflow } from '@astrale-os/sdk/workflow';
+import { z } from 'zod';
+import { InvitationRequestFailure } from '../../integrations/user-invitation/index.js';
+import { canonicalNodeId } from '../../utils/canonical-node-path/index.js';
+export const invite = defineWorkflow()('User.invite', {
+    errors: {
+        INVALID_INVITATION_REFERENCE: {
+            family: 'VALIDATION_ERROR',
+            message: 'User must be an exact canonical @NodeId path.',
+            details: z.strictObject({}),
+        },
+        INVITATION_CONFLICT: {
+            family: 'CONFLICT',
+            message: 'The invitation conflicts with an existing request.',
+            details: z.strictObject({ requestId: z.string() }),
+        },
+        INVITATION_REJECTED: {
+            family: 'VALIDATION_ERROR',
+            message: 'Admin rejected the invitation request.',
+            details: z.strictObject({ requestId: z.string() }),
+        },
+    },
+}, async (context) => {
+    const user = canonicalNodeId(context.input.user, () => context.error('INVALID_INVITATION_REFERENCE', {}));
+    const requestId = context.execution.idempotencyKey ?? crypto.randomUUID();
+    try {
+        return await context.step.run('request-invitation', () => context.integrations.enrollment.invite({
+            user,
+            email: context.input.email,
+            requestId,
+            requestedBy: context.caller.identity,
+        }));
+    }
+    catch (cause) {
+        if (cause instanceof InvitationRequestFailure)
+            throw context.error(cause.code, { requestId });
+        throw cause;
+    }
+});

package/dist/functions/user/record-profile.js

@@ -0,0 +1,18 @@
+import { defineAction } from '@astrale-os/sdk/action';
+import { recordUserProfile } from '../../mutations/user/index.js';
+import { readUserProfile } from '../../queries/user/index.js';
+/**
+ * One read and, only when something changed, one write, with Shell's own authority: the policy
+ * admits the account itself alone. An email is kept in lower case.
+ */
+export const recordProfile = defineAction()('User.recordProfile', async ({ input, self, query, mutate }) => {
+    const asked = {
+        ...(input.email === undefined ? {} : { email: input.email.trim().toLowerCase() }),
+        ...(input.displayName === undefined ? {} : { displayName: input.displayName }),
+    };
+    const current = await query(readUserProfile, { user: self }, { as: 'executor' });
+    const set = Object.fromEntries(Object.entries(asked).filter(([key, value]) => current[key] !== value));
+    if (Object.keys(set).length > 0)
+        await mutate(recordUserProfile, { user: self, set });
+    return {};
+});

package/dist/functions/view-access/assign-views.js

@@ -0,0 +1,86 @@
+import { defineAction } from '@astrale-os/sdk/action';
+import { Path } from '@astrale-os/sdk/graph/path';
+import { setViewAccess } from '../../mutations/view-access/index.js';
+import { readViewAccess } from '../../queries/view-access/index.js';
+import { canonicalNodeId } from '../../utils/canonical-node-path/index.js';
+import { viewAccessErrors } from './view-access-errors.js';
+/**
+ * One read and at most one Mutation, both with Shell's own authority: holding `can_use` on this
+ * Function is what admits the caller, Core admin by default. The write changes only what differs
+ * from the Edges read, under their guard, so a View already given or already withdrawn costs
+ * nothing and a concurrent change refuses the whole write. An identity listed twice gets both
+ * lists; one listed with no View is not read.
+ */
+export const assignViews = defineAction()('assignViews', { errors: viewAccessErrors }, async ({ error, input, query, mutate }) => {
+    const nodeId = (reference) => {
+        const invalid = () => error('INVALID_VIEW_ASSIGNMENT_REFERENCE', {});
+        try {
+            return canonicalNodeId(reference, invalid);
+        }
+        catch {
+            throw invalid();
+        }
+    };
+    const wanted = new Map();
+    for (const assignment of input.assignments) {
+        const identity = nodeId(assignment.identity);
+        const lists = [
+            [assignment.set ?? [], true],
+            [assignment.unset ?? [], false],
+        ];
+        for (const [list, given] of lists) {
+            for (const reference of list) {
+                const view = nodeId(reference);
+                const views = wanted.get(identity) ?? new Map();
+                wanted.set(identity, views);
+                if (views.get(view) === !given) {
+                    throw error('CONTRADICTORY_VIEW_ASSIGNMENT', {
+                        identity: Path.id(identity).raw,
+                        view: Path.id(view).raw,
+                    });
+                }
+                views.set(view, given);
+            }
+        }
+    }
+    const [first, ...others] = wanted.keys();
+    if (first === undefined)
+        return {};
+    const read = () => query(readViewAccess, { identities: [first, ...others] });
+    const current = await read();
+    const { give, withdraw } = changes(wanted, current);
+    if (give.length === 0 && withdraw.length === 0)
+        return {};
+    const result = await mutate(setViewAccess, { give, withdraw, guard: current.guard });
+    if (result.ok)
+        return {};
+    switch (result.refusal) {
+        case 'ENDPOINT_NOT_FOUND':
+            // Every endpoint of a withdrawal was read: one that vanished was deleted meanwhile.
+            if (give.length > 0)
+                throw error('VIEW_ASSIGNMENT_ENDPOINT_NOT_FOUND', {});
+            throw error('VIEW_ACCESS_CONFLICT', {});
+        case 'CHANGED':
+            throw error('VIEW_ACCESS_CONFLICT', {});
+        case 'UNKNOWN': {
+            const after = changes(wanted, await read());
+            if (after.give.length === 0 && after.withdraw.length === 0)
+                return {};
+            throw error('VIEW_ACCESS_UNCONFIRMED', {});
+        }
+    }
+});
+/** What differs between the Views wanted and the Views held. */
+function changes(wanted, current) {
+    const give = [];
+    const withdraw = [];
+    for (const [identity, views] of wanted) {
+        const held = current.given.get(identity);
+        for (const [view, given] of views) {
+            if (given === (held?.has(view) ?? false))
+                continue;
+            (given ? give : withdraw).push({ identity, view });
+        }
+    }
+    return { give, withdraw };
+}

package/dist/functions/view-access/index.js

@@ -0,0 +1 @@
+export { assignViews } from './assign-views.js';

package/dist/functions/view-access/view-access-errors.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+export const viewAccessErrors = {
+    INVALID_VIEW_ASSIGNMENT_REFERENCE: {
+        family: 'VALIDATION_ERROR',
+        message: 'Identities and Views must be exact canonical @NodeId paths.',
+        details: z.strictObject({}),
+    },
+    CONTRADICTORY_VIEW_ASSIGNMENT: {
+        family: 'VALIDATION_ERROR',
+        message: 'One View is both given to and withdrawn from the same identity.',
+        details: z.strictObject({ identity: z.string(), view: z.string() }),
+    },
+    VIEW_ASSIGNMENT_ENDPOINT_NOT_FOUND: {
+        family: 'NOT_FOUND',
+        message: 'An identity is not a User or a Group, or a View to give is not a View.',
+        details: z.strictObject({}),
+    },
+    VIEW_ACCESS_CONFLICT: {
+        family: 'CONFLICT',
+        message: 'The Views of these identities changed concurrently; retry the operation.',
+        details: z.strictObject({}),
+    },
+    VIEW_ACCESS_UNCONFIRMED: {
+        family: 'CONFLICT',
+        message: 'The Views asked for could not be confirmed; retry the operation.',
+        details: z.strictObject({}),
+    },
+};

package/dist/index.d.ts

@@ -1,3 +1 @@
-export { Group, ORIGIN, S, ShellCore, ShellSchema, Space, User, adminGroup, administers_space, belongsToSpace, default_space, defaultSpace, groupAssignUser, groupCore, groupUnassignUser, groupView, homeView, mayAdministerSpace, maySetupUsers, memberGroup, member_of_group, member_of_space, owns_space, ownsSpace, resolveHome, setupAdmin, setupMember, spaceAddUser, spaceCore, spaceRemoveUser, spaceSetDefault, spaceView, userView, 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';
-export { application } from './application.js';
-export { default as runtime } from './runtime.js';
+export { ShellSchema, S, type Shell, type ShellClasses, type ShellSchemaInput, type InvitationSummary, User, Group, member_of_group, adminGroup, memberGroup, Namespace, alias, viewsNamespace, } from './schema/index.js';

package/dist/index.js

@@ -1,3 +1 @@
-export { Group, ORIGIN, S, ShellCore, ShellSchema, Space, User, adminGroup, administers_space, belongsToSpace, default_space, defaultSpace, groupAssignUser, groupCore, groupUnassignUser, groupView, homeView, mayAdministerSpace, maySetupUsers, memberGroup, member_of_group, member_of_space, owns_space, ownsSpace, resolveHome, setupAdmin, setupMember, spaceAddUser, spaceCore, spaceRemoveUser, spaceSetDefault, spaceView, userView, } from '#schema';
-export { application } from './application.js';
-export { default as runtime } from './runtime.js';
+export { ShellSchema, S, User, Group, member_of_group, adminGroup, memberGroup, Namespace, alias, viewsNamespace, } from './schema/index.js';

package/dist/integrations/index.d.ts

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

package/dist/integrations/index.js

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

package/dist/integrations/integrations.d.ts

@@ -0,0 +1,9 @@
+export declare const integrations: {
+    enrollment: import("@astrale-os/sdk/integration").IntegrationDefinition<"shell.enrollment", {
+        invite: import("@astrale-os/sdk/integration").IntegrationOperation<import("./user-invitation/index.js").InviteRequest, {
+            invitationId: string;
+            user: string;
+            state: "accepted" | "cancelled" | "completed" | "expired" | "failed" | "pending" | "registered" | "registering";
+        }, "keyed" | "safe">;
+    }>;
+};

package/dist/integrations/integrations.js

@@ -0,0 +1,2 @@
+import { enrollment } from './user-invitation/index.js';
+export const integrations = { enrollment };

package/dist/integrations/user-invitation/index.d.ts

@@ -0,0 +1,4 @@
+export { enrollment } from './request-user-invitation.js';
+export { InvitationRequestFailure } from './invitation-request-failure.js';
+export { type InviteRequest } from './invite-user-request.js';
+export type { InvitationSummary } from '../../schema/modules/user/index.js';

package/dist/integrations/user-invitation/index.js

@@ -0,0 +1,3 @@
+export { enrollment } from './request-user-invitation.js';
+export { InvitationRequestFailure } from './invitation-request-failure.js';
+export {} from './invite-user-request.js';

package/dist/integrations/user-invitation/invitation-request-failure.d.ts

@@ -0,0 +1,5 @@
+/** Expected business refusal from the invitation service, without its response body. */
+export declare class InvitationRequestFailure extends Error {
+    readonly code: 'INVITATION_CONFLICT' | 'INVITATION_REJECTED';
+    constructor(code: 'INVITATION_CONFLICT' | 'INVITATION_REJECTED');
+}

package/dist/integrations/user-invitation/invitation-request-failure.js

@@ -0,0 +1,9 @@
+/** Expected business refusal from the invitation service, without its response body. */
+export class InvitationRequestFailure extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = 'InvitationRequestFailure';
+    }
+}

package/dist/integrations/user-invitation/invite-user-request.d.ts

@@ -0,0 +1,6 @@
+export interface InviteRequest {
+    readonly requestId: string;
+    readonly user: string;
+    readonly email: string;
+    readonly requestedBy: string;
+}

package/dist/integrations/user-invitation/invite-user-request.js

@@ -0,0 +1 @@
+export {};

package/dist/integrations/user-invitation/request-user-invitation.d.ts

@@ -0,0 +1,8 @@
+import type { InviteRequest } from './invite-user-request.js';
+export declare const enrollment: import("@astrale-os/sdk/integration").IntegrationDefinition<"shell.enrollment", {
+    invite: import("@astrale-os/sdk/integration").IntegrationOperation<InviteRequest, {
+        invitationId: string;
+        user: string;
+        state: "accepted" | "cancelled" | "completed" | "expired" | "failed" | "pending" | "registered" | "registering";
+    }, "keyed" | "safe">;
+}>;

package/dist/integrations/user-invitation/request-user-invitation.js

@@ -0,0 +1,9 @@
+import { defineIntegration } from '@astrale-os/sdk/integration';
+export const enrollment = defineIntegration({
+    id: 'shell.enrollment',
+    operations: {
+        invite: defineIntegration.operation({
+            replay: ({ requestId }) => ({ kind: 'keyed', source: 'input', key: requestId }),
+        }),
+    },
+});

package/dist/mutations/group/index.js

@@ -1 +1 @@
-export { changeGroupMembership, } from './membership.js';
+export { setGroupMembership } from './set-group-membership.js';

package/dist/mutations/group/set-group-membership.js

@@ -0,0 +1,29 @@
+import { defineMutation } from '@astrale-os/sdk/mutation';
+export const setGroupMembership = defineMutation()((domain) => ({
+    id: 'shell.group.membership.set',
+    build(input, mutation) {
+        mutation.expect.query(input.current.endpoints);
+        mutation.expect.query(input.current.guard);
+        const endpoints = { source: input.member, target: input.group };
+        const changes = [
+            { class: domain.classes.member_of_group, current: input.current.membership },
+            { class: domain.dependencies.kernel.classes.extends_with, current: input.current.authority },
+        ];
+        for (const edge of changes) {
+            if (edge.current === input.present)
+                continue;
+            if (input.present)
+                mutation.createEdge({ class: edge.class, ...endpoints });
+            else
+                mutation.deleteEdge({ class: edge.class, ...endpoints });
+        }
+    },
+    project: () => ({ ok: true }),
+    reject: (failure) => {
+        if (failure.outcomeKnown &&
+            failure.code !== 'MUTATION_PRECONDITION_FAILED' &&
+            failure.code !== 'MUTATION_CONFLICT')
+            throw failure;
+        return { ok: false, code: failure.code, outcomeKnown: failure.outcomeKnown };
+    },
+}));