@astrale-domains/shell 0.1.7 → 0.1.9

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

@@ -1,4 +1,7 @@
-import { defineWorkflow } from '@astrale-os/sdk/workflow';
-import { changeGroupMembership } from './change-group-membership.js';
+import { defineAction } from '@astrale-os/sdk/action';
+import { changeGroupMembers, 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));
+/** Withdraw one account or group from a group, in one read and one write. */
+export const unassignMember = defineAction()('Group.unassignMember', { errors: groupMembershipErrors }, (context) => changeGroupMembership(context, false));
+/** Withdraw several accounts or groups from a group, in one commit. */
+export const unassignMembers = defineAction()('Group.unassignMembers', { errors: groupMembershipErrors }, (context) => changeGroupMembers(context, context.input, false));

package/dist/functions/invitation/send-invitation.js

@@ -2,6 +2,7 @@ import { defineWorkflow } from '@astrale-os/sdk/workflow';
 import { inviteErrors, readAccount, userErrors } from '../user/index.js';
 import { InvitationRequestFailure } from '../../integrations/user-invitation/index.js';
 import { bindAccount, createInvitation, updateInvitation } from '../../mutations/invitation/index.js';
+import { readInvitation, readPendingInvitations } from '../../queries/invitation/index.js';
 import { canonicalNodeId } from '../../utils/canonical-node-path/index.js';
 const errors = { ...inviteErrors, ...userErrors };
 /** How long an invitation waits for its first sign-in. */
@@ -12,6 +13,10 @@ export const invitationSignal = (round) => `event-${round}`;
  * Invite an account and keep its invitation until it ends: record it, have Admin send the email,
  * then wait for the first sign-in (`accept`), a resend, a cancel or the expiry. It grants nothing:
  * the account holds what `User.create` or an admin gave it.
+ *
+ * An account has at most one pending invitation. When one is pending for the same email, this run
+ * has it resent, with a full time to live again, and ends. For another email, it cancels it and
+ * records a new one; Admin replaces its own link when it receives the new request.
  */
 export const send = defineWorkflow()('Invitation.send', { errors }, async (context) => {
     const { step, execution, awaitSignal, cancelled, error } = context;
@@ -24,13 +29,57 @@ export const send = defineWorkflow()('Invitation.send', { errors }, async (conte
     if (account.email === undefined)
         throw error('USER_EMAIL_INVALID', {});
     const email = account.email;
+    // Stop the runs of replaced invitations: each finds its invitation closed and ends.
+    const stop = (runs) => step.run('stop-replaced', async ({ kernel }) => {
+        for (const { execution: ref } of runs) {
+            await kernel.execution.cancel(ref).catch(() => undefined);
+        }
+    });
+    const retire = async (invitations) => {
+        for (const [index, { id }] of invitations.entries()) {
+            await step.mutate(`retire-${index}`, updateInvitation, {
+                invitation: id,
+                status: 'cancelled',
+            });
+        }
+        await stop(invitations);
+    };
+    // Close the invitation, unless another run already closed it (a replacement).
+    const close = async (name, status) => {
+        const current = await step.run(`read-${name}`, ({ query }) => query(readInvitation, { invitation }));
+        if (current?.status !== 'pending')
+            return { status: 'cancelled' };
+        await step.mutate(name, updateInvitation, { invitation, status });
+        return { status };
+    };
+    const pending = await step.run('read-pending', ({ query }) => query(readPendingInvitations, { user }));
+    const same = pending.find((previous) => previous.email === email);
+    // Its run sends the email again and restarts the time to live. A run that no longer answers
+    // has its invitation replaced instead.
+    const resent = same !== undefined &&
+        (await step.run('resend-pending', ({ kernel }) => kernel.execution
+            .signal(same.execution, {
+            name: invitationSignal(same.round),
+            value: { kind: 'resend' },
+        })
+            .then(() => true, () => false)));
+    if (resent) {
+        const others = pending.filter((previous) => previous !== same);
+        if (others.length > 0)
+            await retire(others);
+        return { status: 'pending' };
+    }
     const startedAt = await step.run('clock', () => Date.now());
-    const expiresAt = startedAt + INVITATION_TTL_MS;
+    let expiresAt = startedAt + INVITATION_TTL_MS;
     const { invitation } = await step.mutate('record-invitation', createInvitation, {
         user,
         execution: execution.id,
         expiresAt: new Date(expiresAt).toISOString(),
+        email,
+        replaces: pending.map((previous) => previous.id),
     });
+    if (pending.length > 0)
+        await stop(pending);
     const requestedBy = execution.initiator.caller ?? execution.initiator.principal;
     const sendEmail = async (round) => {
         try {
@@ -55,27 +104,28 @@ export const send = defineWorkflow()('Invitation.send', { errors }, async (conte
             const event = await awaitSignal(invitationSignal(round), {
                 timeoutMs: Math.max(expiresAt - now, 1),
             });
-            if (event.kind === 'timeout') {
-                await step.mutate('expire', updateInvitation, { invitation, status: 'expired' });
-                return { status: 'expired' };
-            }
+            if (event.kind === 'timeout')
+                return await close('expire', 'expired');
             if (event.value.kind === 'accepted') {
                 const { iss, sub } = event.value;
                 await step.mutate('bind-account', bindAccount, { user, iss, sub });
                 await step.mutate('accept', updateInvitation, { invitation, status: 'accepted' });
                 return { status: 'accepted' };
             }
+            // A resend is a new link from Admin, with a full time to live again.
             await sendEmail(round + 1);
+            const resentAt = await step.run(`resent-at-${round + 1}`, () => Date.now());
+            expiresAt = resentAt + INVITATION_TTL_MS;
             await step.mutate(`next-round-${round + 1}`, updateInvitation, {
                 invitation,
                 round: round + 1,
+                expiresAt: new Date(expiresAt).toISOString(),
             });
         }
     }
     catch (cause) {
         if (!cancelled(cause))
             throw cause;
-        await step.mutate('cancel', updateInvitation, { invitation, status: 'cancelled' });
-        return { status: 'cancelled' };
+        return await close('cancel', 'cancelled');
     }
 });

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

@@ -1,2 +1,2 @@
-// Seam L-SHELL-12: the legacy handler the Runtime registers.
-export { legacyAssignViews } from './legacy/index.js';
+// Seams L-SHELL-12, L-SHELL-20: the legacy handlers the Runtime registers.
+export { legacyAssignViews, legacyMigrateViewAccess } from './legacy/index.js';

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

@@ -1 +1,2 @@
 export { legacyAssignViews } from './assign-views.js';
+export { legacyMigrateViewAccess } from './migrate-view-access.js';

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

@@ -0,0 +1,29 @@
+import { defineAction } from '@astrale-os/sdk/action';
+import { legacyMoveViewAccess } from '../../../mutations/view-access/legacy/index.js';
+import { legacyGivenViewKey, legacyReadViewAccessToMove } from '../../../queries/view-access/legacy/index.js';
+/** Edges moved by one write. */
+const BATCH = 200;
+/**
+ * @deprecated Copy every Shell `view_access` Edge to the Kernel's, the one the Kernel enforces
+ * from kernel-host 1.0.0-beta.45, then delete the Shell's (L-SHELL-20). Idempotent: a View the
+ * Kernel's Edge already gives is not copied again, and a second run finds no Shell Edge. Each batch
+ * copies and deletes in one write, so a View is never given by neither Edge. Replaced by nothing:
+ * Views are given through the Kernel's Edge. Removal: Shell major (delivery step 5), once every
+ * instance has run it.
+ */
+export const legacyMigrateViewAccess = defineAction()('legacyMigrateViewAccess', async (context) => {
+    const { shell, kernel } = await context.query(legacyReadViewAccessToMove, {});
+    let copied = 0;
+    let removed = 0;
+    for (let start = 0; start < shell.length; start += BATCH) {
+        const remove = shell.slice(start, start + BATCH);
+        const copy = remove.filter((given) => !kernel.has(legacyGivenViewKey(given)));
+        const result = await context.mutate(legacyMoveViewAccess, { copy, remove });
+        if (!result.ok) {
+            throw new Error(`view_access migration stopped after ${removed} Edges: ${result.code}; run it again.`);
+        }
+        copied += copy.length;
+        removed += remove.length;
+    }
+    return { copied, removed };
+});

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/set-group-membership.js

@@ -1,6 +1,46 @@
 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',
@@ -22,17 +62,9 @@ export const setGroupMembership = defineMutation()((domain) => ({
         }
     },
     project: () => ({ ok: true }),
-    reject: (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,
-            ...('rule' in failure && failure.rule !== undefined ? { rule: failure.rule } : {}),
-            outcomeKnown: failure.outcomeKnown,
-        };
-    },
+    reject: (failure) => rejectChange({
+        outcomeKnown: failure.outcomeKnown,
+        code: failure.code,
+        ...('rule' in failure && failure.rule !== undefined ? { rule: failure.rule } : {}),
+    }),
 }));

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

@@ -1,8 +1,23 @@
 import { defineMutation } from '@astrale-os/sdk/mutation';
-/** Record a pending invitation of one account, kept by one durable run. */
+/**
+ * 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,
@@ -11,6 +26,7 @@ export const createInvitation = defineMutation()((domain) => ({
                 expiresAt: input.expiresAt,
                 execution: input.execution,
                 round: 0,
+                email: input.email,
             },
         });
         mutation.createEdge({
@@ -26,7 +42,7 @@ export const createInvitation = defineMutation()((domain) => ({
         return { invitation };
     },
 }));
-/** Change an invitation's status or its round, while it is still pending. */
+/** 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) {
@@ -42,6 +58,7 @@ export const updateInvitation = defineMutation()((domain) => ({
                 set: {
                     ...(input.status === undefined ? {} : { status: input.status }),
                     ...(input.round === undefined ? {} : { round: input.round }),
+                    ...(input.expiresAt === undefined ? {} : { expiresAt: input.expiresAt }),
                 },
             },
         });

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

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

package/dist/mutations/view-access/legacy/move-view-access.js

@@ -0,0 +1,26 @@
+import { defineMutation } from '@astrale-os/sdk/mutation';
+/**
+ * @deprecated Create Kernel `view_access` Edges and delete Shell ones in one write (L-SHELL-20).
+ * Replaced by nothing. Removal: with `legacyMigrateViewAccess`.
+ */
+export const legacyMoveViewAccess = defineMutation()((domain) => ({
+    id: 'shell.view-access.legacy-move',
+    build(input, mutation) {
+        for (const { identity, view } of input.copy) {
+            mutation.createEdge({
+                class: domain.dependencies.kernel.classes.view_access,
+                source: identity,
+                target: view,
+            });
+        }
+        for (const { identity, view } of input.remove) {
+            mutation.deleteEdge({ class: domain.classes.view_access, source: identity, target: view });
+        }
+    },
+    project: () => ({ ok: true }),
+    reject: (failure) => ({
+        ok: false,
+        code: failure.code,
+        outcomeKnown: failure.outcomeKnown,
+    }),
+}));

package/dist/mutations/view-access/set-view-access.js

@@ -5,7 +5,7 @@ export const setViewAccess = defineMutation()((domain) => ({
     build(input, mutation) {
         mutation.expect.query(input.guard);
         const edge = ({ identity, view }) => ({
-            class: domain.classes.view_access,
+            class: domain.dependencies.kernel.classes.view_access,
             source: identity,
             target: view,
         });

package/dist/queries/composition/index.js

@@ -1,2 +1,2 @@
 export { readExtensions } from './read-extensions.js';
-export { readRoleNodes } from './read-role-nodes.js';
+export { readRoleKeys, readRoleNodes } from './read-role-nodes.js';

package/dist/queries/composition/read-role-nodes.js

@@ -1,3 +1,4 @@
+import { Path } from '@astrale-os/sdk/graph/path';
 import { defineQuery, Query, queryResult, } from '@astrale-os/sdk/query';
 const CORE = 'core.';
 /** Each Core Node of a Kernel Role Class, named by its `of_domain` locator. */
@@ -22,20 +23,54 @@ export const readRoleNodes = defineQuery()((domain) => {
         },
         project(pages) {
             const byKey = new Map();
-            for (const page of pages) {
-                for (const item of queryResult.edgeItems(page, 'Shell Roles')) {
-                    if (item.edge.kind !== 'value' || item.source.kind !== 'reference')
-                        continue;
-                    if (item.target.kind !== 'value')
-                        continue;
-                    const key = item.edge.value.props[member];
-                    const owner = item.target.value.props[origin];
-                    if (typeof key !== 'string' || !key.startsWith(CORE) || typeof owner !== 'string')
-                        continue;
-                    byKey.set(`${owner}:${key.slice(CORE.length)}`, item.source.value.id);
-                }
-            }
+            for (const [id, key] of roleKeys(pages, member, origin))
+                byKey.set(key, id);
             return { byKey, ids: new Set(byKey.values()) };
         },
     };
 });
+/** Each Core Role in pages of `of_domain` Edges: its Node, and `<origin>:<Core key>`. */
+function roleKeys(pages, member, origin) {
+    const keys = new Map();
+    for (const page of pages) {
+        for (const item of queryResult.edgeItems(page, 'Shell Roles')) {
+            if (item.edge.kind !== 'value' || item.source.kind !== 'reference')
+                continue;
+            if (item.target.kind !== 'value')
+                continue;
+            const key = item.edge.value.props[member];
+            const owner = item.target.value.props[origin];
+            if (typeof key !== 'string' || !key.startsWith(CORE) || typeof owner !== 'string')
+                continue;
+            keys.set(item.source.value.id, `${owner}:${key.slice(CORE.length)}`);
+        }
+    }
+    return keys;
+}
+/**
+ * The Core Roles among some Identities, by `<origin>:<Core key>`: what one composition holds, read
+ * without the catalogue of every installed Role.
+ */
+export const readRoleKeys = defineQuery()((domain) => {
+    const kernel = domain.dependencies.kernel.classes;
+    const member = kernel.of_domain.properties.member.key;
+    const origin = kernel.Domain.properties.origin.key;
+    return {
+        id: 'shell.composition.role-keys',
+        page: { size: 256 },
+        pagination: { maximumPages: 16 },
+        build: ({ identities }) => {
+            const locator = Query.from({
+                nodes: [Path.id(identities[0]), ...identities.slice(1).map((id) => Path.id(id))],
+            })
+                .filter({ class: kernel.Role })
+                .expand({ via: [kernel.of_domain], direction: 'outgoing' });
+            return locator.select({
+                kind: 'edges',
+                binding: locator.edge,
+                projection: { edge: 'value', source: 'reference', target: 'value' },
+            });
+        },
+        project: (pages) => roleKeys(pages, member, origin),
+    };
+});

package/dist/queries/group/index.js

@@ -1,2 +1,3 @@
 export { readGroupMembership, } from './read-group-membership.js';
 export { readGroupMembershipEndpoints, } from './read-group-membership-endpoints.js';
+export { readGroupMembers, readGroupMembersEndpoints, } from './read-group-members.js';

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

@@ -1,2 +1,3 @@
 export { legacyReadMemberOfGroup } from './read-member-of-group.js';
 export { legacyReadCoreGroups } from './read-core-groups.js';
+export { legacyReadMembersOfGroup } from './read-members-of-group.js';

package/dist/queries/group/legacy/read-members-of-group.js

@@ -0,0 +1,27 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { Query, defineQuery, } from '@astrale-os/sdk/query';
+import { canonical, sources, } from '../read-group-members.js';
+/**
+ * @deprecated The legacy `member_of_group` Edges from the members to the group, in one read and
+ * kept whole as one guard (L-SHELL-8). Replaced by `readGroupMembers` (`extends_with`). Removal:
+ * Shell major (delivery step 5) after 1Pact step 4.
+ */
+export const legacyReadMembersOfGroup = defineQuery()((domain) => ({
+    id: 'shell.group.members.legacy',
+    page: { size: 256 },
+    pagination: { maximumPages: 2 },
+    build({ members, group }) {
+        const walk = Query.from({
+            nodes: [Path.id(members[0]), ...members.slice(1).map((id) => Path.id(id))],
+        }).expand({ via: [domain.classes.member_of_group], direction: 'outgoing' });
+        return walk.filter({ predicate: { kind: 'identity.equal', identity: group } }).select({
+            kind: 'edges',
+            binding: walk.edge,
+            projection: { edge: 'reference', source: 'reference', target: 'reference' },
+        });
+    },
+    project: (pages, _input, { ast, complete }) => ({
+        present: sources(pages, 'Shell legacy group members'),
+        guard: { query: ast, equals: canonical(complete) },
+    }),
+}));

package/dist/queries/group/read-group-members.js

@@ -0,0 +1,73 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { Query, defineQuery, queryResult, } from '@astrale-os/sdk/query';
+const anchors = (ids) => [Path.id(ids[0]), ...ids.slice(1).map((id) => Path.id(id))];
+/** Every member and the group, in one read whatever the number of members. */
+export const readGroupMembersEndpoints = defineQuery()(() => ({
+    id: 'shell.group.members.endpoints',
+    page: { size: 256 },
+    pagination: { maximumPages: 2 },
+    build: ({ members, group }) => Query.from({ nodes: [...anchors(members), Path.id(group)] }).select({
+        kind: 'nodes',
+        projection: { kind: 'reference' },
+    }),
+    project(pages, input, { ast, complete }) {
+        const visible = new Set(queryResult.completeNodeIds(pages, 'Shell group members'));
+        let groupClass;
+        for (const page of pages) {
+            if (page.kind !== 'nodes')
+                continue;
+            for (const item of page.nodes) {
+                if (item.kind === 'reference' && item.value.id === input.group)
+                    groupClass = item.value.class;
+            }
+        }
+        return {
+            visible,
+            ...(groupClass === undefined ? {} : { groupClass }),
+            // The Kernel takes a guard's Nodes in canonical order.
+            guard: { query: ast, equals: { ...complete, ids: [...complete.ids].sort(order) } },
+        };
+    },
+}));
+/** The `extends_with` Edges from the members to the group: their memberships (G1), in one read. */
+export const readGroupMembers = defineQuery()((domain) => ({
+    id: 'shell.group.members.read',
+    page: { size: 256 },
+    pagination: { maximumPages: 2 },
+    build({ members, group }) {
+        const walk = Query.from({ nodes: anchors(members) }).expand({
+            via: [domain.dependencies.kernel.classes.extends_with],
+            direction: 'outgoing',
+        });
+        return walk.filter({ predicate: { kind: 'identity.equal', identity: group } }).select({
+            kind: 'edges',
+            binding: walk.edge,
+            projection: { edge: 'reference', source: 'reference', target: 'reference' },
+        });
+    },
+    project: (pages, _input, { ast, complete }) => ({
+        present: sources(pages, 'Shell group members'),
+        guard: { query: ast, equals: canonical(complete) },
+    }),
+}));
+/** The members an Edge read finds, by source. */
+export function sources(pages, label) {
+    const found = new Set();
+    for (const page of pages) {
+        for (const item of queryResult.edgeItems(page, label)) {
+            if (item.source.kind === 'reference')
+                found.add(item.source.value.id);
+        }
+    }
+    return found;
+}
+const order = (left, right) => (left < right ? -1 : left > right ? 1 : 0);
+/** A guard's Edges in the Kernel's canonical order: by source, then target, then Class. */
+export function canonical(selection) {
+    if (selection.kind !== 'edge')
+        return selection;
+    const keys = [...selection.keys].sort((left, right) => order(left.source, right.source) ||
+        order(left.target, right.target) ||
+        order(left.class, right.class));
+    return { ...selection, keys };
+}

package/dist/queries/invitation/index.js

@@ -1 +1 @@
-export { readInvitation } from './read-invitation.js';
+export { readInvitation, readPendingInvitations } from './read-invitation.js';

package/dist/queries/invitation/read-invitation.js

@@ -1,5 +1,17 @@
 import { Path } from '@astrale-os/sdk/graph/path';
 import { defineQuery, Query, queryResult, } from '@astrale-os/sdk/query';
+/** An invitation Node as the methods and the run read it. */
+function toInvitation(node, keys) {
+    const props = node.props;
+    const email = props[keys.email.key];
+    return {
+        id: node.id,
+        status: String(props[keys.status.key]),
+        execution: String(props[keys.execution.key]),
+        round: Number(props[keys.round.key] ?? 0),
+        ...(typeof email === 'string' ? { email } : {}),
+    };
+}
 /** One invitation, or undefined when there is none the reader reads. */
 export const readInvitation = defineQuery()((domain) => ({
     id: 'shell.invitation.read',
@@ -13,13 +25,26 @@ export const readInvitation = defineQuery()((domain) => ({
         const node = queryResult.completeNodeValues(pages, 'Shell invitation')[0];
         if (node === undefined)
             return undefined;
-        const props = node.props;
-        const keys = domain.classes.Invitation.properties;
-        return {
-            id: node.id,
-            status: String(props[keys.status.key]),
-            execution: String(props[keys.execution.key]),
-            round: Number(props[keys.round.key] ?? 0),
-        };
+        return toInvitation(node, domain.classes.Invitation.properties);
     },
 }));
+/** The pending invitations of one account: at most one, unless recorded before that rule. */
+export const readPendingInvitations = defineQuery()((domain) => ({
+    id: 'shell.invitation.pending',
+    page: { size: 64 },
+    pagination: { maximumPages: 1 },
+    build: ({ user }) => Query.from({ nodes: [Path.id(user)] })
+        .expand({ via: [domain.classes.invitation_user], direction: 'incoming' })
+        .filter({ class: domain.classes.Invitation })
+        .filter({
+        predicate: {
+            kind: 'property.equal',
+            property: domain.classes.Invitation.properties.status.key,
+            value: 'pending',
+        },
+    })
+        .select({ kind: 'nodes', projection: { kind: 'value' } }),
+    project: (pages) => queryResult
+        .completeNodeValues(pages, 'Shell pending invitations')
+        .map((node) => toInvitation(node, domain.classes.Invitation.properties)),
+}));

package/dist/queries/role/index.js

@@ -1 +1 @@
-export { readRoleNode } from './read-role-node.js';
+export { readRoleId, readRoleNode } from './read-role-node.js';

package/dist/queries/role/read-role-node.js

@@ -11,3 +11,11 @@ export const readRoleNode = defineQuery()(() => ({
     build: ({ role }) => Query.from({ nodes: [role] }).select({ kind: 'nodes', projection: { kind: 'value' } }),
     project: (pages) => queryResult.completeNodeValues(pages, 'Shell Role').length === 1,
 }));
+/** One Role's Node, read by its Core target; nothing when it is not installed. */
+export const readRoleId = defineQuery()(() => ({
+    id: 'shell.role.id',
+    page: { size: 1 },
+    pagination: { maximumPages: 1 },
+    build: ({ role }) => Query.from({ nodes: [role] }).select({ kind: 'nodes', projection: { kind: 'reference' } }),
+    project: (pages) => queryResult.completeNodeIds(pages, 'Shell Role')[0],
+}));

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

@@ -0,0 +1 @@
+export { legacyGivenViewKey, legacyReadViewAccessToMove, } from './read-view-access-to-move.js';

package/dist/queries/view-access/legacy/read-view-access-to-move.js

@@ -0,0 +1,40 @@
+import { defineQuery, Query, queryResult, } from '@astrale-os/sdk/query';
+/**
+ * @deprecated The key `LegacyViewAccessToMove.kernel` holds for an Edge (L-SHELL-20). Replaced by
+ * nothing. Removal: with `legacyMigrateViewAccess`.
+ */
+export const legacyGivenViewKey = ({ identity, view }) => `${identity} ${view}`;
+/**
+ * @deprecated Every `view_access` Edge, the Shell's and the Kernel's, in one read (L-SHELL-20).
+ * Replaced by nothing: the Kernel's alone is written. Removal: with `legacyMigrateViewAccess`.
+ */
+export const legacyReadViewAccessToMove = defineQuery()((domain) => {
+    const shellClass = domain.classes.view_access;
+    const kernelClass = domain.dependencies.kernel.classes.view_access;
+    return {
+        id: 'shell.view-access.legacy-to-move',
+        page: { size: 1000 },
+        pagination: { maximumPages: 103 },
+        build: () => Query.from({ edges: [shellClass, kernelClass] }).select({
+            kind: 'edges',
+            projection: { edge: 'value', source: 'reference', target: 'reference' },
+        }),
+        project(pages) {
+            const shell = [];
+            const kernel = new Set();
+            for (const page of pages) {
+                for (const item of queryResult.edgeItems(page, 'Shell view access to move')) {
+                    if (item.edge.kind !== 'value')
+                        continue;
+                    const { class: key, source, target } = item.edge.value;
+                    const given = { identity: source, view: target };
+                    if (key === shellClass.key)
+                        shell.push(given);
+                    else if (key === kernelClass.key)
+                        kernel.add(legacyGivenViewKey(given));
+                }
+            }
+            return { shell, kernel };
+        },
+    };
+});

package/dist/queries/view-access/read-view-access.js

@@ -7,7 +7,7 @@ export const readViewAccess = defineQuery()((domain) => ({
         const held = Query.from({
             nodes: [Path.id(identities[0]), ...identities.slice(1).map((identity) => Path.id(identity))],
         }).expand({
-            via: [domain.classes.view_access],
+            via: [domain.dependencies.kernel.classes.view_access],
             direction: 'outgoing',
         });
         return held.select({