@astrale-domains/shell 0.1.0-beta.46 → 0.1.0-beta.48

package/dist/runtime.js

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

package/dist/schema/index.d.ts

@@ -3,3 +3,4 @@ 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 { listEntrypoints, type EntrypointEntry } from './modules/application/index.js';
+export { Namespace, alias, viewsNamespace } from './modules/namespace/index.js';

package/dist/schema/index.js

@@ -2,3 +2,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 { listEntrypoints } from './modules/application/index.js';
+export { Namespace, alias, viewsNamespace } from './modules/namespace/index.js';

package/dist/schema/modules/group/classes/group.d.ts

@@ -1,5 +1,6 @@
 export declare const Group: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
     readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+    readonly inheritance: "open";
     readonly policies: {
         readonly read: true;
     };

package/dist/schema/modules/group/classes/group.js

@@ -3,6 +3,8 @@ import { UsersRound } from '@astrale-os/sdk/schema/icons';
 import { assignMember, unassignMember } from '../functions/index.js';
 export const Group = nodeClass({
     icon: classIcon.lucide(UsersRound),
+    // Domains that depend on Shell extend it with the groups they own.
+    inheritance: 'open',
     policies: { read: true },
     extends: [K.classes.Identity, K.classes.Named, K.classes.Descriptable],
     methods: { assignMember, unassignMember },

package/dist/schema/modules/namespace/classes/alias.d.ts

@@ -0,0 +1,21 @@
+/**
+ * One name in a Namespace: the Edge slug is the name, the target any Node. The Kernel key keeps a
+ * name to one Node for every author; Edge identity keeps a Node to one alias per Namespace. The
+ * target accepts a Class Shell does not own, so the alias detaches with its Node.
+ */
+export declare const 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 outgoing: "0..*";
+    };
+    readonly target: {
+        readonly as: "node";
+        readonly incoming: "0..*";
+    };
+    readonly constraints: Record<never, never>;
+    readonly effectiveProperties: never;
+}>;

package/dist/schema/modules/namespace/classes/alias.js

@@ -0,0 +1,13 @@
+import { K, edgeClass } from '@astrale-os/sdk/schema';
+import { Namespace } from './namespace.js';
+/**
+ * One name in a Namespace: the Edge slug is the name, the target any Node. The Kernel key keeps a
+ * name to one Node for every author; Edge identity keeps a Node to one alias per Namespace. The
+ * target accepts a Class Shell does not own, so the alias detaches with its Node.
+ */
+export const alias = edgeClass.directed({
+    policies: { read: true, traverse: true },
+    source: { as: 'namespace', accepts: [() => Namespace], outgoing: '0..*' },
+    target: { as: 'node', accepts: [K.classes.Node], incoming: '0..*' },
+    unique: [['source', 'slug']],
+});

package/dist/schema/modules/namespace/classes/index.d.ts

@@ -0,0 +1,2 @@
+export { Namespace } from './namespace.js';
+export { alias } from './alias.js';

package/dist/schema/modules/namespace/classes/index.js

@@ -0,0 +1,2 @@
+export { Namespace } from './namespace.js';
+export { alias } from './alias.js';

package/dist/schema/modules/namespace/classes/namespace.d.ts

@@ -0,0 +1,31 @@
+/** A scope of names chosen by the instance: each `alias` Edge slug names one Node, once. */
+export declare const 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>>;
+    };
+}>;

package/dist/schema/modules/namespace/classes/namespace.js

@@ -0,0 +1,10 @@
+import { K, classIcon, nodeClass } from '@astrale-os/sdk/schema';
+import { Signpost } from '@astrale-os/sdk/schema/icons';
+import { link, rename, unlink } from '../functions/index.js';
+/** A scope of names chosen by the instance: each `alias` Edge slug names one Node, once. */
+export const Namespace = nodeClass({
+    icon: classIcon.lucide(Signpost),
+    policies: { read: true, traverse: true },
+    extends: [K.classes.Named, K.classes.Descriptable],
+    methods: { link, unlink, rename },
+});

package/dist/schema/modules/namespace/core/index.d.ts

@@ -0,0 +1 @@
+export { viewsNamespace } from './views-namespace.js';

package/dist/schema/modules/namespace/core/index.js

@@ -0,0 +1 @@
+export { viewsNamespace } from './views-namespace.js';

package/dist/schema/modules/namespace/core/views-namespace.d.ts

@@ -0,0 +1,2 @@
+/** `/:shell.astrale.ai:core.views`: the names a visitor opens at `https://<instance>/v/<name>`. */
+export declare const viewsNamespace: import("@astrale-os/sdk/schema").CoreNode;

package/dist/schema/modules/namespace/core/views-namespace.js

@@ -0,0 +1,7 @@
+import { K, core } from '@astrale-os/sdk/schema';
+import { Namespace } from '../classes/namespace.js';
+/** `/:shell.astrale.ai:core.views`: the names a visitor opens at `https://<instance>/v/<name>`. */
+export const viewsNamespace = core.node(() => Namespace, {
+    [K.classes.Named.properties.name.key]: 'Views',
+    [K.classes.Descriptable.properties.description.key]: 'Aliases opened at /v/<name> on this instance.',
+});

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

@@ -0,0 +1,3 @@
+export { link } from './link.js';
+export { unlink } from './unlink.js';
+export { rename } from './rename.js';

package/dist/schema/modules/namespace/functions/link.js

@@ -0,0 +1,11 @@
+import { K, method, path } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { ownsClass, administersShellClass } from '../../../policies/index.js';
+import { namespaceName } from '../types/index.js';
+export const link = method({
+    description: 'Give one Node an alias in this Namespace.',
+    auth: 'authorized',
+    input: z.strictObject({ name: namespaceName, target: path(K.classes.Node) }),
+    output: z.object({}),
+    policy: ({ anyOf, check, self }) => anyOf(check(administersShellClass, self), check(ownsClass, self)),
+});

package/dist/schema/modules/namespace/functions/rename.js

@@ -0,0 +1,11 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { ownsClass, administersShellClass } from '../../../policies/index.js';
+import { namespaceName } from '../types/index.js';
+export const rename = method({
+    description: 'Rename one alias of this Namespace; the Node it names stays the same.',
+    auth: 'authorized',
+    input: z.strictObject({ name: namespaceName, to: namespaceName }),
+    output: z.object({}),
+    policy: ({ anyOf, check, self }) => anyOf(check(administersShellClass, self), check(ownsClass, self)),
+});

package/dist/schema/modules/namespace/functions/unlink.js

@@ -0,0 +1,11 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { ownsClass, administersShellClass } from '../../../policies/index.js';
+import { namespaceName } from '../types/index.js';
+export const unlink = method({
+    description: 'Remove one alias from this Namespace.',
+    auth: 'authorized',
+    input: z.strictObject({ name: namespaceName }),
+    output: z.object({}),
+    policy: ({ anyOf, check, self }) => anyOf(check(administersShellClass, self), check(ownsClass, self)),
+});

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

@@ -0,0 +1,2 @@
+export { Namespace, alias } from './classes/index.js';
+export { viewsNamespace } from './core/index.js';

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

@@ -0,0 +1,2 @@
+export { Namespace, alias } from './classes/index.js';
+export { viewsNamespace } from './core/index.js';

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

@@ -0,0 +1 @@
+export { namespaceName } from './namespace-name.js';

package/dist/schema/modules/namespace/types/namespace-name.js

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+/**
+ * A name as written after `/v/`. Portable value patterns match substrings only, so the exact
+ * grammar, a lower-case Edge slug, is the Namespace Actions' rule and its one refusal
+ * `INVALID_NAME`.
+ */
+export const namespaceName = z.string();

package/dist/schema/modules/user/classes/user.d.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 export declare const User: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
     readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+    readonly inheritance: "open";
     readonly policies: {
         readonly read: true;
     };

package/dist/schema/modules/user/classes/user.js

@@ -6,6 +6,8 @@ import { invite } from '../functions/index.js';
 const creationKey = z.string().min(1).max(512).optional();
 export const User = nodeClass({
     icon: classIcon.lucide(UserRound),
+    // Domains that depend on Shell extend it with the accounts they own.
+    inheritance: 'open',
     policies: { read: true },
     extends: [K.classes.Identity],
     properties: { creationKey },

package/dist/schema/schema.d.ts

@@ -3,6 +3,7 @@ export declare const ORIGIN: 'shell.astrale.ai';
 declare const 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;
         };
@@ -26,6 +27,7 @@ declare const classes: {
     }>;
     readonly Group: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
         readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+        readonly inheritance: "open";
         readonly policies: {
             readonly read: true;
         };
@@ -63,6 +65,52 @@ declare const classes: {
         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 outgoing: "0..*";
+        };
+        readonly target: {
+            readonly as: "node";
+            readonly incoming: "0..*";
+        };
+        readonly constraints: Record<never, never>;
+        readonly effectiveProperties: never;
+    }>;
 };
 export type ShellClasses = typeof classes;
 declare const input: {
@@ -74,6 +122,7 @@ declare const input: {
     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;
             };
@@ -97,6 +146,7 @@ declare const input: {
         }>;
         readonly Group: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
             readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly inheritance: "open";
             readonly policies: {
                 readonly read: true;
             };
@@ -134,6 +184,52 @@ declare const input: {
             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 outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "node";
+                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>, {
@@ -161,6 +257,7 @@ declare const input: {
             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;
         };
     };
 };
@@ -171,6 +268,7 @@ export declare const ShellSchema: import("@astrale-os/sdk/schema").AuthoredSchem
     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;
             };
@@ -194,6 +292,7 @@ export declare const ShellSchema: import("@astrale-os/sdk/schema").AuthoredSchem
         }>;
         readonly Group: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
             readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly inheritance: "open";
             readonly policies: {
                 readonly read: true;
             };
@@ -231,6 +330,52 @@ export declare const ShellSchema: import("@astrale-os/sdk/schema").AuthoredSchem
             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 outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "node";
+                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>, {
@@ -258,6 +403,7 @@ export declare const ShellSchema: import("@astrale-os/sdk/schema").AuthoredSchem
             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;
         };
     };
 }, {
@@ -270,6 +416,7 @@ export declare const S: schema.ResolvedDomainOf<import("@astrale-os/sdk/schema")
     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;
             };
@@ -293,6 +440,7 @@ export declare const S: schema.ResolvedDomainOf<import("@astrale-os/sdk/schema")
         }>;
         readonly Group: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
             readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly inheritance: "open";
             readonly policies: {
                 readonly read: true;
             };
@@ -330,6 +478,52 @@ export declare const S: schema.ResolvedDomainOf<import("@astrale-os/sdk/schema")
             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 outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "node";
+                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>, {
@@ -357,6 +551,7 @@ export declare const S: schema.ResolvedDomainOf<import("@astrale-os/sdk/schema")
             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;
         };
     };
 }, {

package/dist/schema/schema.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-domains/shell",
-  "version": "0.1.0-beta.46",
+  "version": "0.1.0-beta.48",
   "description": "Astrale Shell Domain schema and remote product implementation",
   "license": "Apache-2.0",
   "repository": {
@@ -76,7 +76,7 @@
     "vitest": "5.0.1"
   },
   "peerDependencies": {
-    "@astrale-os/sdk": ">=0.6.0-beta.31 <1.0.0"
+    "@astrale-os/sdk": ">=0.6.0-beta.37 <1.0.0"
   },
   "devEngines": {
     "runtime": {