@astrale-domains/shell 0.1.0-beta.39 → 0.1.0-beta.40

package/README.md

@@ -2,7 +2,7 @@
 
 Shell owns two concrete Identity classes, User and Group, the member_of_group relation,
 the admin/member/applications Core groups, three static methods, one Domain function, and one
-application View. There is no Space, setup function, personal home, or public repair method.
+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
 
@@ -14,17 +14,19 @@ application View. There is no Space, setup function, personal home, or public re
 
 | Domain function | Input | Output |
 | --- | --- | --- |
-| listApplications | `{}` | `{ applications: { origin }[] }` |
-
-listApplications reads every installed Domain with Shell's own authority (Shell requires `read` on
-Kernel `Domain`), then resolves each Domain's View catalogue with the caller's authority and keeps
-only the Domains that expose at least one View to that caller. Its Policy (`usesFunction`) admits any
-caller whose composed profile holds `can_use` on it, so holding the capability is enough.
-
-The Core `applications` Group carries `can_use` on listApplications and View.resolve. Administrators
-hold listApplications directly (a Core Edge cannot author Kernel `extends_with`); members do not.
-Share it dynamically with `Group.assignMember({ member: user, group: applications })`, which composes
-the profile through `extends_with`; `unassignMember` withdraws it.
+| listEntrypoints | `{}` | `{ entrypoints: { origin, name, view }[] }` |
+
+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 Core `applications` Group carries `can_use` on listEntrypoints and View.resolve. Administrators
+hold both directly (a Core Edge cannot author Kernel `extends_with`); members do not.
+Share them dynamically with `Group.assignMember({ member: user, 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.

package/dist/domain.d.ts

@@ -2,6 +2,8 @@ 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;
@@ -61,11 +63,13 @@ declare const frontend: import("@astrale-os/sdk/view").Frontend<import("@astrale
         }>;
     };
     readonly functions: {
-        readonly listApplications: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+        readonly listEntrypoints: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
             readonly mode: 'value';
             readonly value: {
-                applications: {
+                entrypoints: {
                     origin: string;
+                    name: string;
+                    view: string;
                 }[];
             };
         }, "authorized", false, false, undefined>>;

package/dist/domain.js

@@ -6,15 +6,17 @@ const frontend = defineFrontend({
     schema: ShellSchema,
     source: vite({ config: './frontend/vite.config.ts' }),
     routes: { application: { path: '/', handshake: 'shell' } },
-    entrypoint: 'application',
 });
 const domainRequirements = requirements({
     // Sujet implicite : le principal installé Shell, utilisé par kernel.self.
     functions: KernelRootFunctions,
     classes: [
         { class: K.classes.extends_with, operations: ['create', 'read', 'traverse', 'delete'] },
-        // listApplications reads the installed Domain catalogue as Shell.
+        // listEntrypoints reads every entrypoint View locator and its Domain as Shell.
         { class: K.classes.Domain, operations: ['read'] },
+        { class: K.classes.of_domain, operations: ['read'] },
+        { class: K.classes.entrypoint, operations: ['traverse'] },
+        { class: K.classes.View, operations: ['traverse'] },
     ],
     authority: {
         grant: ['create', 'read', 'update', 'delete', 'traverse', 'use', 'revoke'],
@@ -30,7 +32,7 @@ const domainRequirements = requirements({
                 S.classes.Group.static.methods.assignMember,
                 S.classes.Group.static.methods.unassignMember,
                 // Core Edges cannot author Kernel extends_with, so administrators hold it directly.
-                S.functions.listApplications,
+                S.functions.listEntrypoints,
             ],
             classes: [
                 { class: S.classes.User, operations: ['create', 'read', 'traverse', 'update', 'delete'] },
@@ -52,6 +54,8 @@ const domainRequirements = requirements({
         {
             subject: S.core.nodes.member,
             functions: [
+                // Download re-reads the holder Node with the caller's authority: no new data exposure.
+                K.functions.download,
                 K.functions.introspect,
                 K.functions.query,
                 K.functions.mutate,
@@ -61,7 +65,7 @@ const domainRequirements = requirements({
         {
             // Shared dynamically: Group.assignMember(user, applications) composes this profile.
             subject: S.core.nodes.applications,
-            functions: [S.functions.listApplications, K.classes.View.static.methods.resolve],
+            functions: [S.functions.listEntrypoints, K.classes.View.static.methods.resolve],
         },
     ],
 });

package/dist/functions/application/index.js

@@ -1 +1 @@
-export { listApplications } from './list-applications.js';
+export { listEntrypoints } from './list-entrypoints.js';

package/dist/functions/application/list-entrypoints.js

@@ -0,0 +1,4 @@
+import { defineAction } from '@astrale-os/sdk/action';
+import { readInstalledEntrypoints } from '../../queries/application/index.js';
+/** One graph read: every Domain with an `entrypoint` Edge, its name and its entrypoint View. */
+export const listEntrypoints = defineAction()('listEntrypoints', async ({ query }) => ({ entrypoints: [...(await query(readInstalledEntrypoints, {}))] }));

package/dist/queries/application/index.js

@@ -1 +1 @@
-export { readInstalledDomainOrigins } from './read-installed-domain-origins.js';
+export { readInstalledEntrypoints } from './read-installed-entrypoints.js';

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

@@ -0,0 +1,44 @@
+import { defineQuery, Query, queryResult, } from '@astrale-os/sdk/query';
+const VIEW_MEMBER = /^view\.([A-Za-z][A-Za-z0-9_]*)$/u;
+/**
+ * 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 readInstalledEntrypoints = 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/runtime.d.ts

@@ -13,6 +13,8 @@ declare const initialize: (environment: unknown) => {
     };
 };
 declare const functions: readonly [import("@astrale-os/sdk/workflow").WorkflowDefinition<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;
@@ -72,11 +74,13 @@ declare const functions: readonly [import("@astrale-os/sdk/workflow").WorkflowDe
         }>;
     };
     readonly functions: {
-        readonly listApplications: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+        readonly listEntrypoints: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
             readonly mode: 'value';
             readonly value: {
-                applications: {
+                entrypoints: {
                     origin: string;
+                    name: string;
+                    view: string;
                 }[];
             };
         }, "authorized", false, false, undefined>>;
@@ -128,6 +132,8 @@ declare const functions: readonly [import("@astrale-os/sdk/workflow").WorkflowDe
         }, import("zod/v4/core").$strict>;
     };
 }>, import("@astrale-os/sdk/workflow").WorkflowDefinition<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;
@@ -187,11 +193,13 @@ declare const functions: readonly [import("@astrale-os/sdk/workflow").WorkflowDe
         }>;
     };
     readonly functions: {
-        readonly listApplications: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+        readonly listEntrypoints: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
             readonly mode: 'value';
             readonly value: {
-                applications: {
+                entrypoints: {
                     origin: string;
+                    name: string;
+                    view: string;
                 }[];
             };
         }, "authorized", false, false, undefined>>;
@@ -241,6 +249,8 @@ declare const functions: readonly [import("@astrale-os/sdk/workflow").WorkflowDe
         }, import("zod/v4/core").$strict>;
     };
 }>, import("@astrale-os/sdk/workflow").WorkflowDefinition<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;
@@ -300,11 +310,13 @@ declare const functions: readonly [import("@astrale-os/sdk/workflow").WorkflowDe
         }>;
     };
     readonly functions: {
-        readonly listApplications: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+        readonly listEntrypoints: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
             readonly mode: 'value';
             readonly value: {
-                applications: {
+                entrypoints: {
                     origin: string;
+                    name: string;
+                    view: string;
                 }[];
             };
         }, "authorized", false, false, undefined>>;
@@ -354,6 +366,8 @@ declare const functions: readonly [import("@astrale-os/sdk/workflow").WorkflowDe
         }, import("zod/v4/core").$strict>;
     };
 }>, import("@astrale-os/sdk/action").ActionDefinition<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;
@@ -413,11 +427,13 @@ declare const functions: readonly [import("@astrale-os/sdk/workflow").WorkflowDe
         }>;
     };
     readonly functions: {
-        readonly listApplications: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+        readonly listEntrypoints: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
             readonly mode: 'value';
             readonly value: {
-                applications: {
+                entrypoints: {
                     origin: string;
+                    name: string;
+                    view: string;
                 }[];
             };
         }, "authorized", false, false, undefined>>;
@@ -440,7 +456,7 @@ declare const functions: readonly [import("@astrale-os/sdk/workflow").WorkflowDe
     };
 }, {
     readonly kernel: "kernel.astrale.ai";
-}]>, "listApplications", Readonly<Record<never, never>>, Readonly<Record<never, never>>>];
+}]>, "listEntrypoints", Readonly<Record<never, never>>, Readonly<Record<never, never>>>];
 export type ShellRuntime = Runtime<ShellSchema, typeof integrations, typeof initialize, typeof functions>;
 declare const runtime: ShellRuntime;
 export default runtime;

package/dist/runtime.js

@@ -1,5 +1,5 @@
 import { defineRuntime } from '@astrale-os/sdk/runtime';
-import { listApplications } from './functions/application/index.js';
+import { listEntrypoints } from './functions/application/index.js';
 import { assignMember, unassignMember } from './functions/group/index.js';
 import { invite } from './functions/user/index.js';
 import { integrations } from './integrations/index.js';
@@ -7,7 +7,7 @@ import { enrollmentProvider } from './providers/admin-enrollment/index.js';
 const initialize = (environment) => ({
     providers: { enrollment: enrollmentProvider(environment) },
 });
-const functions = [invite, assignMember, unassignMember, listApplications];
+const functions = [invite, assignMember, unassignMember, listEntrypoints];
 const runtime = defineRuntime()({
     integrations,
     initialize,

package/dist/schema/index.d.ts

@@ -2,4 +2,4 @@ export { ShellSchema, S, type Shell, type ShellClasses, type ShellSchemaInput }
 export { User } from './modules/user/index.js';
 export type { InvitationSummary } from './modules/user/index.js';
 export { Group, member_of_group, adminGroup, applicationsGroup, memberGroup, } from './modules/group/index.js';
-export { listApplications, type ApplicationEntry } from './modules/application/index.js';
+export { listEntrypoints, type EntrypointEntry } from './modules/application/index.js';

package/dist/schema/index.js

@@ -1,4 +1,4 @@
 export { ShellSchema, S } from './schema.js';
 export { User } from './modules/user/index.js';
 export { Group, member_of_group, adminGroup, applicationsGroup, memberGroup, } from './modules/group/index.js';
-export { listApplications } from './modules/application/index.js';
+export { listEntrypoints } from './modules/application/index.js';

package/dist/schema/modules/application/functions/index.d.ts

@@ -1 +1 @@
-export { listApplications } from './list-applications.js';
+export { listEntrypoints } from './list-entrypoints.js';

package/dist/schema/modules/application/functions/index.js

@@ -1 +1 @@
-export { listApplications } from './list-applications.js';
+export { listEntrypoints } from './list-entrypoints.js';

package/dist/schema/modules/application/functions/list-entrypoints.d.ts

@@ -0,0 +1,15 @@
+import { type Function as SchemaFunction } from '@astrale-os/sdk/schema';
+/**
+ * The entrypoint View of every installed Domain that declares one, with its Domain name. Shell
+ * reads the Kernel `entrypoint` Edges with its own authority; a Domain without one is not listed.
+ */
+export declare const listEntrypoints: SchemaFunction<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>>;

package/dist/schema/modules/application/functions/list-entrypoints.js

@@ -0,0 +1,16 @@
+import { func } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { usesFunction } from '../../../policies/index.js';
+import { entrypointEntry } from '../types/index.js';
+/**
+ * The entrypoint View of every installed Domain that declares one, with its Domain name. Shell
+ * reads the Kernel `entrypoint` Edges with its own authority; a Domain without one is not listed.
+ */
+export const listEntrypoints = func({
+    description: 'List the entrypoint View and name of every installed Domain that declares one.',
+    auth: 'authorized',
+    input: z.strictObject({}),
+    output: z.object({ entrypoints: z.array(entrypointEntry) }),
+    // Holding can_use is enough: membership of the Applications Group shares it dynamically.
+    policy: ({ check, ref }) => check(usesFunction, ref(() => listEntrypoints)),
+});

package/dist/schema/modules/application/index.d.ts

@@ -1,2 +1,2 @@
-export { listApplications } from './functions/index.js';
-export { applicationEntry, type ApplicationEntry } from './types/index.js';
+export { listEntrypoints } from './functions/index.js';
+export { entrypointEntry, type EntrypointEntry } from './types/index.js';

package/dist/schema/modules/application/index.js

@@ -1,2 +1,2 @@
-export { listApplications } from './functions/index.js';
-export { applicationEntry } from './types/index.js';
+export { listEntrypoints } from './functions/index.js';
+export { entrypointEntry } from './types/index.js';

package/dist/schema/modules/application/types/entrypoint-entry.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+/** One installed Domain entrypoint: the Domain origin, its display name, and its View key. */
+export declare const entrypointEntry: z.ZodObject<{
+    origin: z.ZodString;
+    name: z.ZodString;
+    view: z.ZodString;
+}, z.core.$strip>;
+export type EntrypointEntry = z.infer<typeof entrypointEntry>;

package/dist/schema/modules/application/types/entrypoint-entry.js

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+/** One installed Domain entrypoint: the Domain origin, its display name, and its View key. */
+export const entrypointEntry = z.object({
+    origin: z.string().min(1),
+    name: z.string().min(1),
+    view: z.string().min(1),
+});

package/dist/schema/modules/application/types/index.d.ts

@@ -1 +1 @@
-export { applicationEntry, type ApplicationEntry } from './application-entry.js';
+export { entrypointEntry, type EntrypointEntry } from './entrypoint-entry.js';

package/dist/schema/modules/application/types/index.js

@@ -1 +1 @@
-export { applicationEntry } from './application-entry.js';
+export { entrypointEntry } from './entrypoint-entry.js';

package/dist/schema/schema.d.ts

@@ -60,6 +60,8 @@ declare const classes: {
 };
 export type ShellClasses = typeof classes;
 declare const input: {
+    readonly name: 'Shell';
+    readonly entrypoint: 'application';
     readonly dependencies: {
         readonly kernel: KernelSchema;
     };
@@ -122,11 +124,13 @@ declare const input: {
         }>;
     };
     readonly functions: {
-        readonly listApplications: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+        readonly listEntrypoints: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
             readonly mode: 'value';
             readonly value: {
-                applications: {
+                entrypoints: {
                     origin: string;
+                    name: string;
+                    view: string;
                 }[];
             };
         }, "authorized", false, false, undefined>>;
@@ -150,6 +154,8 @@ declare const input: {
 };
 export type ShellSchemaInput = typeof input;
 export declare const ShellSchema: import("@astrale-os/sdk/schema").AuthoredSchema<"shell.astrale.ai", readonly ["kernel.astrale.ai", 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;
@@ -209,11 +215,13 @@ export declare const ShellSchema: import("@astrale-os/sdk/schema").AuthoredSchem
         }>;
     };
     readonly functions: {
-        readonly listApplications: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+        readonly listEntrypoints: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
             readonly mode: 'value';
             readonly value: {
-                applications: {
+                entrypoints: {
                     origin: string;
+                    name: string;
+                    view: string;
                 }[];
             };
         }, "authorized", false, false, undefined>>;
@@ -239,6 +247,8 @@ export declare const ShellSchema: import("@astrale-os/sdk/schema").AuthoredSchem
 }]>;
 export type ShellSchema = typeof ShellSchema;
 export declare const S: schema.ResolvedDomainOf<import("@astrale-os/sdk/schema").AuthoredSchema<"shell.astrale.ai", readonly ["kernel.astrale.ai", 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;
@@ -298,11 +308,13 @@ export declare const S: schema.ResolvedDomainOf<import("@astrale-os/sdk/schema")
         }>;
     };
     readonly functions: {
-        readonly listApplications: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+        readonly listEntrypoints: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
             readonly mode: 'value';
             readonly value: {
-                applications: {
+                entrypoints: {
                     origin: string;
+                    name: string;
+                    view: string;
                 }[];
             };
         }, "authorized", false, false, undefined>>;

package/dist/schema/schema.js

@@ -1,5 +1,5 @@
 import { defineSchema, KernelSchema, schema } from '@astrale-os/sdk/schema';
-import { listApplications } from './modules/application/index.js';
+import { listEntrypoints } from './modules/application/index.js';
 import { Group, member_of_group, adminGroup, applicationsGroup, memberGroup, belongsToGroup, } from './modules/group/index.js';
 import { User } from './modules/user/index.js';
 import { ownsClass, administersShellClass, usesFunction } from './policies/index.js';
@@ -7,13 +7,15 @@ import { applicationView } from './views/index.js';
 export const ORIGIN = 'shell.astrale.ai';
 const dependencies = { kernel: KernelSchema };
 const classes = { User, Group, member_of_group };
-const functions = { listApplications };
+const functions = { listEntrypoints };
 const policies = { belongsToGroup, ownsClass, administersShellClass, usesFunction };
 const views = { application: applicationView };
 const core = {
     nodes: { admin: adminGroup, applications: applicationsGroup, member: memberGroup },
 };
 const input = {
+    name: 'Shell',
+    entrypoint: 'application',
     dependencies,
     classes,
     functions,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-domains/shell",
-  "version": "0.1.0-beta.39",
+  "version": "0.1.0-beta.40",
   "description": "Astrale Shell Domain schema and remote product implementation",
   "license": "Apache-2.0",
   "repository": {
@@ -58,8 +58,8 @@
   },
   "devDependencies": {
     "@astrale-os/ox": "0.1.4",
-    "@astrale-os/sdk": "0.6.0-beta.18",
-    "@astrale-os/shell-react": ">=0.5.0-beta.7 <1.0.0",
+    "@astrale-os/sdk": "0.6.0-beta.24",
+    "@astrale-os/shell-react": ">=0.6.0-beta.0 <1.0.0",
     "@astrale-os/ui": "0.3.0-beta.32",
     "@astrale/typescript-config": "npm:@jsr/astrale__typescript-config@~2.0.0",
     "@testing-library/dom": "10.4.1",
@@ -76,7 +76,7 @@
     "vitest": "5.0.1"
   },
   "peerDependencies": {
-    "@astrale-os/sdk": ">=0.6.0-beta.4 <1.0.0"
+    "@astrale-os/sdk": ">=0.6.0-beta.24 <1.0.0"
   },
   "devEngines": {
     "runtime": {

package/dist/functions/application/list-applications.js

@@ -1,19 +0,0 @@
-import { defineAction } from '@astrale-os/sdk/action';
-import { Path } from '@astrale-os/sdk/graph/path';
-import { readInstalledDomainOrigins } from '../../queries/application/index.js';
-/** Catalogues resolved together, so a large instance does not flood the Kernel. */
-const RESOLVE_BATCH = 16;
-export const listApplications = defineAction()('listApplications', async ({ query, kernel }) => {
-    const origins = await query(readInstalledDomainOrigins, {});
-    const applications = [];
-    for (let offset = 0; offset < origins.length; offset += RESOLVE_BATCH) {
-        const batch = origins.slice(offset, offset + RESOLVE_BATCH);
-        // The caller's authority decides which Views it can open.
-        const catalogues = await Promise.all(batch.map((origin) => kernel.caller.viewsFor(Path.domain(origin))));
-        for (const [index, origin] of batch.entries()) {
-            if (catalogues[index].views.length > 0)
-                applications.push({ origin });
-        }
-    }
-    return { applications };
-});

package/dist/queries/application/read-installed-domain-origins.js

@@ -1,22 +0,0 @@
-import { defineQuery, Query, queryResult, } from '@astrale-os/sdk/query';
-/** Every installed Domain origin this authority can read, in origin order. */
-export const readInstalledDomainOrigins = defineQuery()((domain) => ({
-    id: 'shell.application.domain-origins',
-    page: { size: 200 },
-    pagination: { maximumPages: 50 },
-    build: () => Query.from({ nodes: [domain.dependencies.kernel.classes.Domain] }).select({
-        kind: 'nodes',
-        projection: { kind: 'value' },
-    }),
-    project(pages) {
-        return queryResult
-            .completeNodeValues(pages, 'Installed Domains')
-            .map((installed) => {
-            const value = installed.props[domain.dependencies.kernel.classes.Domain.properties.origin.key];
-            if (typeof value !== 'string')
-                throw new TypeError('Installed Domain has no origin.');
-            return value;
-        })
-            .sort((left, right) => left.localeCompare(right));
-    },
-}));

package/dist/schema/modules/application/functions/list-applications.d.ts

@@ -1,13 +0,0 @@
-import { type Function as SchemaFunction } from '@astrale-os/sdk/schema';
-/**
- * Installed Domains that expose at least one View to the caller. Shell reads the Domain catalogue
- * with its own authority; each catalogue of Views is resolved with the caller's.
- */
-export declare const listApplications: SchemaFunction<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
-    readonly mode: 'value';
-    readonly value: {
-        applications: {
-            origin: string;
-        }[];
-    };
-}, "authorized", false, false, undefined>>;

package/dist/schema/modules/application/functions/list-applications.js

@@ -1,16 +0,0 @@
-import { func } from '@astrale-os/sdk/schema';
-import { z } from 'zod';
-import { usesFunction } from '../../../policies/index.js';
-import { applicationEntry } from '../types/index.js';
-/**
- * Installed Domains that expose at least one View to the caller. Shell reads the Domain catalogue
- * with its own authority; each catalogue of Views is resolved with the caller's.
- */
-export const listApplications = func({
-    description: 'List the installed Domains whose Views the caller can open.',
-    auth: 'authorized',
-    input: z.strictObject({}),
-    output: z.object({ applications: z.array(applicationEntry) }),
-    // Holding can_use is enough: membership of the Applications Group shares it dynamically.
-    policy: ({ check, ref }) => check(usesFunction, ref(() => listApplications)),
-});

package/dist/schema/modules/application/types/application-entry.d.ts

@@ -1,5 +0,0 @@
-import { z } from 'zod';
-export declare const applicationEntry: z.ZodObject<{
-    origin: z.ZodString;
-}, z.core.$strip>;
-export type ApplicationEntry = z.infer<typeof applicationEntry>;

package/dist/schema/modules/application/types/application-entry.js

@@ -1,2 +0,0 @@
-import { z } from 'zod';
-export const applicationEntry = z.object({ origin: z.string().min(1) });