@astrale-domains/shell 0.1.6 → 0.1.8

package/dist/functions/user/write-account.js

@@ -0,0 +1,57 @@
+import { PROFILE_PROPERTIES, newProfileValues, updateAccount, } from '../../mutations/identity/index.js';
+import { readProfile } from '../../queries/profile/index.js';
+import { sameJson } from '../../utils/index.js';
+/** The values of an account a write is decided on. */
+const DECIDED = [
+    'name',
+    'email',
+    'givenName',
+    'familyName',
+    'icon',
+    'directory',
+    'externalId',
+    'frozen',
+];
+/**
+ * Write what differs between an account and a change (`null` erases). `frozen` is written as is: it
+ * alone states whether the account may sign in. The write holds only on the values it was decided on. It answers whether
+ * anything changed, or the refusal: a key another account holds, or a concurrent change.
+ */
+export async function writeAccount({ mutate, query }, account, change) {
+    const set = {};
+    const unset = [];
+    for (const [key, value] of Object.entries(change)) {
+        const current = account[key];
+        if (value === null || value === undefined) {
+            if (value === null && current !== undefined)
+                unset.push(key);
+        }
+        else if (!sameJson(value, current))
+            set[key] = value;
+    }
+    if (Object.keys(set).length === 0 && unset.length === 0)
+        return 'unchanged';
+    const expected = Object.fromEntries(DECIDED.map((key) => [key, account[key]]));
+    // The profile carries the shared values; an account stored before profiles gets one now.
+    const shares = PROFILE_PROPERTIES.some((key) => key in set || unset.includes(key));
+    const profileNode = shares
+        ? await query(readProfile, { kind: 'User', node: account.id })
+        : undefined;
+    const merged = Object.fromEntries(Object.entries({ ...account, ...set }).filter(([key]) => !unset.includes(key)));
+    const created = profileNode === undefined ? newProfileValues(merged) : undefined;
+    const profile = !shares
+        ? undefined
+        : profileNode !== undefined
+            ? { id: profileNode }
+            : created === undefined
+                ? undefined
+                : { create: created };
+    const result = await mutate(updateAccount, {
+        user: account.id,
+        set: set,
+        unset,
+        expected,
+        ...(profile === undefined ? {} : { profile }),
+    });
+    return result.ok ? 'written' : result.refusal;
+}

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

@@ -1 +1,2 @@
-export { assignViews } from './assign-views.js';
+// Seam L-SHELL-12: the legacy handler the Runtime registers.
+export { legacyAssignViews } from './legacy/index.js';

package/dist/functions/view-access/{assign-views.js → legacy/assign-views.js}

@@ -1,17 +1,21 @@
 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';
+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 { legacyViewAccessErrors } 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
+ * @deprecated Give and withdraw Views for each identity in one write (L-SHELL-12). Replaced by a
+ * Mutation on `view_access`, which `workspace.admin` holders write. Removal: Shell major (delivery
+ * step 5) after 1Pact step 4.
+ *
+ * One read and at most one Mutation, both with Shell's own authority: `workspace.admin` admits the
+ * caller. 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 }) => {
+export const legacyAssignViews = defineAction()('assignViews', { errors: legacyViewAccessErrors }, async ({ error, input, query, mutate }) => {
     const nodeId = (reference) => {
         const invalid = () => error('INVALID_VIEW_ASSIGNMENT_REFERENCE', {});
         try {

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

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

package/dist/functions/view-access/{view-access-errors.js → legacy/view-access-errors.js}

@@ -1,5 +1,9 @@
 import { z } from 'zod';
-export const viewAccessErrors = {
+/**
+ * @deprecated The refusals of `assignViews` (L-SHELL-12). Replaced by the Kernel's refusals of a
+ * Mutation on `view_access`. Removal: Shell major (delivery step 5) after 1Pact step 4.
+ */
+export const legacyViewAccessErrors = {
     INVALID_VIEW_ASSIGNMENT_REFERENCE: {
         family: 'VALIDATION_ERROR',
         message: 'Identities and Views must be exact canonical @NodeId paths.',

package/dist/index.d.ts

@@ -1 +1 @@
-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';
+export { ShellSchema, S, type Shell, type ShellClasses, type ShellSchemaInput, type InvitationSummary, type ProfileName, User, Group, Role, hasRole, profileRoles, atomicRoles, shellRoles, PROFILE_NAMES, view_access, Namespace, alias, viewsNamespace, member_of_group, adminGroup, memberGroup, } from './schema/index.js';

package/dist/index.js

@@ -1 +1,3 @@
-export { ShellSchema, S, User, Group, member_of_group, adminGroup, memberGroup, Namespace, alias, viewsNamespace, } from './schema/index.js';
+export { ShellSchema, S, User, Group, Role, hasRole, profileRoles, atomicRoles, shellRoles, PROFILE_NAMES, view_access, Namespace, alias, viewsNamespace, 
+// L-SHELL-16: the former names of the legacy Edge Class and Core groups.
+member_of_group, adminGroup, memberGroup, } from './schema/index.js';

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

@@ -1,6 +1,12 @@
+import type { ProfileName } from '../../schema/modules/role/index.js';
+/**
+ * What Shell asks Admin to send: the account, its email, the profile it was granted, and who asked.
+ * `profile` is optional on the wire, so an Admin that ignores it still sends the invitation.
+ */
 export interface InviteRequest {
     readonly requestId: string;
     readonly user: string;
     readonly email: string;
+    readonly profile?: ProfileName;
     readonly requestedBy: string;
 }

package/dist/legacy/index.js

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

package/dist/legacy/release.js

@@ -0,0 +1,33 @@
+import { requirements, } from '@astrale-os/sdk/domain';
+import { K } from '@astrale-os/sdk/schema';
+import { S } from '../schema/index.js';
+const key = ({ ref }) => `${ref.origin}:${ref.name}`;
+/** The members each legacy binding adds to a target binding, by Role. */
+const members = new Map([
+    // The legacy Core groups each become a member of the profile they stood for, so every stored
+    // member holds that profile with no data migration (AM3).
+    [key(S.core.nodes['workspace.admin']), [S.core.nodes.admin]],
+    [key(S.core.nodes['workspace.member']), [S.core.nodes.member]],
+    // View only and Applications open only what they are given: Kernel reader, with no profile (AM10).
+    [key(K.core.nodes.reader), [S.core.nodes['view-only'], S.core.nodes.applications]],
+    // listEntrypoints reads every entrypoint View as Shell.
+    [key(K.core.nodes['view.reader']), [requirements.domain]],
+]);
+/**
+ * @deprecated The release bindings legacy Core groups and callers need (L-SHELL-7): each legacy
+ * group is a member of its profile (AM3); Shell reads installed entrypoints for `listEntrypoints`
+ * (row L-SHELL-11), and writes `extends_with` when it acts for the owner of a foreign Group
+ * subclass, bounded by its own scope (row L-SHELL-9, AM5). Replaced by the target bindings alone.
+ * Removal: Shell major (delivery step 5) after 1Pact step 4.
+ */
+export function legacyRelease(target) {
+    return {
+        roles: target.roles.map((binding) => {
+            const added = members.get(key(binding.role));
+            return added === undefined
+                ? binding
+                : { ...binding, members: [...(binding.members ?? []), ...added] };
+        }),
+        scopes: [{ on: K.classes.extends_with, operations: ['create', 'delete'] }],
+    };
+}

package/dist/mutations/composition/grant-role.js

@@ -0,0 +1,13 @@
+import { defineMutation } from '@astrale-os/sdk/mutation';
+/** Grant one Role: `extends_with` from the holder to it (R1). Shell owns its Roles' Class. */
+export const grantRole = defineMutation()((domain) => ({
+    id: 'shell.role.grant',
+    build({ holder, role }, mutation) {
+        mutation.createEdge({
+            class: domain.dependencies.kernel.classes.extends_with,
+            source: { id: holder },
+            target: role,
+        });
+    },
+    project: () => ({}),
+}));

package/dist/mutations/composition/index.js

@@ -0,0 +1 @@
+export { grantRole } from './grant-role.js';

package/dist/mutations/group/index.js

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

package/dist/mutations/group/legacy/index.js

@@ -0,0 +1 @@
+export { legacyMembershipClass } from './membership-class.js';

package/dist/mutations/group/legacy/membership-class.js

@@ -0,0 +1,7 @@
+/**
+ * @deprecated The legacy `member_of_group` Edge Class a membership write converges (L-SHELL-8).
+ * Replaced by `extends_with` alone. Removal: Shell major (delivery step 5) after 1Pact step 4.
+ */
+export function legacyMembershipClass(domain) {
+    return domain.classes.member_of_group;
+}

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

@@ -1,29 +1,70 @@
 import { defineMutation } from '@astrale-os/sdk/mutation';
+// Seam L-SHELL-8: the legacy membership Edge a change may converge beside `extends_with`.
+import { legacyMembershipClass } from './legacy/index.js';
+const rejectChange = (failure) => {
+    if (failure.outcomeKnown &&
+        failure.code !== 'MUTATION_PRECONDITION_FAILED' &&
+        failure.code !== 'MUTATION_CONFLICT' &&
+        failure.code !== 'MUTATION_POST_STATE_INVALID')
+        throw failure;
+    return {
+        ok: false,
+        code: failure.code,
+        ...(failure.rule !== undefined ? { rule: failure.rule } : {}),
+        outcomeKnown: failure.outcomeKnown,
+    };
+};
+/**
+ * Create or delete membership Edges of several members of one group in one commit, under the few
+ * guards that cover all of them: every change is written, or none.
+ */
+export const setGroupMemberships = defineMutation()((domain) => ({
+    id: 'shell.group.memberships.set',
+    build(input, mutation) {
+        for (const guard of input.guards)
+            mutation.expect.query(guard);
+        for (const change of input.changes) {
+            const endpoints = { source: { id: change.member }, target: { id: input.group } };
+            const selected = change.edge === 'authority'
+                ? domain.dependencies.kernel.classes.extends_with
+                : legacyMembershipClass(domain);
+            if (change.present)
+                mutation.createEdge({ class: selected, ...endpoints });
+            else
+                mutation.deleteEdge({ class: selected, ...endpoints });
+        }
+    },
+    project: () => ({ ok: true }),
+    reject: (failure) => rejectChange({
+        outcomeKnown: failure.outcomeKnown,
+        code: failure.code,
+        ...('rule' in failure && failure.rule !== undefined ? { rule: failure.rule } : {}),
+    }),
+}));
+/** Converge the membership Edges of one pair, guarded by what was observed of them. */
 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)
+        mutation.expect.query(input.endpoints);
+        for (const edge of input.edges)
+            mutation.expect.query(edge.guard);
+        const endpoints = { source: { id: input.member }, target: { id: input.group } };
+        for (const edge of input.edges) {
+            if (edge.current === edge.present)
                 continue;
-            if (input.present)
-                mutation.createEdge({ class: edge.class, ...endpoints });
+            const selected = edge.edge === 'authority'
+                ? domain.dependencies.kernel.classes.extends_with
+                : legacyMembershipClass(domain);
+            if (edge.present)
+                mutation.createEdge({ class: selected, ...endpoints });
             else
-                mutation.deleteEdge({ class: edge.class, ...endpoints });
+                mutation.deleteEdge({ class: selected, ...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 };
-    },
+    reject: (failure) => rejectChange({
+        outcomeKnown: failure.outcomeKnown,
+        code: failure.code,
+        ...('rule' in failure && failure.rule !== undefined ? { rule: failure.rule } : {}),
+    }),
 }));

package/dist/mutations/identity/create-profile.js

@@ -0,0 +1,37 @@
+import { defineMutation } from '@astrale-os/sdk/mutation';
+/** Give an account or a group stored before profiles its profile. */
+export const createProfile = defineMutation()((domain) => ({
+    id: 'shell.profile.create',
+    build(input, mutation) {
+        if (input.kind === 'User') {
+            const profile = mutation.createNode({
+                as: 'profile',
+                class: domain.classes.UserProfile,
+                props: input.values,
+            });
+            mutation.createEdge({
+                class: domain.classes.user_profile,
+                source: { id: input.owner },
+                target: profile,
+            });
+            return;
+        }
+        const profile = mutation.createNode({
+            as: 'profile',
+            class: domain.classes.GroupProfile,
+            props: input.values,
+        });
+        mutation.createEdge({
+            class: domain.classes.group_profile,
+            source: { id: input.owner },
+            target: profile,
+        });
+    },
+    project: () => ({ ok: true }),
+    reject: (failure) => {
+        // Another write gave it its profile meanwhile, or another profile holds the email.
+        if (failure.outcomeKnown)
+            return { ok: false, refusal: failure.code };
+        throw failure;
+    },
+}));

package/dist/mutations/identity/delete-identity.js

@@ -0,0 +1,28 @@
+import { defineMutation } from '@astrale-os/sdk/mutation';
+/** Delete one account or group, and every membership into it, in one write. */
+export const deleteIdentity = defineMutation()((domain) => ({
+    id: 'shell.identity.delete',
+    build({ kind, node, members, profile }, mutation) {
+        for (const { source, target } of members) {
+            mutation.deleteEdge({
+                class: domain.dependencies.kernel.classes.extends_with,
+                source: { id: source },
+                target: { id: target },
+            });
+        }
+        mutation.deleteNode({ node: { id: node }, class: domain.classes[kind] });
+        if (profile !== undefined) {
+            mutation.deleteNode({
+                node: { id: profile },
+                class: kind === 'User' ? domain.classes.UserProfile : domain.classes.GroupProfile,
+            });
+        }
+    },
+    project: () => ({ ok: true }),
+    reject: (failure) => {
+        // A member joined, or the Node changed, since it was read.
+        if (failure.outcomeKnown)
+            return { ok: false, refusal: failure.code };
+        throw failure;
+    },
+}));

package/dist/mutations/identity/index.js

@@ -0,0 +1,4 @@
+export { PROFILE_PROPERTIES, createAccount, newProfileValues, profileValues, updateAccount, } from './write-account.js';
+export { GROUP_PROFILE_PROPERTIES, createGroup, groupProfileValues, updateGroup, } from './write-group.js';
+export { deleteIdentity } from './delete-identity.js';
+export { createProfile } from './create-profile.js';

package/dist/mutations/identity/write-account.js

@@ -0,0 +1,109 @@
+import { defineMutation } from '@astrale-os/sdk/mutation';
+/** What an account shares on its profile: the rest stays private on the account. */
+export const PROFILE_PROPERTIES = ['name', 'givenName', 'familyName', 'email'];
+/**
+ * The values of a new profile: its name is the account's name, else "given family", else the
+ * email; undefined for an account that has none of them (it gets its profile once it has one).
+ */
+export function newProfileValues(values) {
+    const shared = profileValues(values);
+    const full = [values.givenName, values.familyName].filter(Boolean).join(' ');
+    const name = values.name ?? (full === '' ? undefined : full) ?? values.email;
+    return name === undefined ? undefined : { ...shared, name: name.slice(0, 100) };
+}
+/** A profile keeps an email of 100 characters at most; a longer one stays on the account alone. */
+export const PROFILE_EMAIL_MAX = 100;
+/** The profile values among account values. */
+export function profileValues(values) {
+    return Object.fromEntries(PROFILE_PROPERTIES.flatMap((key) => {
+        const value = values[key];
+        if (value === undefined)
+            return [];
+        if (key === 'email' && value.length > PROFILE_EMAIL_MAX)
+            return [];
+        return [[key, value]];
+    }));
+}
+const refuse = (failure) => {
+    if (failure.outcomeKnown && failure.code === 'MUTATION_POST_STATE_INVALID') {
+        if (failure.rule === 'duplicate-key')
+            return { ok: false, refusal: 'DUPLICATE_KEY' };
+    }
+    if (failure.outcomeKnown && failure.code === 'MUTATION_PRECONDITION_FAILED') {
+        return { ok: false, refusal: 'CHANGED' };
+    }
+    throw failure;
+};
+/** Create one account, optionally granting it Roles in the same write. */
+export const createAccount = defineMutation()((domain) => ({
+    id: 'shell.account.create',
+    build({ values }, mutation) {
+        const account = mutation.createNode({
+            as: 'account',
+            class: domain.classes.User,
+            props: values,
+        });
+        const shared = newProfileValues(values);
+        if (shared === undefined)
+            return;
+        const profile = mutation.createNode({
+            as: 'profile',
+            class: domain.classes.UserProfile,
+            props: shared,
+        });
+        mutation.createEdge({ class: domain.classes.user_profile, source: account, target: profile });
+    },
+    project: (result) => {
+        const user = result.createdNodes['account'];
+        if (user === undefined)
+            throw new TypeError('The Kernel created no account.');
+        return { ok: true, user };
+    },
+    reject: refuse,
+}));
+/** Set and erase Properties of one account, on the values it was decided on. */
+export const updateAccount = defineMutation()((domain) => ({
+    id: 'shell.account.update',
+    build({ user, set, unset, expected, profile }, mutation) {
+        if (expected !== undefined) {
+            const absent = Object.keys(expected).filter((key) => expected[key] === undefined);
+            const equals = Object.fromEntries(Object.entries(expected).filter(([, value]) => value !== undefined));
+            mutation.expect.node({
+                node: { id: user },
+                class: domain.classes.User,
+                props: { equals, ...(absent.length === 0 ? {} : { absent }) },
+            });
+        }
+        mutation.updateNode({
+            node: { id: user },
+            class: domain.classes.User,
+            props: { set, ...(unset === undefined || unset.length === 0 ? {} : { unset }) },
+        });
+        if (profile === undefined)
+            return;
+        if ('create' in profile) {
+            const created = mutation.createNode({
+                as: 'profile',
+                class: domain.classes.UserProfile,
+                props: profile.create,
+            });
+            mutation.createEdge({
+                class: domain.classes.user_profile,
+                source: { id: user },
+                target: created,
+            });
+            return;
+        }
+        const shared = profileValues(set);
+        const erased = (unset ?? []).filter((key) => PROFILE_PROPERTIES.includes(key));
+        if (Object.keys(shared).length === 0 && erased.length === 0)
+            return;
+        mutation.updateNode({
+            node: { id: profile.id },
+            class: domain.classes.UserProfile,
+            props: { set: shared, ...(erased.length === 0 ? {} : { unset: erased }) },
+        });
+    },
+    project: () => ({ ok: true }),
+    reject: refuse,
+}));

package/dist/mutations/identity/write-group.js

@@ -0,0 +1,72 @@
+import { defineMutation } from '@astrale-os/sdk/mutation';
+/** What a group shares on its profile: the rest stays private on the group. */
+export const GROUP_PROFILE_PROPERTIES = ['name', 'description'];
+/** The profile values among group values. */
+export function groupProfileValues(values) {
+    return Object.fromEntries(GROUP_PROFILE_PROPERTIES.flatMap((key) => values[key] === undefined ? [] : [[key, values[key]]]));
+}
+const refuse = (failure) => {
+    if (failure.outcomeKnown &&
+        failure.code === 'MUTATION_POST_STATE_INVALID' &&
+        failure.rule === 'duplicate-key') {
+        return { ok: false, refusal: 'DUPLICATE_KEY' };
+    }
+    throw failure;
+};
+/** Create one group. */
+export const createGroup = defineMutation()((domain) => ({
+    id: 'shell.group.create',
+    build({ values }, mutation) {
+        const group = mutation.createNode({ as: 'group', class: domain.classes.Group, props: values });
+        const profile = mutation.createNode({
+            as: 'profile',
+            class: domain.classes.GroupProfile,
+            props: groupProfileValues(values),
+        });
+        mutation.createEdge({ class: domain.classes.group_profile, source: group, target: profile });
+    },
+    project: (result) => {
+        const group = result.createdNodes['group'];
+        if (group === undefined)
+            throw new TypeError('The Kernel created no group.');
+        return { ok: true, group };
+    },
+    reject: refuse,
+}));
+/** Set and erase Properties of one group. */
+export const updateGroup = defineMutation()((domain) => ({
+    id: 'shell.group.update',
+    build({ group, set, unset, profile, }, mutation) {
+        mutation.updateNode({
+            node: { id: group },
+            class: domain.classes.Group,
+            props: { set, ...(unset === undefined || unset.length === 0 ? {} : { unset }) },
+        });
+        if (profile === undefined)
+            return;
+        if ('create' in profile) {
+            const created = mutation.createNode({
+                as: 'profile',
+                class: domain.classes.GroupProfile,
+                props: profile.create,
+            });
+            mutation.createEdge({
+                class: domain.classes.group_profile,
+                source: { id: group },
+                target: created,
+            });
+            return;
+        }
+        const shared = groupProfileValues(set);
+        const erased = (unset ?? []).filter((key) => GROUP_PROFILE_PROPERTIES.includes(key));
+        if (Object.keys(shared).length === 0 && erased.length === 0)
+            return;
+        mutation.updateNode({
+            node: { id: profile.id },
+            class: domain.classes.GroupProfile,
+            props: { set: shared, ...(erased.length === 0 ? {} : { unset: erased }) },
+        });
+    },
+    project: () => ({ ok: true }),
+    reject: refuse,
+}));

package/dist/mutations/invitation/index.js

@@ -0,0 +1 @@
+export { bindAccount, createInvitation, updateInvitation, } from './write-invitation.js';

package/dist/mutations/invitation/write-invitation.js

@@ -0,0 +1,79 @@
+import { defineMutation } from '@astrale-os/sdk/mutation';
+/**
+ * Record a pending invitation of one account, kept by one durable run, and cancel in the same
+ * commit the pending invitations it replaces: an account has at most one.
+ */
+export const createInvitation = defineMutation()((domain) => ({
+    id: 'shell.invitation.create',
+    build(input, mutation) {
+        for (const previous of input.replaces ?? []) {
+            mutation.expect.node({
+                node: { id: previous },
+                class: domain.classes.Invitation,
+                props: { equals: { status: 'pending' } },
+            });
+            mutation.updateNode({
+                node: { id: previous },
+                class: domain.classes.Invitation,
+                props: { set: { status: 'cancelled' } },
+            });
+        }
+        const invitation = mutation.createNode({
+            as: 'invitation',
+            class: domain.classes.Invitation,
+            props: {
+                status: 'pending',
+                expiresAt: input.expiresAt,
+                execution: input.execution,
+                round: 0,
+                email: input.email,
+            },
+        });
+        mutation.createEdge({
+            class: domain.classes.invitation_user,
+            source: invitation,
+            target: { id: input.user },
+        });
+    },
+    project: (result) => {
+        const invitation = result.createdNodes['invitation'];
+        if (invitation === undefined)
+            throw new TypeError('The Kernel created no invitation.');
+        return { invitation };
+    },
+}));
+/** Change an invitation's status, or its round and expiry, while it is still pending. */
+export const updateInvitation = defineMutation()((domain) => ({
+    id: 'shell.invitation.update',
+    build(input, mutation) {
+        mutation.expect.node({
+            node: { id: input.invitation },
+            class: domain.classes.Invitation,
+            props: { equals: { status: 'pending' } },
+        });
+        mutation.updateNode({
+            node: { id: input.invitation },
+            class: domain.classes.Invitation,
+            props: {
+                set: {
+                    ...(input.status === undefined ? {} : { status: input.status }),
+                    ...(input.round === undefined ? {} : { round: input.round }),
+                    ...(input.expiresAt === undefined ? {} : { expiresAt: input.expiresAt }),
+                },
+            },
+        });
+    },
+    project: () => ({ ok: true }),
+}));
+/** Bind an account to the sign-in that accepted its invitation (U8). */
+export const bindAccount = defineMutation()((domain) => ({
+    id: 'shell.account.bind',
+    build(input, mutation) {
+        mutation.updateNode({
+            node: { id: input.user },
+            class: domain.classes.User,
+            props: { set: { iss: input.iss, sub: input.sub } },
+        });
+    },
+    project: () => ({ ok: true }),
+}));

package/dist/mutations/user/legacy/index.js

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

package/dist/mutations/user/{record-user-profile.js → legacy/record-user-profile.js}

@@ -1,6 +1,9 @@
 import { defineMutation } from '@astrale-os/sdk/mutation';
-/** Set the email and display name an account recorded about itself. */
-export const recordUserProfile = defineMutation()((domain) => ({
+/**
+ * @deprecated Set the email and display name an account recorded about itself (L-SHELL-5). Replaced
+ * by `User.updateProfile`. Removal: Shell major (delivery step 5) after 1Pact step 4.
+ */
+export const legacyRecordUserProfile = defineMutation()((domain) => ({
     id: 'shell.user.profile.record',
     build({ user, set }, mutation) {
         const props = {