@astrale-domains/shell 0.1.0-beta.9 → 0.1.2

package/README.md

@@ -1,66 +1,266 @@
 # 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.
-
-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.
-
-The Methods are:
-
-- Group: `assignUser`, `unassignUser`;
-- Space: `addUser`, `removeUser`, `setDefault`; and
-- Application: `install`, `uninstall`.
-
-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.
-
-## 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__/`.
-
-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.
-
-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.
-
-## 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.
-
-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.
-
-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.
+Shell owns two concrete Identity classes, User and Group, the member_of_group relation,
+the admin/member/applications/view-only Core groups, the Namespace class and its alias relation, the
+view_access relation, the `views` Core Namespace, three static methods, one User method, three Namespace methods, two Domain functions, and one
+application View, which is its entrypoint. The Schema names the Domain `Shell`. There is no Space, setup function, personal home, or public repair method.
+
+## Contracts
+
+| Static method | Input | Output |
+| --- | --- | --- |
+| User.invite | `{ user: UserPath, email: string }` | `{ invitationId, user, state }` |
+| Group.assignMember | `{ member: UserPath \| GroupPath, group: GroupPath }` | `{}` |
+| Group.unassignMember | Same | `{}` |
+
+| User method | Input | Output |
+| --- | --- | --- |
+| User.recordProfile | `{ email?: string, displayName?: string }` | `{}` |
+
+An account records the email and display name it signs in with, so the directory can name it, in
+`claimedEmail` and `claimedName`: named apart from the `email` or `displayName` a Domain extending
+User declares for its own profile. Its
+`isSelf` Policy admits the account itself alone, and Shell writes, with its own authority, only what
+changed; an email is kept in lower case. The values come from the account, not from its identity
+provider: they name it for display and decide nothing. The GUI records them at each sign-in.
+
+| Namespace method | Input | Output |
+| --- | --- | --- |
+| Namespace.link | `{ name: string, target: NodePath }` | `{}` |
+| Namespace.unlink | `{ name: string }` | `{}` |
+| Namespace.rename | `{ name: string, to: string }` | `{}` |
+
+| Domain function | Input | Output |
+| --- | --- | --- |
+| listEntrypoints | `{}` | `{ entrypoints: { origin, name, view }[] }` |
+| assignViews | `{ assignments: { identity, set?, unset? }[] }` | `{}` |
+
+listEntrypoints reads, with Shell's own authority, every Kernel `of_domain` locator whose View has
+an outgoing `entrypoint` Edge, and returns one entry per Domain in origin order: its origin, the
+`name` of its Domain Node, and the key of its entrypoint View. A Domain without an entrypoint is
+not listed. Shell requires `read` on Kernel `Domain` and `of_domain`, and `traverse` on `entrypoint`
+and `View`. Its `usesFunction` Policy admits any caller whose composed profile holds `can_use`
+on the Function, so holding the capability is enough.
+
+The workspace opens only once listEntrypoints answers, so every profile that admits a person to
+the workspace holds it. Administrators and members hold both listEntrypoints and View.resolve
+directly (a Core Edge cannot author Kernel `extends_with`): an invited person, whom Admin assigns
+to Core member, can open the workspace. The Core `applications` Group carries the same two
+capabilities for Identities outside Members, and `query`: the `/v/<name>` page reads its Path with
+a Query under the visitor's own rights, so read rules still decide what it sees. Share them
+dynamically with
+`Group.assignMember({ member: identity, group: applications })`, which composes the profile through
+`extends_with`; `unassignMember` withdraws it.
+
+User extends Kernel.Identity and owns only optional creationKey correlation.
+Concrete business classes may declare their own displayName/email; Shell never reads or writes them.
+Group extends Kernel.Identity, Named and Descriptable. Authentication remains the
+Kernel-owned, write-once iss/sub binding. Invitation email is explicit input, not a User property.
+
+| Operation | Schema Policy alternatives, in addition to Kernel admission |
+| --- | --- |
+| invite | Core admin membership AND Shell-owned concrete User class; or ownership of the User's concrete class |
+| assignMember / unassignMember | Core admin membership AND Shell-owned concrete Group class; or ownership of the Group's concrete class |
+
+ownsClass follows instance_of → concrete class → of_domain → caller. It does not
+infer ownership from an email, a subclass name, or ownership of an ancestor class.
+A Domain cannot assign its Employee to Core member merely by owning Employee. Admin's invitation
+orchestration retains that responsibility. A Group's owner may manage any admitted User or Group in that Group.
+administersShellClass connects Core admin membership and concrete ownership in one Policy pattern;
+it does not treat inheritance from Shell as ownership. These are callable restrictions, not an
+isolation boundary against Root/Manager or the existing broad administrator Kernel profile.
+With Kernel Host beta94 or newer, an external caller needs callable authority through its own
+identity composition AND a passing callable Policy. Declare exact foreign methods in the calling
+Domain's requirements; can_use no longer bypasses the Policy. Root and exact owner exceptions remain.
+
+## Namespaces and aliases
+
+**An alias names a Node. It grants nothing.** A name designates at most one Node in its
+Namespace, for every author: `alias` declares the Kernel key `unique: [['source', 'slug']]` in its
+first release, so the Kernel refuses a taken name on the final state of any Mutation, Shell's or an
+administrator's own `mutate`. Edge identity gives a Node at most one alias per Namespace. An alias
+is a Path, `/:shell.astrale.ai:core.views~"shell.astrale.ai:class.alias"(roadmap)`, and reaches its
+Node only for a reader who may read that Node. Its target endpoint accepts any Node, a Class Shell
+does not own, so the alias detaches when its Node is deleted; the Namespace stays.
+
+The Core Namespace `views` holds the names opened at `/v/<name>`. Namespace and alias declare
+`read: true` and `traverse: true`: a reader lists and follows the aliases whose Node it may read,
+and an alias toward any other Node does not exist for it. Shell, through its own alias Edges,
+finds the Node of every name, even one it does not read.
+
+`link` names any Node its target Path reaches, whatever Domain owns it: an alias grants nothing,
+and each reader sees only the aliases toward Nodes it may read. Offering only Nodes the
+administrator sees is the interface's courtesy, not a server guarantee; any writer already learns
+from a Mutation's locator whether a Path reaches a Node.
+
+| Method | Calls | Refusals |
+| --- | --- | --- |
+| link | One Mutation with Shell's authority; its locator resolves `target` | `INVALID_NAME`, `TARGET_NOT_FOUND`, `NAME_TAKEN`, `TARGET_ALREADY_ALIASED` |
+| unlink | One read of the alias Path with Shell's authority, then one Mutation | `INVALID_NAME`, `NAME_NOT_FOUND` |
+| rename | Same; renaming a name to itself writes nothing | `INVALID_NAME`, `NAME_NOT_FOUND`, `NAME_TAKEN` |
+
+A name is an Edge slug in lower case (`INVALID_NAME`). That rule is Shell's: an administrator
+writing through `mutate` bypasses it, never the key. Nothing guards a name's uniqueness but the key.
+`unlink` and `rename` change the alias only while it still carries the name they read, so a
+concurrent rename answers `NAME_NOT_FOUND` instead of changing another name. Shell maps the Kernel's
+sealed refusals:
+
+| Kernel refusal of the Mutation | link | unlink | rename |
+| --- | --- | --- | --- |
+| `MUTATION_POST_STATE_INVALID`, rule `duplicate-key` | `NAME_TAKEN` | propagates | `NAME_TAKEN` |
+| `MUTATION_PRECONDITION_FAILED` (the alias Edge exists, is gone, or carries another name) | `TARGET_ALREADY_ALIASED` | `NAME_NOT_FOUND` | `NAME_NOT_FOUND` |
+| `MUTATION_LOCATOR_INVALID` (the target Path reaches no Node, or the target was deleted) | `TARGET_NOT_FOUND` | `NAME_NOT_FOUND` | `NAME_NOT_FOUND` |
+
+Every other failure propagates. Core admin holds the three methods, `read` and `traverse` on
+Namespace, and every operation on alias. Administration follows `administersShellClass` on the
+Namespace, as for Groups.
+
+## View access
+
+**A View given to an account decides where it lands, never what it reads.** `view_access` runs from
+a User or a Group to one Kernel View. The Core group `view-only` limits its members to the Views
+they hold, directly or through a group they are a direct member of; membership in `view-only` and
+in Core `admin` counts the same way. Everyone else, and every administrator, opens the workspace as
+before. Nothing else changes: the View's own Domain still
+guards every Node it shows, and `View.resolve` and `listEntrypoints` answer as before.
+
+| Fact | Who writes it | How |
+| --- | --- | --- |
+| `view_access(holder → View)` | Core admin | `assignViews`, or a Mutation that creates or deletes the Edge. It carries no property. |
+| `member_of_group(user → view-only)` | Core admin | `Group.assignMember` / `Group.unassignMember`. |
+
+`view_access` declares `read: true` and `traverse: true`, as `alias` does. Its target is a
+Class Shell does not own, so it detaches when its View is deleted, by a Mutation or by a release
+that removes the View. Clients read a visitor's access with its own Queries
+(`shell.views.access()`): never a read function. A Shell release without `view-only` limits no one.
+
+`assignViews` takes, for each identity (a User or a Group, by `@NodeId`), the Views to give
+(`set`) and to withdraw (`unset`), by `@NodeId`. It reads the identities' `view_access` Edges and
+writes only what differs, in one Mutation guarded by that read, with Shell's own authority: a View
+already given or already withdrawn costs nothing, and a concurrent change refuses the whole write
+(`VIEW_ACCESS_CONFLICT`). An identity listed twice gets both lists; one View both given and
+withdrawn is refused. One call changes at most 40 identities and 20 Views per list. Core admin
+holds it, and may share `can_use` on it. It never changes `view-only`: whether an identity opens the workspace stays its
+membership, which `Group.assignMember` changes.
+
+To limit an invited person to one View: invite them, assign them to `view-only`, give them the
+View with `assignViews`, and give the View an alias in `views` so `/v/<name>` opens it.
+
+## Flows
+
+```text
+Domain creates Employee extending User → unregistered, no group
+Direct credential-evidenced Register → same node authenticates, still no group
+User.invite → provider authentication → Admin ingress → WorkOS/login
+            → Admin Register on that same node → member assignment → completed
+Group.assignMember → member_of_group + Kernel.extends_with in one atomic mutation
+Group.unassignMember → remove both edges in one atomic mutation
+```
+
+The invitation flow is coordinated by Admin, not by an Employee callback. Shell's Integration
+carries only user/email/requestId/requestedBy. Its Provider mints an invocation-bound Shell
+proof for its configured HTTPS ingress audience; target/sourceProof are not business inputs.
+A returned pending invitation does not prove email delivery or completed registration.
+
+`assignMember({ member: A, group: B })` adds A to B. A and its current and future members inherit
+B's authority. Groups can have several parents; Kernel rejects self-membership and cycles in the
+same transaction as both membership edges. The target Group's manager authorizes this delegation;
+the child Group's managers can subsequently change the population that inherits it.
+
+`unassignMember` removes only that direct pair. Another membership path can preserve effective
+access. Queries of `member_of_group` continue to return direct facts; Policy evaluation expands
+the caller's identity composition. Shell must be able to traverse both concrete endpoint Classes,
+including a foreign Group used as the member.
+
+Membership methods converge both edges, including an observed partial membership.
+After an uncertain mutation response they re-read the pair; an unconfirmed outcome remains
+explicitly unconfirmed. This is not a global repair scan or an exactly-once guarantee.
+
+A Team class extending Group can carry a business permission edge to Project. Membership
+composition lets an Employee, as caller, inherit Team's authority; the protected Project Policy is
+still evaluated by Kernel. Removing composition removes that authority path. Installed
+Kernel E2E evidence, not a handler test, qualifies this behavior.
+
+## Installation and View
+
+The Shell principal requests all Kernel root functions, the required extends_with operations,
+and the declared grant/revoke authority. Core admin receives the full declared Shell profile,
+including invite, recordProfile, assignMember, unassignMember, link, unlink, rename and assignViews
+so humans inheriting admin can call those methods. Core member receives Download, Introspect, Query,
+Mutate, View.resolve, listEntrypoints and recordProfile, not blanket class-read grants. Core applications receives listEntrypoints,
+View.resolve and Query.
+The Domain definition's requirements, including Core Identity capabilities in requirements.core, are owned by domain.ts and materialized by installation,
+never by invitation handlers.
+
+The sole application entrypoint uses the Vite React frontend at /, composed with
+`@astrale-os/shell-react` and `@astrale-os/ui`. It administers the instance under the caller's own
+session, in three tabs. **Access** lists users, then groups: whether each opens the whole OS or only its Views (two spelled-out options
+over its `view-only` membership; an administrator always does, a Core group is decided by its role)
+and, through a picker, the installed Views given to it. **Groups** lists the groups and the direct
+members of the chosen one, to add or remove. **Addresses** lists the installed Views and the name
+`/v/<name>` each opens at, to give, rename or remove through `Namespace.link`, `rename` and `unlink`;
+a name the Namespace would refuse, or one another View has, is refused beside the field before it is
+sent. Every change applies at once and comes back with a
+message when the Kernel refuses it. A user shows its recorded display name and email, or its concrete
+class when it recorded none, never a guessed foreign profile. Every read is a Query under the
+caller's rights; the screen proxies no privileged read.
+
+## Versions
+
+The Domain's version is the `version` of `domain/package.json`, which Release Please writes; it
+also writes it to the root `package.json`, the Project's, which `astrale-domain publish` reads. One
+number names the npm package `@astrale-domains/shell` and the registry Publication
+`shell.astrale.ai@<version>`, so an instance installs a published release by number:
+
+```sh
+astrale domain install shell.astrale.ai@<version> -i <instance> --as <instance>-root
+```
+
+`shell.astrale.ai@<major>.<minor>` installs the highest stable version of that line. The Domain
+releases stable versions from 0.1.1 on; 0.1.0, the first Publication, names the 0.1.0-beta.51
+release.
+
+## Source and qualification
+
+Each declaration, Query and Mutation has its own semantic file. Layer roots are facades;
+functions own orchestration, integrations/providers own external effects, views/ui own the
+directory surface. Runtime has one default export and binds the three static Workflows.
+The Dataset is referenced lazily by the root astrale.config.ts.
+
+Domain authors import Schema from @astrale-domains/shell; platform workers use the explicit
+/domain and /runtime exports. Creation/registration, installation authority, invitation
+delivery, runtime replay and browser rendering are separate qualification boundaries.
+The redesigned Admin composition, published Register cohort and real invitation/instance-create
+journeys remain release gates; this source README is not evidence that those gates passed.
+
+### 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 Domain definition and runtime needed by platform
+Worker deployments through the explicit `./domain` and `./runtime` subpaths, while its root remains
+Schema-only. Its build therefore compiles the explicit roots in `tsconfig.package.json` and applies
+Shell-owned normalization and checks to the emitted platform closure. Source-only `#` aliases are
+rewritten to relative JS and declaration references so consumer path mappings cannot capture private Shell
+types. Tarball qualification then verifies the exact exports, isolated subpaths, 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.
+
+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.
+
+### Breaking membership API migration
+
+`Group.assignMember` / `Group.unassignMember` replace `assignUser` / `unassignUser` without aliases.
+Callers must change `{ user, group }` to `{ member, group }` and declare the new exact callable
+requirements. The `member_of_group` Class key is preserved; its source role is now `member` and
+accepts User or Group families. Existing User memberships remain valid.
+
+Rebuild and install all affected Schema dependents as one coherent revision closure. Admin bootstrap
+and invitation completion must use the new API when this Shell revision is installed. A downgrade
+to the User-only contract requires handling any Group-to-Group facts first. Validate public admission,
+foreign endpoint traversal, and deployed revisions during the coordinated release.

package/dist/domain.d.ts

@@ -0,0 +1,225 @@
+import { type DomainDefinition } from '@astrale-os/sdk/domain';
+import { ShellSchema } from './schema/index.js';
+import { type ShellRuntime } from './runtime.js';
+declare const frontend: import("@astrale-os/sdk/view").Frontend<import("@astrale-os/sdk/schema").AuthoredSchema<"shell.astrale.ai", readonly ["kernel.astrale.ai", import("@astrale-os/sdk/schema").KernelSchema] | readonly ["shell.astrale.ai", {
+    readonly name: 'Shell';
+    readonly entrypoint: 'application';
+    readonly classes: {
+        readonly User: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly inheritance: "open";
+            readonly policies: {
+                readonly read: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Identity">];
+            readonly properties: {
+                readonly creationKey: import("zod").ZodOptional<import("zod").ZodString>;
+                readonly claimedEmail: import("zod").ZodOptional<import("zod").ZodString>;
+                readonly claimedName: import("zod").ZodOptional<import("zod").ZodString>;
+            };
+            readonly methods: {
+                readonly invite: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    user: string;
+                    email: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        invitationId: string;
+                        user: string;
+                        state: "accepted" | "cancelled" | "completed" | "expired" | "failed" | "pending" | "registered" | "registering";
+                    };
+                }, "authorized", true, false, undefined, undefined>>;
+                readonly recordProfile: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    email?: string | undefined;
+                    displayName?: string | undefined;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+            };
+        }>;
+        readonly Group: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly inheritance: "open";
+            readonly policies: {
+                readonly read: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Identity">, import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">];
+            readonly methods: {
+                readonly assignMember: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    member: string;
+                    group: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", true, false, undefined, undefined>>;
+                readonly unassignMember: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    member: string;
+                    group: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", true, false, undefined, undefined>>;
+            };
+        }>;
+        readonly member_of_group: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "member";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "group";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+        readonly Namespace: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly policies: {
+                readonly read: true;
+                readonly traverse: true;
+            };
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">];
+            readonly methods: {
+                readonly link: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                    target: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+                readonly unlink: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+                readonly rename: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                    to: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", false, false, undefined, undefined>>;
+            };
+        }>;
+        readonly alias: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "namespace";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "node";
+                readonly accepts: readonly (import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+                    readonly origin: "kernel.astrale.ai";
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+        readonly view_access: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "holder";
+                readonly accepts: readonly (() => {
+                    readonly kind: 'node';
+                    readonly abstract: never;
+                    readonly depth: never;
+                    readonly properties: never;
+                    readonly methods: never;
+                })[];
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "view";
+                readonly accepts: readonly (import("@astrale-os/sdk/schema").ClassRef<"View"> & {
+                    readonly origin: "kernel.astrale.ai";
+                })[];
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+    };
+    readonly functions: {
+        readonly listEntrypoints: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+            readonly mode: 'value';
+            readonly value: {
+                entrypoints: {
+                    origin: string;
+                    name: string;
+                    view: string;
+                }[];
+            };
+        }, "authorized", false, false, undefined, undefined>>;
+        readonly assignViews: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<{
+            assignments: {
+                identity: string;
+                set?: string[] | undefined;
+                unset?: string[] | undefined;
+            }[];
+        }, {
+            readonly mode: 'value';
+            readonly value: Record<string, never>;
+        }, "authorized", false, false, undefined, undefined>>;
+    };
+    readonly policies: {
+        readonly belongsToGroup: import("@astrale-os/sdk/schema").Policy;
+        readonly ownsClass: import("@astrale-os/sdk/schema").Policy;
+        readonly administersShellClass: import("@astrale-os/sdk/schema").Policy;
+        readonly usesFunction: import("@astrale-os/sdk/schema").Policy;
+        readonly isSelf: import("@astrale-os/sdk/schema").Policy;
+    };
+    readonly views: {
+        readonly application: import("@astrale-os/sdk/schema").View;
+    };
+    readonly core: {
+        readonly nodes: {
+            readonly admin: import("@astrale-os/sdk/schema").CoreNode;
+            readonly applications: import("@astrale-os/sdk/schema").CoreNode;
+            readonly member: import("@astrale-os/sdk/schema").CoreNode;
+            readonly views: import("@astrale-os/sdk/schema").CoreNode;
+            readonly 'view-only': import("@astrale-os/sdk/schema").CoreNode;
+        };
+    };
+}, {
+    readonly kernel: "kernel.astrale.ai";
+}]>>;
+declare const domainRequirements: import("@astrale-os/sdk/domain").Requirements;
+export type ShellDomain = DomainDefinition<typeof ShellSchema, ShellRuntime, typeof frontend, undefined, typeof domainRequirements>;
+export declare const domain: ShellDomain;
+export {};