@astrale-domains/shell 0.1.0-beta.4 → 0.1.0-beta.7

package/dist/schema/group/class.js

@@ -1,11 +1,7 @@
-import { nodeClass } from '@astrale-os/sdk/schema';
-import { K } from '@astrale-os/sdk/schema/kernel';
+import { K, nodeClass } from '@astrale-os/sdk/schema';
 import { groupAssignUser, groupUnassignUser } from './methods.js';
-const ref = (name) => ({ origin: K.$.origin, kind: 'interface', name });
 export const Group = nodeClass({
     description: 'A named compositional Shell Identity.',
-    // Current DSL Core-property admission still requires explicit metadata interfaces.
-    implements: [ref(K.Identity.name), ref(K.Named.name), ref(K.Descriptable.name)],
+    extends: [K.classes.Identity, K.classes.Named, K.classes.Descriptable],
     methods: { assignUser: groupAssignUser, unassignUser: groupUnassignUser },
 });
-//# sourceMappingURL=class.js.map

package/dist/schema/group/core.d.ts

@@ -1,495 +1,14 @@
 import { type builder } from '@astrale-os/sdk/schema';
-export declare const adminGroup: builder.Node<builder.NodeClass<{
-    readonly description: "A named compositional Shell Identity.";
-    readonly implements: readonly [{
-        origin: "kernel.astrale.ai";
-        kind: 'interface';
-        name: string;
-    }, {
-        origin: "kernel.astrale.ai";
-        kind: 'interface';
-        name: string;
-    }, {
-        origin: "kernel.astrale.ai";
-        kind: 'interface';
-        name: string;
-    }];
-    readonly methods: {
-        assignUser: builder.Function<{
-            readonly description: string;
-            readonly input: import("zod").ZodObject<{
-                user: builder.Path<readonly [builder.NodeInterface<{
-                    readonly description: "A human-facing Shell principal.";
-                    readonly extends: readonly [{
-                        origin: "kernel.astrale.ai";
-                        kind: 'interface';
-                        name: "Identity";
-                    }];
-                }>]>;
-            }, import("zod/v4/core").$strict>;
-            readonly output: {
-                type: 'object';
-                properties: {};
-                additionalProperties: boolean;
-            };
-            readonly auth: "authorized";
-            readonly policy: ({ check, self }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
-        }>;
-        unassignUser: builder.Function<{
-            readonly description: string;
-            readonly input: import("zod").ZodObject<{
-                user: builder.Path<readonly [builder.NodeInterface<{
-                    readonly description: "A human-facing Shell principal.";
-                    readonly extends: readonly [{
-                        origin: "kernel.astrale.ai";
-                        kind: 'interface';
-                        name: "Identity";
-                    }];
-                }>]>;
-            }, import("zod/v4/core").$strict>;
-            readonly output: {
-                type: 'object';
-                properties: {};
-                additionalProperties: boolean;
-            };
-            readonly auth: "authorized";
-            readonly policy: ({ check, self }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
-        }>;
-    };
-}>>;
-export declare const memberGroup: builder.Node<builder.NodeClass<{
-    readonly description: "A named compositional Shell Identity.";
-    readonly implements: readonly [{
-        origin: "kernel.astrale.ai";
-        kind: 'interface';
-        name: string;
-    }, {
-        origin: "kernel.astrale.ai";
-        kind: 'interface';
-        name: string;
-    }, {
-        origin: "kernel.astrale.ai";
-        kind: 'interface';
-        name: string;
-    }];
-    readonly methods: {
-        assignUser: builder.Function<{
-            readonly description: string;
-            readonly input: import("zod").ZodObject<{
-                user: builder.Path<readonly [builder.NodeInterface<{
-                    readonly description: "A human-facing Shell principal.";
-                    readonly extends: readonly [{
-                        origin: "kernel.astrale.ai";
-                        kind: 'interface';
-                        name: "Identity";
-                    }];
-                }>]>;
-            }, import("zod/v4/core").$strict>;
-            readonly output: {
-                type: 'object';
-                properties: {};
-                additionalProperties: boolean;
-            };
-            readonly auth: "authorized";
-            readonly policy: ({ check, self }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
-        }>;
-        unassignUser: builder.Function<{
-            readonly description: string;
-            readonly input: import("zod").ZodObject<{
-                user: builder.Path<readonly [builder.NodeInterface<{
-                    readonly description: "A human-facing Shell principal.";
-                    readonly extends: readonly [{
-                        origin: "kernel.astrale.ai";
-                        kind: 'interface';
-                        name: "Identity";
-                    }];
-                }>]>;
-            }, import("zod/v4/core").$strict>;
-            readonly output: {
-                type: 'object';
-                properties: {};
-                additionalProperties: boolean;
-            };
-            readonly auth: "authorized";
-            readonly policy: ({ check, self }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
-        }>;
-    };
-}>>;
+export declare const adminGroup: builder.CoreNode;
+export declare const memberGroup: builder.CoreNode;
 export declare const groupCore: {
     nodes: {
-        admin: builder.Node<builder.NodeClass<{
-            readonly description: "A named compositional Shell Identity.";
-            readonly implements: readonly [{
-                origin: "kernel.astrale.ai";
-                kind: 'interface';
-                name: string;
-            }, {
-                origin: "kernel.astrale.ai";
-                kind: 'interface';
-                name: string;
-            }, {
-                origin: "kernel.astrale.ai";
-                kind: 'interface';
-                name: string;
-            }];
-            readonly methods: {
-                assignUser: builder.Function<{
-                    readonly description: string;
-                    readonly input: import("zod").ZodObject<{
-                        user: builder.Path<readonly [builder.NodeInterface<{
-                            readonly description: "A human-facing Shell principal.";
-                            readonly extends: readonly [{
-                                origin: "kernel.astrale.ai";
-                                kind: 'interface';
-                                name: "Identity";
-                            }];
-                        }>]>;
-                    }, import("zod/v4/core").$strict>;
-                    readonly output: {
-                        type: 'object';
-                        properties: {};
-                        additionalProperties: boolean;
-                    };
-                    readonly auth: "authorized";
-                    readonly policy: ({ check, self }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
-                }>;
-                unassignUser: builder.Function<{
-                    readonly description: string;
-                    readonly input: import("zod").ZodObject<{
-                        user: builder.Path<readonly [builder.NodeInterface<{
-                            readonly description: "A human-facing Shell principal.";
-                            readonly extends: readonly [{
-                                origin: "kernel.astrale.ai";
-                                kind: 'interface';
-                                name: "Identity";
-                            }];
-                        }>]>;
-                    }, import("zod/v4/core").$strict>;
-                    readonly output: {
-                        type: 'object';
-                        properties: {};
-                        additionalProperties: boolean;
-                    };
-                    readonly auth: "authorized";
-                    readonly policy: ({ check, self }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
-                }>;
-            };
-        }>>;
-        member: builder.Node<builder.NodeClass<{
-            readonly description: "A named compositional Shell Identity.";
-            readonly implements: readonly [{
-                origin: "kernel.astrale.ai";
-                kind: 'interface';
-                name: string;
-            }, {
-                origin: "kernel.astrale.ai";
-                kind: 'interface';
-                name: string;
-            }, {
-                origin: "kernel.astrale.ai";
-                kind: 'interface';
-                name: string;
-            }];
-            readonly methods: {
-                assignUser: builder.Function<{
-                    readonly description: string;
-                    readonly input: import("zod").ZodObject<{
-                        user: builder.Path<readonly [builder.NodeInterface<{
-                            readonly description: "A human-facing Shell principal.";
-                            readonly extends: readonly [{
-                                origin: "kernel.astrale.ai";
-                                kind: 'interface';
-                                name: "Identity";
-                            }];
-                        }>]>;
-                    }, import("zod/v4/core").$strict>;
-                    readonly output: {
-                        type: 'object';
-                        properties: {};
-                        additionalProperties: boolean;
-                    };
-                    readonly auth: "authorized";
-                    readonly policy: ({ check, self }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
-                }>;
-                unassignUser: builder.Function<{
-                    readonly description: string;
-                    readonly input: import("zod").ZodObject<{
-                        user: builder.Path<readonly [builder.NodeInterface<{
-                            readonly description: "A human-facing Shell principal.";
-                            readonly extends: readonly [{
-                                origin: "kernel.astrale.ai";
-                                kind: 'interface';
-                                name: "Identity";
-                            }];
-                        }>]>;
-                    }, import("zod/v4/core").$strict>;
-                    readonly output: {
-                        type: 'object';
-                        properties: {};
-                        additionalProperties: boolean;
-                    };
-                    readonly auth: "authorized";
-                    readonly policy: ({ check, self }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
-                }>;
-            };
-        }>>;
+        admin: builder.CoreNode<builder.Lazy<builder.NodeClass<builder.NodeClassInput>>, (Readonly<Record<`${string}:class.${string}.property.${string}`, import("@astrale-os/sdk/schema").Value>> | Readonly<{} & {
+            [x: string]: unknown;
+        }>) & import("@astrale-os/sdk/schema").Object>;
+        member: builder.CoreNode<builder.Lazy<builder.NodeClass<builder.NodeClassInput>>, (Readonly<Record<`${string}:class.${string}.property.${string}`, import("@astrale-os/sdk/schema").Value>> | Readonly<{} & {
+            [x: string]: unknown;
+        }>) & import("@astrale-os/sdk/schema").Object>;
     };
-    edges: builder.Edge<builder.Node<builder.NodeClass<{
-        readonly description: "A named compositional Shell Identity.";
-        readonly implements: readonly [{
-            origin: "kernel.astrale.ai";
-            kind: 'interface';
-            name: string;
-        }, {
-            origin: "kernel.astrale.ai";
-            kind: 'interface';
-            name: string;
-        }, {
-            origin: "kernel.astrale.ai";
-            kind: 'interface';
-            name: string;
-        }];
-        readonly methods: {
-            assignUser: builder.Function<{
-                readonly description: string;
-                readonly input: import("zod").ZodObject<{
-                    user: builder.Path<readonly [builder.NodeInterface<{
-                        readonly description: "A human-facing Shell principal.";
-                        readonly extends: readonly [{
-                            origin: "kernel.astrale.ai";
-                            kind: 'interface';
-                            name: "Identity";
-                        }];
-                    }>]>;
-                }, import("zod/v4/core").$strict>;
-                readonly output: {
-                    type: 'object';
-                    properties: {};
-                    additionalProperties: boolean;
-                };
-                readonly auth: "authorized";
-                readonly policy: ({ check, self }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
-            }>;
-            unassignUser: builder.Function<{
-                readonly description: string;
-                readonly input: import("zod").ZodObject<{
-                    user: builder.Path<readonly [builder.NodeInterface<{
-                        readonly description: "A human-facing Shell principal.";
-                        readonly extends: readonly [{
-                            origin: "kernel.astrale.ai";
-                            kind: 'interface';
-                            name: "Identity";
-                        }];
-                    }>]>;
-                }, import("zod/v4/core").$strict>;
-                readonly output: {
-                    type: 'object';
-                    properties: {};
-                    additionalProperties: boolean;
-                };
-                readonly auth: "authorized";
-                readonly policy: ({ check, self }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
-            }>;
-        };
-    }>>, builder.DirectedEdgeClass<{
-        readonly as: "admin";
-        readonly accepts: readonly [{
-            origin: "kernel.astrale.ai";
-            kind: 'interface';
-            name: "Identity";
-        }];
-        readonly outgoing: "0..*";
-    }, {
-        readonly as: "group";
-        readonly accepts: readonly [() => builder.NodeClass<{
-            readonly description: "A named compositional Shell Identity.";
-            readonly implements: readonly [{
-                origin: "kernel.astrale.ai";
-                kind: 'interface';
-                name: string;
-            }, {
-                origin: "kernel.astrale.ai";
-                kind: 'interface';
-                name: string;
-            }, {
-                origin: "kernel.astrale.ai";
-                kind: 'interface';
-                name: string;
-            }];
-            readonly methods: {
-                assignUser: builder.Function<{
-                    readonly description: string;
-                    readonly input: import("zod").ZodObject<{
-                        user: builder.Path<readonly [builder.NodeInterface<{
-                            readonly description: "A human-facing Shell principal.";
-                            readonly extends: readonly [{
-                                origin: "kernel.astrale.ai";
-                                kind: 'interface';
-                                name: "Identity";
-                            }];
-                        }>]>;
-                    }, import("zod/v4/core").$strict>;
-                    readonly output: {
-                        type: 'object';
-                        properties: {};
-                        additionalProperties: boolean;
-                    };
-                    readonly auth: "authorized";
-                    readonly policy: ({ check, self }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
-                }>;
-                unassignUser: builder.Function<{
-                    readonly description: string;
-                    readonly input: import("zod").ZodObject<{
-                        user: builder.Path<readonly [builder.NodeInterface<{
-                            readonly description: "A human-facing Shell principal.";
-                            readonly extends: readonly [{
-                                origin: "kernel.astrale.ai";
-                                kind: 'interface';
-                                name: "Identity";
-                            }];
-                        }>]>;
-                    }, import("zod/v4/core").$strict>;
-                    readonly output: {
-                        type: 'object';
-                        properties: {};
-                        additionalProperties: boolean;
-                    };
-                    readonly auth: "authorized";
-                    readonly policy: ({ check, self }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
-                }>;
-            };
-        }>];
-        readonly incoming: "0..*";
-    }, Omit<{
-        readonly source: {
-            readonly as: "admin";
-            readonly accepts: readonly [{
-                origin: "kernel.astrale.ai";
-                kind: 'interface';
-                name: "Identity";
-            }];
-            readonly outgoing: "0..*";
-        };
-        readonly target: {
-            readonly as: "group";
-            readonly accepts: readonly [() => builder.NodeClass<{
-                readonly description: "A named compositional Shell Identity.";
-                readonly implements: readonly [{
-                    origin: "kernel.astrale.ai";
-                    kind: 'interface';
-                    name: string;
-                }, {
-                    origin: "kernel.astrale.ai";
-                    kind: 'interface';
-                    name: string;
-                }, {
-                    origin: "kernel.astrale.ai";
-                    kind: 'interface';
-                    name: string;
-                }];
-                readonly methods: {
-                    assignUser: builder.Function<{
-                        readonly description: string;
-                        readonly input: import("zod").ZodObject<{
-                            user: builder.Path<readonly [builder.NodeInterface<{
-                                readonly description: "A human-facing Shell principal.";
-                                readonly extends: readonly [{
-                                    origin: "kernel.astrale.ai";
-                                    kind: 'interface';
-                                    name: "Identity";
-                                }];
-                            }>]>;
-                        }, import("zod/v4/core").$strict>;
-                        readonly output: {
-                            type: 'object';
-                            properties: {};
-                            additionalProperties: boolean;
-                        };
-                        readonly auth: "authorized";
-                        readonly policy: ({ check, self }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
-                    }>;
-                    unassignUser: builder.Function<{
-                        readonly description: string;
-                        readonly input: import("zod").ZodObject<{
-                            user: builder.Path<readonly [builder.NodeInterface<{
-                                readonly description: "A human-facing Shell principal.";
-                                readonly extends: readonly [{
-                                    origin: "kernel.astrale.ai";
-                                    kind: 'interface';
-                                    name: "Identity";
-                                }];
-                            }>]>;
-                        }, import("zod/v4/core").$strict>;
-                        readonly output: {
-                            type: 'object';
-                            properties: {};
-                            additionalProperties: boolean;
-                        };
-                        readonly auth: "authorized";
-                        readonly policy: ({ check, self }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
-                    }>;
-                };
-            }>];
-            readonly incoming: "0..*";
-        };
-        readonly description: "Authority to administer one Shell Group.";
-    }, "source" | "target">>, builder.Node<builder.NodeClass<{
-        readonly description: "A named compositional Shell Identity.";
-        readonly implements: readonly [{
-            origin: "kernel.astrale.ai";
-            kind: 'interface';
-            name: string;
-        }, {
-            origin: "kernel.astrale.ai";
-            kind: 'interface';
-            name: string;
-        }, {
-            origin: "kernel.astrale.ai";
-            kind: 'interface';
-            name: string;
-        }];
-        readonly methods: {
-            assignUser: builder.Function<{
-                readonly description: string;
-                readonly input: import("zod").ZodObject<{
-                    user: builder.Path<readonly [builder.NodeInterface<{
-                        readonly description: "A human-facing Shell principal.";
-                        readonly extends: readonly [{
-                            origin: "kernel.astrale.ai";
-                            kind: 'interface';
-                            name: "Identity";
-                        }];
-                    }>]>;
-                }, import("zod/v4/core").$strict>;
-                readonly output: {
-                    type: 'object';
-                    properties: {};
-                    additionalProperties: boolean;
-                };
-                readonly auth: "authorized";
-                readonly policy: ({ check, self }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
-            }>;
-            unassignUser: builder.Function<{
-                readonly description: string;
-                readonly input: import("zod").ZodObject<{
-                    user: builder.Path<readonly [builder.NodeInterface<{
-                        readonly description: "A human-facing Shell principal.";
-                        readonly extends: readonly [{
-                            origin: "kernel.astrale.ai";
-                            kind: 'interface';
-                            name: "Identity";
-                        }];
-                    }>]>;
-                }, import("zod/v4/core").$strict>;
-                readonly output: {
-                    type: 'object';
-                    properties: {};
-                    additionalProperties: boolean;
-                };
-                readonly auth: "authorized";
-                readonly policy: ({ check, self }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
-            }>;
-        };
-    }>>>[];
+    edges: never[];
 };
-//# sourceMappingURL=core.d.ts.map

package/dist/schema/group/core.js

@@ -1,20 +1,14 @@
-import { edge, node } from '@astrale-os/sdk/schema';
-import { K } from '@astrale-os/sdk/schema/kernel';
+import { K, core } from '@astrale-os/sdk/schema';
 import { Group } from './class.js';
-import { administers_group } from './relationships.js';
-const identity = (subject, name, description) => node(Group, {
-    [K.Identity.$.property('iss').key]: 'shell.astrale.ai',
-    [K.Identity.$.property('sub').key]: subject,
-    [K.Named.$.property('name').key]: name,
-    [K.Descriptable.$.property('description').key]: description,
+const identity = (subject, name, description) => core.node(() => Group, {
+    [K.classes.Identity.self.properties.iss.key]: 'shell.astrale.ai',
+    [K.classes.Identity.self.properties.sub.key]: subject,
+    [K.classes.Named.self.properties.name.key]: name,
+    [K.classes.Descriptable.self.properties.description.key]: description,
 });
 export const adminGroup = identity('core.admin', 'Administrators', 'Users entrusted with Shell application-plane administration.');
 export const memberGroup = identity('core.member', 'Members', 'Users admitted to the common Shell application plane.');
 export const groupCore = {
     nodes: { admin: adminGroup, member: memberGroup },
-    edges: [
-        edge(adminGroup, administers_group, adminGroup, {}),
-        edge(adminGroup, administers_group, memberGroup, {}),
-    ],
+    edges: [],
 };
-//# sourceMappingURL=core.js.map

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

@@ -1,7 +1,6 @@
 export { Group } from './class.js';
 export { adminGroup, groupCore, memberGroup } from './core.js';
 export { groupAssignUser, groupUnassignUser, type GroupMembershipInput, type GroupMembershipResult, } from './methods.js';
-export { mayAdministerGroup } from './policies.js';
-export { administers_group, member_of_group } from './relationships.js';
+export { maySetupUsers } from './policies.js';
+export { member_of_group } from './relationships.js';
 export { groupView } from './view.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/schema/group/index.js

@@ -1,7 +1,6 @@
 export { Group } from './class.js';
 export { adminGroup, groupCore, memberGroup } from './core.js';
 export { groupAssignUser, groupUnassignUser, } from './methods.js';
-export { mayAdministerGroup } from './policies.js';
-export { administers_group, member_of_group } from './relationships.js';
+export { maySetupUsers } from './policies.js';
+export { member_of_group } from './relationships.js';
 export { groupView } from './view.js';
-//# sourceMappingURL=index.js.map