@astrale-domains/shell 0.1.0-beta.12 → 0.1.0-beta.14

package/README.md

@@ -1,71 +1,92 @@
 # Shell Domain
 
-Shell is the minimal Kernel-native application plane. Its durable model is one `User` interface,
-the concrete `User`, `Group`, `Space`, and `Application` Node Classes, eight relationships, five
-Policies, two Functions, seven Methods, five Kernel View declarations, and four deterministic Core
-nodes.
+Shell is the minimal Kernel-native application plane. Its durable model is the concrete `User`,
+`Group`, and `Space` Node Classes, five relationships, four Policies, two Functions, six Methods,
+four Kernel View declarations, and three deterministic Core nodes.
 
-The `ensureUser` Function is the Shell-owned identity genesis boundary. It idempotently provisions an
-externally identified `User`, their personal `Space`, and both ownership/default relationships under
-the installed Shell Domain's authority. `ensureAdministrator` idempotently assigns one existing User
-to Shell's administrator Group. Both keep product mutation under Shell authority while allowing an
-authenticated genesis operator to request the transition.
+Identity registration and Shell business setup are separate boundaries. A real external user first
+creates a local key and self-provisions that key as the exact Shell `User` Class. The CLI journey is:
+
+```sh
+astrale identity create alice
+astrale identity register alice \
+  --class /:shell.astrale.ai:class.User \
+  --props '{"shell.astrale.ai:class.User.property.displayName":"Alice"}' \
+  --as <root> -i <instance>
+```
+
+Under the current public contract, Root submits the self-proven registration for each Shell User;
+it does not author that User's Shell memberships or Space facts. Root calls `setupAdmin` only to
+converge the first administrator, using the exact registered issuer and subject returned by
+`identity register`. After that, an authenticated Shell administrator calls `setupMember` or
+`setupAdmin` for subsequent registered Users. Both setup Functions are authorized by
+`maySetupUsers` against membership in the Core Administrators Group.
+They converge the User profile, personal Space, ownership/default facts, Members membership, and—only
+for `setupAdmin`—Administrators membership. They do not create credentials, grant humans dynamic
+`can_*` authority, infer identity from a local CLI name, or replace self-proven registration.
 
 The Methods are:
 
-- Group: `assignUser`, `unassignUser`;
-- Space: `addUser`, `removeUser`, `setDefault`; and
-- Application: `install`, `uninstall`.
+- User: `resolveHome`;
+- Group: `assignUser`, `unassignUser`; and
+- Space: `addUser`, `removeUser`, `setDefault`.
 
-Installation authors the `admin`, `member`, `default-space`, and `shell` Core. An authenticated genesis
-operator may invoke `ensureUser`, but cannot mutate Shell Classes directly. The remote handler performs
-the atomic identity provisioning as Shell, then callers assign the User explicitly to a Group. Shell
-infers no authority from email, claims, path spelling, or creation order.
+Installation authors the `admin`, `member`, and `default-space` Core nodes. Shell infers no authority
+from email, claims, path spelling, creation order, or a successful handler-local boolean.
 
 ## Source ownership
 
 - `schema/` owns the complete Domain contract, public Method values, Policies, relationships, DSL
   Views, and Core graph;
-- `rules/` owns synchronous classifications, decisions, normalization, and result projection;
-- `queries/` owns canonical single and composite graph observations plus explicit bounded continuation
-  pagination when a business observation requires the complete set;
-- `mutations/` owns canonical atomic graph changes and their expected rejection evidence;
-- `workflows/` owns replay-shaped multi-step business journeys and unknown-outcome recovery;
-- `functions/` binds the Function and each Method to a rule, workflow, or direct operation;
-- `utils/` owns only the shared graph-endpoint and bounded-query mechanics used by independent
-  submodules; and
-- root `tests/` owns cross-layer and system evidence, while each semantic submodule owns focused
-  evidence in `__tests__/`.
+- `queries/` owns canonical graph observations through the invocation-bound Query executor;
+- `mutations/` owns canonical graph changes and exact preconditions;
+- `actions/` owns the single-operation `User.resolveHome` implementation;
+- `workflows/` owns setup, Group membership, and Space access/default journeys plus
+  unknown-outcome observation; and
+- each semantic owner keeps focused evidence in its own `__tests__/` directory, while root tests
+  remain reserved for cross-layer or physical evidence.
 
 No current responsibility earns a `states/`, `capabilities/`, `integrations/`, `migrations/`,
-`views/`, `ui/`, or root `scripts/` source layer. DSL View declarations remain in Schema; a future
-frontend projection or UI must establish its own concrete responsibility before adding those layers.
+`views/`, or `ui/` source layer. DSL View declarations remain in Schema; a future frontend
+projection or UI must establish its own concrete responsibility before adding those layers.
 
-Shell never re-declares shared metadata properties. `Group` and `Space` currently name `K.Named`
-and `K.Descriptable` in their `implements` lists because the current DSL makes only `K.Node`
-intrinsic and Core-property admission otherwise rejects `name` and `description`. Removing those
-interface references awaits the recorded Kernel authoring-default decision; no timestamps are
-authored by Shell.
+Shell never re-declares shared metadata properties. `Group` and `Space` name `K.Named` and
+`K.Descriptable` in their `implements` lists because those Kernel Classes own the admitted
+`name` and `description` properties; no timestamps are authored by Shell.
 
 ## Execution and evidence
 
-`ShellDomain` is the complete remote product implementation. Its exact handler map proves that the
-genesis Functions and all seven Methods are served from the same immutable publication. The handlers use
-the SDK's canonical Auth, Query, Mutation, Result, Workflow, and Step contracts. `ensureUser` relies on
-the Kernel provision operation's stable idempotency key; the SDK's current inline Step runner does not
-claim process-restart replay on its own.
+`application.ts` and `runtime.ts` form the complete remote product implementation. Runtime admission
+is exhaustive: `User.resolveHome` is one Action, and both setup Functions plus all five mutating
+Methods are Workflows. They use the SDK's canonical Auth, Query, Mutation, Result, Workflow, and Step
+contracts. Named Workflow steps describe semantic operations but do not claim process-restart
+durability, exactly-once execution, compensation, or crash recovery.
 
 The executable contract lives in Shell's semantic source, public facades, and tests. Product
 decisions, journeys, legacy disposition, dependency gates, and qualification evidence live in
 [`.history/`](.history/). Product Domains intentionally have no `.spec/` tree; Kernel authoring
 values come through semantic `@astrale-os/sdk/*` facades.
 
-Domain authors import the schema facade from `@astrale-domains/shell`. The public package is the
-schema contract only. Shell's independently released Worker is built from this repository's local
-application descriptor and runtime entrypoint, so consumers never install remote implementation
-code to use the Domain.
+Domain authors import the schema facade from `@astrale-domains/shell`. Worker deployments import the
+application descriptor from `@astrale-domains/shell/application` and the runtime entrypoint from
+`@astrale-domains/shell/runtime`, so bundling the remote runtime does not traverse the build-only
+schema facade.
+
+### Publication boundary
+
+`@astrale-domains/shell` is an executable platform package and a deliberate exception to the normal
+Domain publication product. It publishes the remote Shell application and runtime needed by platform
+Worker deployments through the explicit `./application` and `./runtime` subpaths, while its root remains
+Schema-only. Its build therefore compiles the explicit roots in `tsconfig.package.json` and applies
+Shell-owned checks to the emitted platform closure. Tarball qualification then verifies the exact
+exports, isolated entrypoints, absence of source maps, and an install using only public npm
+dependencies.
+
+The generic `astrale-domain package` command remains Schema-only and exposes only the Domain root plus
+package metadata. This Shell exception must not be copied to ordinary product Domains or used to
+weaken that SDK contract. Deployment consumers must use the explicit executable subpaths so a linked
+schema import cannot traverse Shell's private application or runtime implementation.
 
-The source, deterministic Knowledge linter, TypeScript package, unit/cross-layer tests, and remote Shell
-contract are qualified locally. Installed-instance, released-package, browser, and live
-credential journeys are separate evidence levels and are not claimed here. Shell does not broker
-authentication tokens; standard Domain token exchange is owned by Protocol, Server, and SDK.
+Source, package, and deterministic test qualification remain distinct from installed-instance,
+released-package, browser, and live-credential evidence. Shell does not broker authentication
+tokens; standard Domain token exchange is owned by Protocol, Server, and SDK.

package/dist/actions/index.d.ts

@@ -0,0 +1 @@
+export * from './user/index.js';

package/dist/actions/index.js

@@ -0,0 +1 @@
+export * from './user/index.js';

package/dist/actions/user/index.d.ts

@@ -0,0 +1 @@
+export { resolveHomeAction } from './resolve-home.js';

package/dist/actions/user/index.js

@@ -0,0 +1 @@
+export { resolveHomeAction } from './resolve-home.js';

package/dist/actions/user/resolve-home.d.ts

@@ -0,0 +1,3 @@
+import { type ActionDefinition } from '@astrale-os/sdk/action';
+import type { ShellSchema } from '#schema';
+export declare const resolveHomeAction: ActionDefinition<typeof ShellSchema, 'User.resolveHome'>;

package/dist/actions/user/resolve-home.js

@@ -0,0 +1,19 @@
+import { defineAction } from '@astrale-os/sdk/action';
+import { InvocationError } from '@astrale-os/sdk/execution';
+import { Path } from '@astrale-os/sdk/graph/path';
+import { observeHome } from '#queries/user';
+export const resolveHomeAction = defineAction()('User.resolveHome', async ({ domain, query, self }) => {
+    const observed = await query(observeHome, Path.id(self).raw);
+    if (observed.spaces.length > 1) {
+        throw new InvocationError('CONFLICT', 'The Shell User has more than one default Space.', {
+            reason: { code: 'MULTIPLE_DEFAULT_SPACES', details: {} },
+        });
+    }
+    const home = observed.spaces[0];
+    if (home !== undefined && home.class !== domain.classes.Space.key) {
+        throw new InvocationError('CONFLICT', 'The Shell User default target is not a Shell Space.', {
+            reason: { code: 'DEFAULT_SPACE_CLASS_CONFLICT', details: {} },
+        });
+    }
+    return Object.freeze({ userId: self, personalSpaceId: home?.id ?? null });
+});

package/dist/application.d.ts

@@ -0,0 +1,6 @@
+import { type Application, type Frontend, type Requirements } from '@astrale-os/sdk/application';
+import runtime from './runtime.js';
+import { ShellSchema } from './schema/index.js';
+export declare const frontend: Frontend<typeof ShellSchema>;
+export declare const application: Application<typeof ShellSchema, typeof runtime, typeof frontend, undefined, Requirements>;
+export default application;

package/dist/application.js

@@ -0,0 +1,30 @@
+import { defineApplication, defineFrontend, external, requirements, } from '@astrale-os/sdk/application';
+import { K } from '@astrale-os/sdk/schema';
+import runtime from './runtime.js';
+import { ShellSchema } from './schema/index.js';
+export const frontend = defineFrontend({
+    schema: ShellSchema,
+    source: external('https://app.astrale.ai'),
+    routes: {
+        group: '/groups',
+        home: '/',
+        space: '/spaces',
+        user: '/users',
+    },
+    entrypoint: 'home',
+});
+const administration = requirements({
+    callables: [
+        K.classes.Identity.static.methods.whois,
+        K.functions.provision,
+        K.functions.query,
+        K.functions.mutate,
+    ],
+});
+export const application = defineApplication({
+    schema: ShellSchema,
+    runtime,
+    frontend,
+    requirements: administration,
+});
+export default application;

package/dist/entrypoints/application.d.ts

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

package/dist/entrypoints/application.js

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

package/dist/entrypoints/runtime.d.ts

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

package/dist/entrypoints/runtime.js

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

package/dist/index.d.ts

@@ -0,0 +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/index.js';

package/dist/index.js

@@ -0,0 +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/index.js';

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

@@ -0,0 +1 @@
+export { changeGroupMembership, type GroupMembershipChange, type GroupMembershipChangeResult, } from './membership.js';

package/dist/mutations/group/index.js

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

package/dist/mutations/group/membership.d.ts

@@ -0,0 +1,19 @@
+import type { NodeId } from '@astrale-os/sdk/graph/node';
+import type { QueryPrecondition } from '@astrale-os/sdk/mutation';
+import type { QueryNodeAST } from '@astrale-os/sdk/query';
+import { type Mutation } from '@astrale-os/sdk/mutation';
+import type { Shell } from '#schema';
+export interface GroupMembershipChange {
+    readonly user: string;
+    readonly group: NodeId;
+    readonly present: boolean;
+    readonly guard: QueryPrecondition<QueryNodeAST>;
+}
+export type GroupMembershipChangeResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly code: string;
+    readonly outcomeKnown: boolean;
+};
+export declare const changeGroupMembership: Mutation<Shell, GroupMembershipChange, GroupMembershipChangeResult>;

package/dist/mutations/group/membership.js

@@ -0,0 +1,19 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { defineMutation } from '@astrale-os/sdk/mutation';
+export const changeGroupMembership = defineMutation()((domain) => ({
+    id: 'shell.group.membership',
+    build(change, mutation) {
+        mutation.expect.query(change.guard);
+        const edge = {
+            class: domain.classes.member_of_group,
+            source: Path.parse(change.user),
+            target: Path.id(change.group),
+        };
+        if (change.present)
+            mutation.createEdge(edge);
+        else
+            mutation.deleteEdge(edge);
+    },
+    project: () => Object.freeze({ ok: true }),
+    reject: (failure) => Object.freeze({ ok: false, code: failure.code, outcomeKnown: failure.outcomeKnown }),
+}));

package/dist/mutations/space/access.d.ts

@@ -0,0 +1,25 @@
+import type { NodeId } from '@astrale-os/sdk/graph/node';
+import type { QueryPrecondition } from '@astrale-os/sdk/mutation';
+import type { QueryNodeAST } from '@astrale-os/sdk/query';
+import { type Mutation } from '@astrale-os/sdk/mutation';
+import type { Shell } from '#schema';
+export interface SpaceAccessChange {
+    readonly user: string;
+    readonly space: NodeId;
+    readonly addMember: boolean;
+    readonly removeMember: boolean;
+    readonly addAdmin: boolean;
+    readonly removeAdmin: boolean;
+    readonly guards: {
+        readonly member: QueryPrecondition<QueryNodeAST>;
+        readonly admin: QueryPrecondition<QueryNodeAST>;
+    };
+}
+export type SpaceAccessChangeResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly code: string;
+    readonly outcomeKnown: boolean;
+};
+export declare const changeSpaceAccess: Mutation<Shell, SpaceAccessChange, SpaceAccessChangeResult>;

package/dist/mutations/space/access.js

@@ -0,0 +1,23 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { defineMutation } from '@astrale-os/sdk/mutation';
+export const changeSpaceAccess = defineMutation()((domain) => ({
+    id: 'shell.space.access',
+    build(change, mutation) {
+        mutation.expect.query(change.guards.member);
+        mutation.expect.query(change.guards.admin);
+        const source = Path.parse(change.user);
+        const target = Path.id(change.space);
+        const member = { class: domain.classes.member_of_space, source, target };
+        const admin = { class: domain.classes.administers_space, source, target };
+        if (change.removeMember)
+            mutation.deleteEdge(member);
+        if (change.removeAdmin)
+            mutation.deleteEdge(admin);
+        if (change.addMember)
+            mutation.createEdge(member);
+        if (change.addAdmin)
+            mutation.createEdge(admin);
+    },
+    project: () => Object.freeze({ ok: true }),
+    reject: (failure) => Object.freeze({ ok: false, code: failure.code, outcomeKnown: failure.outcomeKnown }),
+}));

package/dist/mutations/space/default.d.ts

@@ -0,0 +1,19 @@
+import type { NodeId } from '@astrale-os/sdk/graph/node';
+import type { QueryPrecondition } from '@astrale-os/sdk/mutation';
+import type { QueryNodeAST } from '@astrale-os/sdk/query';
+import { type Mutation } from '@astrale-os/sdk/mutation';
+import type { Shell } from '#schema';
+export interface DefaultSpaceChange {
+    readonly user: NodeId;
+    readonly previous?: NodeId;
+    readonly next: NodeId;
+    readonly guard: QueryPrecondition<QueryNodeAST>;
+}
+export type DefaultSpaceChangeResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly code: string;
+    readonly outcomeKnown: boolean;
+};
+export declare const changeDefaultSpace: Mutation<Shell, DefaultSpaceChange, DefaultSpaceChangeResult>;

package/dist/mutations/space/default.js

@@ -0,0 +1,23 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { defineMutation } from '@astrale-os/sdk/mutation';
+export const changeDefaultSpace = defineMutation()((domain) => ({
+    id: 'shell.space.default',
+    build(change, mutation) {
+        mutation.expect.query(change.guard);
+        const source = Path.id(change.user);
+        if (change.previous !== undefined) {
+            mutation.deleteEdge({
+                class: domain.classes.default_space,
+                source,
+                target: Path.id(change.previous),
+            });
+        }
+        mutation.createEdge({
+            class: domain.classes.default_space,
+            source,
+            target: Path.id(change.next),
+        });
+    },
+    project: () => Object.freeze({ ok: true }),
+    reject: (failure) => Object.freeze({ ok: false, code: failure.code, outcomeKnown: failure.outcomeKnown }),
+}));

package/dist/mutations/space/index.d.ts

@@ -0,0 +1,2 @@
+export { changeSpaceAccess, type SpaceAccessChange, type SpaceAccessChangeResult, } from './access.js';
+export { changeDefaultSpace, type DefaultSpaceChange, type DefaultSpaceChangeResult, } from './default.js';

package/dist/mutations/space/index.js

@@ -0,0 +1,2 @@
+export { changeSpaceAccess, } from './access.js';
+export { changeDefaultSpace, } from './default.js';

package/dist/mutations/user/index.d.ts

@@ -0,0 +1 @@
+export { repairUser, type UserRepair, type UserRepairResult } from './repair.js';

package/dist/mutations/user/index.js

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

package/dist/mutations/user/repair.d.ts

@@ -0,0 +1,37 @@
+import type { NodeId } from '@astrale-os/sdk/graph/node';
+import type { QueryPrecondition } from '@astrale-os/sdk/mutation';
+import type { QueryNodeAST } from '@astrale-os/sdk/query';
+import { type Mutation } from '@astrale-os/sdk/mutation';
+import type { Shell } from '#schema';
+export interface UserRepair {
+    readonly userId: NodeId;
+    readonly currentDisplayName?: string;
+    readonly displayName?: string;
+    readonly home: {
+        readonly kind: 'existing';
+        readonly id: NodeId;
+        readonly currentName: string;
+        readonly name?: string;
+    } | {
+        readonly kind: 'create';
+        readonly name: string;
+    };
+    readonly addDefault: boolean;
+    readonly addOwnership: boolean;
+    readonly addMember: boolean;
+    readonly addAdmin: boolean;
+    readonly guards: {
+        readonly home: QueryPrecondition<QueryNodeAST>;
+        readonly ownedSpaces: QueryPrecondition<QueryNodeAST>;
+        readonly groups: QueryPrecondition<QueryNodeAST>;
+    };
+}
+export type UserRepairResult = {
+    readonly ok: true;
+    readonly personalSpaceId: NodeId;
+} | {
+    readonly ok: false;
+    readonly code: string;
+    readonly outcomeKnown: boolean;
+};
+export declare const repairUser: Mutation<Shell, UserRepair, UserRepairResult>;

package/dist/mutations/user/repair.js

@@ -0,0 +1,83 @@
+import { LocalBinding } from '@astrale-os/sdk/graph';
+import { Path } from '@astrale-os/sdk/graph/path';
+import { defineMutation } from '@astrale-os/sdk/mutation';
+const personalSpace = LocalBinding('personalSpace');
+export const repairUser = defineMutation()((domain) => ({
+    id: 'shell.user.repair',
+    build(repair, mutation) {
+        mutation.expect.query(repair.guards.home);
+        mutation.expect.query(repair.guards.ownedSpaces);
+        mutation.expect.query(repair.guards.groups);
+        mutation.expect.node({
+            node: Path.id(repair.userId),
+            class: domain.classes.User,
+            props: repair.currentDisplayName === undefined
+                ? { absent: ['displayName'] }
+                : { equals: { displayName: repair.currentDisplayName } },
+        });
+        if (repair.displayName !== undefined) {
+            mutation.updateNode({
+                node: Path.id(repair.userId),
+                class: domain.classes.User,
+                props: { set: { displayName: repair.displayName } },
+            });
+        }
+        const home = repair.home.kind === 'create'
+            ? mutation.createNode({
+                as: personalSpace,
+                class: domain.classes.Space,
+                props: { name: repair.home.name },
+            })
+            : Path.id(repair.home.id);
+        if (repair.home.kind === 'existing' && repair.home.name !== undefined) {
+            mutation.expect.node({
+                node: Path.id(repair.home.id),
+                class: domain.classes.Space,
+                props: { equals: { name: repair.home.currentName } },
+            });
+            mutation.updateNode({
+                node: Path.id(repair.home.id),
+                class: domain.classes.Space,
+                props: { set: { name: repair.home.name } },
+            });
+        }
+        if (repair.addOwnership) {
+            mutation.createEdge({
+                class: domain.classes.owns_space,
+                source: Path.id(repair.userId),
+                target: home,
+            });
+        }
+        if (repair.addDefault) {
+            mutation.createEdge({
+                class: domain.classes.default_space,
+                source: Path.id(repair.userId),
+                target: home,
+            });
+        }
+        if (repair.addMember) {
+            mutation.createEdge({
+                class: domain.classes.member_of_group,
+                source: Path.id(repair.userId),
+                target: Path.project(domain.core.nodes.member.ref),
+            });
+        }
+        if (repair.addAdmin) {
+            mutation.createEdge({
+                class: domain.classes.member_of_group,
+                source: Path.id(repair.userId),
+                target: Path.project(domain.core.nodes.admin.ref),
+            });
+        }
+    },
+    project(result, repair) {
+        const personalSpaceId = repair.home.kind === 'existing' ? repair.home.id : result.createdNodes[personalSpace];
+        if (personalSpaceId === undefined) {
+            throw new TypeError('Shell User repair omitted its created personal Space identity.');
+        }
+        return Object.freeze({ ok: true, personalSpaceId });
+    },
+    reject(failure) {
+        return Object.freeze({ ok: false, code: failure.code, outcomeKnown: failure.outcomeKnown });
+    },
+}));

package/dist/queries/space/access.d.ts

@@ -0,0 +1,9 @@
+import { type CompositeQueryDefinition } from '@astrale-os/sdk/query';
+import type { Shell } from '#schema';
+import { type AdminSpacesObservation } from './admin.js';
+import { type MemberSpacesObservation } from './member.js';
+export interface DirectSpaceAccessObservation {
+    readonly admin: AdminSpacesObservation;
+    readonly member: MemberSpacesObservation;
+}
+export declare const observeDirectSpaceAccess: CompositeQueryDefinition<Shell, string, DirectSpaceAccessObservation>;

package/dist/queries/space/access.js

@@ -0,0 +1,12 @@
+import { defineCompositeQuery } from '@astrale-os/sdk/query';
+import { observeAdminSpaces } from './admin.js';
+import { observeMemberSpaces } from './member.js';
+export const observeDirectSpaceAccess = defineCompositeQuery()(() => ({
+    id: 'shell.space.direct-access',
+    compose({ combine, query }, user) {
+        return combine({
+            admin: query('admin', observeAdminSpaces, user),
+            member: query('member', observeMemberSpaces, user),
+        });
+    },
+}));

package/dist/queries/space/admin.d.ts

@@ -0,0 +1,9 @@
+import type { Node } from '@astrale-os/sdk/graph/node';
+import type { QueryPrecondition } from '@astrale-os/sdk/mutation';
+import type { QueryNodeAST, SingleQueryDefinition } from '@astrale-os/sdk/query';
+import type { Shell } from '#schema';
+export interface AdminSpacesObservation {
+    readonly spaces: readonly Node[];
+    readonly guard: QueryPrecondition<QueryNodeAST>;
+}
+export declare const observeAdminSpaces: SingleQueryDefinition<Shell, string, AdminSpacesObservation>;

package/dist/queries/space/admin.js

@@ -0,0 +1,20 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { Query, defineQuery, queryResult } from '@astrale-os/sdk/query';
+export const observeAdminSpaces = defineQuery()((domain) => ({
+    id: 'shell.space.admin-access',
+    build(user) {
+        const source = Query.from({ nodes: [Path.parse(user)] });
+        const spaces = source.expand({
+            via: [domain.classes.administers_space],
+            direction: 'outgoing',
+        });
+        return spaces.select({ kind: 'nodes', binding: spaces.node, projection: { kind: 'value' } });
+    },
+    pagination: { maximumPages: 64 },
+    project(pages, _user, { ast, complete }) {
+        return Object.freeze({
+            spaces: queryResult.completeNodeValues(pages, 'direct administered Spaces'),
+            guard: Object.freeze({ query: ast, equals: complete }),
+        });
+    },
+}));

package/dist/queries/space/index.d.ts

@@ -0,0 +1,3 @@
+export { observeAdminSpaces, type AdminSpacesObservation } from './admin.js';
+export { observeDirectSpaceAccess, type DirectSpaceAccessObservation } from './access.js';
+export { observeMemberSpaces, type MemberSpacesObservation } from './member.js';

package/dist/queries/space/index.js

@@ -0,0 +1,3 @@
+export { observeAdminSpaces } from './admin.js';
+export { observeDirectSpaceAccess } from './access.js';
+export { observeMemberSpaces } from './member.js';

package/dist/queries/space/member.d.ts

@@ -0,0 +1,9 @@
+import type { Node } from '@astrale-os/sdk/graph/node';
+import type { QueryPrecondition } from '@astrale-os/sdk/mutation';
+import type { QueryNodeAST, SingleQueryDefinition } from '@astrale-os/sdk/query';
+import type { Shell } from '#schema';
+export interface MemberSpacesObservation {
+    readonly spaces: readonly Node[];
+    readonly guard: QueryPrecondition<QueryNodeAST>;
+}
+export declare const observeMemberSpaces: SingleQueryDefinition<Shell, string, MemberSpacesObservation>;

package/dist/queries/space/member.js

@@ -0,0 +1,17 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { Query, defineQuery, queryResult } from '@astrale-os/sdk/query';
+export const observeMemberSpaces = defineQuery()((domain) => ({
+    id: 'shell.space.member-access',
+    build(user) {
+        const source = Query.from({ nodes: [Path.parse(user)] });
+        const spaces = source.expand({ via: [domain.classes.member_of_space], direction: 'outgoing' });
+        return spaces.select({ kind: 'nodes', binding: spaces.node, projection: { kind: 'value' } });
+    },
+    pagination: { maximumPages: 64 },
+    project(pages, _user, { ast, complete }) {
+        return Object.freeze({
+            spaces: queryResult.completeNodeValues(pages, 'direct member Spaces'),
+            guard: Object.freeze({ query: ast, equals: complete }),
+        });
+    },
+}));

package/dist/queries/user/groups.d.ts

@@ -0,0 +1,9 @@
+import type { Node } from '@astrale-os/sdk/graph/node';
+import type { QueryPrecondition } from '@astrale-os/sdk/mutation';
+import type { QueryNodeAST, SingleQueryDefinition } from '@astrale-os/sdk/query';
+import type { Shell } from '#schema';
+export interface UserGroupsObservation {
+    readonly groups: readonly Node[];
+    readonly guard: QueryPrecondition<QueryNodeAST>;
+}
+export declare const observeUserGroups: SingleQueryDefinition<Shell, string, UserGroupsObservation>;