@astrale-domains/shell 0.1.5 → 0.1.7

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/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,38 @@
 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';
+/** 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')
+            failure.code !== 'MUTATION_CONFLICT' &&
+            failure.code !== 'MUTATION_POST_STATE_INVALID')
             throw failure;
-        return { ok: false, code: failure.code, outcomeKnown: failure.outcomeKnown };
+        return {
+            ok: false,
+            code: failure.code,
+            ...('rule' in failure && failure.rule !== undefined ? { rule: failure.rule } : {}),
+            outcomeKnown: failure.outcomeKnown,
+        };
     },
 }));

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,62 @@
+import { defineMutation } from '@astrale-os/sdk/mutation';
+/** Record a pending invitation of one account, kept by one durable run. */
+export const createInvitation = defineMutation()((domain) => ({
+    id: 'shell.invitation.create',
+    build(input, mutation) {
+        const invitation = mutation.createNode({
+            as: 'invitation',
+            class: domain.classes.Invitation,
+            props: {
+                status: 'pending',
+                expiresAt: input.expiresAt,
+                execution: input.execution,
+                round: 0,
+            },
+        });
+        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, 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 }),
+                },
+            },
+        });
+    },
+    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 = {

package/dist/providers/admin-enrollment/create-admin-enrollment-provider.js

@@ -1,8 +1,9 @@
 import { TransportError } from '@astrale-os/sdk/client';
 import { defineProvider } from '@astrale-os/sdk/integration';
 import { z } from 'zod';
-import { enrollment, InvitationRequestFailure } from '../../integrations/user-invitation/index.js';
+import { enrollment, InvitationRequestFailure, } from '../../integrations/user-invitation/index.js';
 import { decodeAdminInvitationResponse } from './decode-admin-invitation-response.js';
+import { legacySendWithoutProfile } from './legacy/index.js';
 import { readReply } from './read-enrollment-response.js';
 // Environment is a representation boundary, unlike already-admitted handler input.
 const configuration = z.object({ ENROLLMENT_INGRESS_URL: z.string().url() });
@@ -33,7 +34,7 @@ export function enrollmentProvider(environment) {
             }
             // No automatic HTTP retry. A timeout after send has an unknown effect.
             const signal = AbortSignal.any([execution.signal, AbortSignal.timeout(remaining)]);
-            const response = await fetch(audience, {
+            const send = (body) => fetch(audience, {
                 method: 'POST',
                 // Workers reject redirect:error before sending. Manual preserves the refusal:
                 // every 3xx is rejected below, without forwarding the proof to its Location.
@@ -44,7 +45,7 @@ export function enrollmentProvider(environment) {
                     Accept: 'application/json',
                     'Idempotency-Key': input.requestId,
                 },
-                body: JSON.stringify(input),
+                body: JSON.stringify(body),
                 signal,
             }).catch((cause) => {
                 if (!(cause instanceof TypeError) && !(cause instanceof DOMException))
@@ -54,6 +55,8 @@ export function enrollmentProvider(environment) {
                     delivery: 'unknown',
                 });
             });
+            // Seam L-SHELL-15: an Admin older than `profile` refuses the field; send it again without.
+            const response = await legacySendWithoutProfile(input, send);
             if (!response.ok) {
                 await response.body?.cancel();
                 if (response.status === 409)

package/dist/providers/admin-enrollment/legacy/index.js

@@ -0,0 +1 @@
+export { legacySendWithoutProfile } from './send-without-profile.js';

package/dist/providers/admin-enrollment/legacy/send-without-profile.js

@@ -0,0 +1,16 @@
+/**
+ * @deprecated Admin before profiles validates its invitation request strictly and refuses the
+ * `profile` field with 400: the request is sent once more without it, which Admin then admits
+ * (L-SHELL-15). A first 400 has no effect, so resending under the same idempotency key is safe.
+ * Replaced by one request carrying `profile`. Removal: Shell major (delivery step 5), once every
+ * Admin deployment admits `profile` (Admin delivery step 2).
+ */
+export async function legacySendWithoutProfile(request, send) {
+    const response = await send(request);
+    if (request.profile === undefined || (response.status !== 400 && response.status !== 422)) {
+        return response;
+    }
+    await response.body?.cancel();
+    const { profile: _profile, ...legacy } = request;
+    return send(legacy);
+}

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

@@ -0,0 +1 @@
+export { legacyReadInstalledEntrypoints } from './read-installed-entrypoints.js';

package/dist/queries/application/legacy/read-installed-entrypoints.js

@@ -0,0 +1,47 @@
+import { defineQuery, Query, queryResult, } from '@astrale-os/sdk/query';
+const VIEW_MEMBER = /^view\.([A-Za-z][A-Za-z0-9_]*)$/u;
+/**
+ * @deprecated The catalogue `listEntrypoints` answers (L-SHELL-11). Replaced by the visitor's own
+ * Query (V2). Removal: Shell major (delivery step 5) after 1Pact step 4.
+ *
+ * Every installed Domain entrypoint this authority can read, in origin order. The `of_domain`
+ * locator of a View that has an outgoing `entrypoint` Edge names that View (`view.<name>`), and its
+ * target is the Domain, whose Node carries the origin and the display name.
+ */
+export const legacyReadInstalledEntrypoints = defineQuery()((domain) => {
+    const kernel = domain.dependencies.kernel.classes;
+    return {
+        id: 'shell.application.entrypoints',
+        page: { size: 200 },
+        pagination: { maximumPages: 50 },
+        build: () => {
+            const located = Query.from({ edges: [kernel.of_domain] });
+            return located
+                .expand({ from: located.source, via: [kernel.entrypoint], direction: 'outgoing' })
+                .select({
+                kind: 'edges',
+                binding: located.edge,
+                projection: { edge: 'value', source: 'reference', target: 'value' },
+            });
+        },
+        project(pages) {
+            const entries = [];
+            for (const page of pages) {
+                for (const item of queryResult.edgeItems(page, 'Installed entrypoints')) {
+                    if (item.edge.kind !== 'value' || item.target.kind !== 'value') {
+                        throw new TypeError('Installed entrypoint is not a complete value.');
+                    }
+                    const member = VIEW_MEMBER.exec(String(item.edge.value.props[kernel.of_domain.properties.member.key]));
+                    const props = item.target.value.props;
+                    const origin = props[kernel.Domain.properties.origin.key];
+                    const name = props[kernel.Domain.properties.name.key];
+                    if (member === null || typeof origin !== 'string' || typeof name !== 'string') {
+                        throw new TypeError('Installed entrypoint has no View, origin, or name.');
+                    }
+                    entries.push({ origin, name, view: `${origin}:view.${member[1]}` });
+                }
+            }
+            return entries.sort((left, right) => left.origin.localeCompare(right.origin));
+        },
+    };
+});

package/dist/queries/composition/index.js

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

package/dist/queries/composition/read-extensions.js

@@ -0,0 +1,34 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { defineQuery, Query, queryResult, } from '@astrale-os/sdk/query';
+/** The `extends_with` Edges at one frontier of a composition walk, read with Shell's authority. */
+export const readExtensions = defineQuery()((domain) => ({
+    id: 'shell.composition.extensions',
+    page: { size: 256 },
+    pagination: { maximumPages: 16 },
+    build({ identities, direction }) {
+        const walk = Query.from({
+            nodes: [Path.id(identities[0]), ...identities.slice(1).map((id) => Path.id(id))],
+        }).expand({ via: [domain.dependencies.kernel.classes.extends_with], direction });
+        return walk.select({
+            kind: 'edges',
+            binding: walk.edge,
+            projection: { edge: 'reference', source: 'reference', target: 'reference' },
+        });
+    },
+    project(pages) {
+        const extensions = [];
+        for (const page of pages) {
+            for (const item of queryResult.edgeItems(page, 'Shell composition')) {
+                if (item.source.kind !== 'reference' || item.target.kind !== 'reference')
+                    continue;
+                extensions.push({
+                    source: item.source.value.id,
+                    target: item.target.value.id,
+                    sourceClass: item.source.value.class,
+                    targetClass: item.target.value.class,
+                });
+            }
+        }
+        return extensions;
+    },
+}));