@astrale-domains/shell 0.1.0-beta.4

package/dist/schema/application/class.d.ts

@@ -0,0 +1,152 @@
+export declare const Application: import("@astrale-os/sdk/schema").NodeClass<{
+    readonly description: "A property-free Space association for one installed Domain.";
+    readonly methods: {
+        install: import("@astrale-os/sdk/schema").Function<{
+            readonly description: "Convergently associate one installed Domain with one Space.";
+            readonly static: true;
+            readonly input: import("zod").ZodObject<{
+                domain: import("@astrale-os/sdk/schema").Path<readonly [{
+                    origin: string;
+                    kind: 'class';
+                    name: string;
+                }]>;
+                space: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeClass<{
+                    readonly description: "A named Shell collaboration boundary.";
+                    readonly implements: readonly [{
+                        origin: "kernel.astrale.ai";
+                        kind: 'interface';
+                        name: string;
+                    }, {
+                        origin: "kernel.astrale.ai";
+                        kind: 'interface';
+                        name: string;
+                    }];
+                    readonly methods: {
+                        addUser: import("@astrale-os/sdk/schema").Function<{
+                            readonly description: "Set one User direct member or admin access.";
+                            readonly input: import("zod").ZodObject<{
+                                user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                                    readonly description: "A human-facing Shell principal.";
+                                    readonly extends: readonly [{
+                                        origin: "kernel.astrale.ai";
+                                        kind: 'interface';
+                                        name: "Identity";
+                                    }];
+                                }>]>;
+                                access: import("zod").ZodEnum<{
+                                    admin: "admin";
+                                    member: "member";
+                                }>;
+                            }, import("zod/v4/core").$strict>;
+                            readonly output: {
+                                type: 'object';
+                                properties: {};
+                                additionalProperties: boolean;
+                            };
+                            readonly auth: "authorized";
+                            readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                        }>;
+                        removeUser: import("@astrale-os/sdk/schema").Function<{
+                            readonly description: "Remove one User direct access.";
+                            readonly input: import("zod").ZodObject<{
+                                user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").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 }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                        }>;
+                        setDefault: import("@astrale-os/sdk/schema").Function<{
+                            readonly description: "Set this accessible Space as the granted User fallback.";
+                            readonly input: {
+                                type: 'object';
+                                properties: {};
+                                additionalProperties: boolean;
+                            };
+                            readonly output: {
+                                type: 'object';
+                                properties: {};
+                                additionalProperties: boolean;
+                            };
+                            readonly auth: "authorized";
+                            readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                        }>;
+                    };
+                }>]>;
+            }, import("zod/v4/core").$strict>;
+            readonly output: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly application: {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly id: {
+                                readonly type: "string";
+                            };
+                            readonly path: {
+                                type: 'string';
+                                pattern: string;
+                            };
+                            readonly class: {
+                                readonly const: "Application";
+                            };
+                        };
+                        readonly required: readonly ["id", "path", "class"];
+                        readonly additionalProperties: false;
+                    };
+                    readonly domain: {
+                        type: 'string';
+                        pattern: string;
+                    };
+                    readonly space: {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly id: {
+                                readonly type: "string";
+                            };
+                            readonly path: {
+                                type: 'string';
+                                pattern: string;
+                            };
+                            readonly class: {
+                                readonly const: "Space";
+                            };
+                        };
+                        readonly required: readonly ["id", "path", "class"];
+                        readonly additionalProperties: false;
+                    };
+                };
+                readonly required: readonly ["application", "domain", "space"];
+                readonly additionalProperties: false;
+            } & import("@astrale-os/sdk/schema").TypedValueSchema<import("./methods.js").InstallApplicationResult>;
+            readonly auth: "authorized";
+            readonly policy: ({ check, input }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+        }>;
+        uninstall: import("@astrale-os/sdk/schema").Function<{
+            readonly description: "Remove this Application association without uninstalling its Domain.";
+            readonly input: {
+                type: 'object';
+                properties: {};
+                additionalProperties: boolean;
+            };
+            readonly output: {
+                type: 'object';
+                properties: {};
+                additionalProperties: boolean;
+            } & import("@astrale-os/sdk/schema").TypedValueSchema<import("./methods.js").UninstallApplicationResult>;
+            readonly auth: "authorized";
+            readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+        }>;
+    };
+}>;
+//# sourceMappingURL=class.d.ts.map

package/dist/schema/application/class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"class.d.ts","sourceRoot":"","sources":["../../../schema/application/class.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW;;;QAGpB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QACP,SAAS;;;;;;;;;;;;;;;;EAEX,CAAA"}

package/dist/schema/application/class.js

@@ -0,0 +1,10 @@
+import { nodeClass } from '@astrale-os/sdk/schema';
+import { applicationInstall, applicationUninstall } from './methods.js';
+export const Application = nodeClass({
+    description: 'A property-free Space association for one installed Domain.',
+    methods: {
+        install: applicationInstall,
+        uninstall: applicationUninstall,
+    },
+});
+//# sourceMappingURL=class.js.map

package/dist/schema/application/class.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"class.js","sourceRoot":"","sources":["../../../schema/application/class.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAElD,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA;AAEvE,MAAM,CAAC,MAAM,WAAW,GAAG,SAAS,CAAC;IACnC,WAAW,EAAE,6DAA6D;IAC1E,OAAO,EAAE;QACP,OAAO,EAAE,kBAAkB;QAC3B,SAAS,EAAE,oBAAoB;KAChC;CACF,CAAC,CAAA"}

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

@@ -0,0 +1,159 @@
+import { type builder } from '@astrale-os/sdk/schema';
+export declare const shellApplication: builder.Node<builder.NodeClass<{
+    readonly description: "A property-free Space association for one installed Domain.";
+    readonly methods: {
+        install: builder.Function<{
+            readonly description: "Convergently associate one installed Domain with one Space.";
+            readonly static: true;
+            readonly input: import("zod").ZodObject<{
+                domain: builder.Path<readonly [{
+                    origin: string;
+                    kind: 'class';
+                    name: string;
+                }]>;
+                space: builder.Path<readonly [builder.NodeClass<{
+                    readonly description: "A named Shell collaboration boundary.";
+                    readonly implements: readonly [{
+                        origin: "kernel.astrale.ai";
+                        kind: 'interface';
+                        name: string;
+                    }, {
+                        origin: "kernel.astrale.ai";
+                        kind: 'interface';
+                        name: string;
+                    }];
+                    readonly methods: {
+                        addUser: builder.Function<{
+                            readonly description: "Set one User direct member or admin access.";
+                            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";
+                                    }];
+                                }>]>;
+                                access: import("zod").ZodEnum<{
+                                    admin: "admin";
+                                    member: "member";
+                                }>;
+                            }, 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;
+                        }>;
+                        removeUser: builder.Function<{
+                            readonly description: "Remove one User direct access.";
+                            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;
+                        }>;
+                        setDefault: builder.Function<{
+                            readonly description: "Set this accessible Space as the granted User fallback.";
+                            readonly input: {
+                                type: 'object';
+                                properties: {};
+                                additionalProperties: boolean;
+                            };
+                            readonly output: {
+                                type: 'object';
+                                properties: {};
+                                additionalProperties: boolean;
+                            };
+                            readonly auth: "authorized";
+                            readonly policy: ({ check, self }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                        }>;
+                    };
+                }>]>;
+            }, import("zod/v4/core").$strict>;
+            readonly output: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly application: {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly id: {
+                                readonly type: "string";
+                            };
+                            readonly path: {
+                                type: 'string';
+                                pattern: string;
+                            };
+                            readonly class: {
+                                readonly const: "Application";
+                            };
+                        };
+                        readonly required: readonly ["id", "path", "class"];
+                        readonly additionalProperties: false;
+                    };
+                    readonly domain: {
+                        type: 'string';
+                        pattern: string;
+                    };
+                    readonly space: {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly id: {
+                                readonly type: "string";
+                            };
+                            readonly path: {
+                                type: 'string';
+                                pattern: string;
+                            };
+                            readonly class: {
+                                readonly const: "Space";
+                            };
+                        };
+                        readonly required: readonly ["id", "path", "class"];
+                        readonly additionalProperties: false;
+                    };
+                };
+                readonly required: readonly ["application", "domain", "space"];
+                readonly additionalProperties: false;
+            } & builder.TypedValueSchema<import("./methods.js").InstallApplicationResult>;
+            readonly auth: "authorized";
+            readonly policy: ({ check, input }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+        }>;
+        uninstall: builder.Function<{
+            readonly description: "Remove this Application association without uninstalling its Domain.";
+            readonly input: {
+                type: 'object';
+                properties: {};
+                additionalProperties: boolean;
+            };
+            readonly output: {
+                type: 'object';
+                properties: {};
+                additionalProperties: boolean;
+            } & builder.TypedValueSchema<import("./methods.js").UninstallApplicationResult>;
+            readonly auth: "authorized";
+            readonly policy: ({ check, self }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+        }>;
+    };
+}>>;
+export declare const applicationCore: Readonly<{
+    nodes: Readonly<{
+        shell: typeof shellApplication;
+    }>;
+    edges: NonNullable<builder.Core['edges']>;
+}>;
+//# sourceMappingURL=core.d.ts.map

package/dist/schema/application/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../schema/application/core.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,OAAO,EAAE,MAAM,wBAAwB,CAAA;AAOzE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAwB,CAAA;AAErD,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC;IACrC,KAAK,EAAE,QAAQ,CAAC;QAAE,KAAK,EAAE,OAAO,gBAAgB,CAAA;KAAE,CAAC,CAAA;IACnD,KAAK,EAAE,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAA;CAC1C,CAMA,CAAA"}

package/dist/schema/application/core.js

@@ -0,0 +1,13 @@
+import { domain, edge, node } from '@astrale-os/sdk/schema';
+import { defaultSpace } from '#schema/space';
+import { Application } from './class.js';
+import { application_of, installed_in } from './relationships.js';
+export const shellApplication = node(Application, {});
+export const applicationCore = {
+    nodes: { shell: shellApplication },
+    edges: [
+        edge(shellApplication, installed_in, defaultSpace, {}),
+        edge(shellApplication, application_of, domain(), {}),
+    ],
+};
+//# sourceMappingURL=core.js.map

package/dist/schema/application/core.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.js","sourceRoot":"","sources":["../../../schema/application/core.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAgB,MAAM,wBAAwB,CAAA;AAEzE,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAE5C,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AACxC,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEjE,MAAM,CAAC,MAAM,gBAAgB,GAAG,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC,CAAA;AAErD,MAAM,CAAC,MAAM,eAAe,GAGvB;IACH,KAAK,EAAE,EAAE,KAAK,EAAE,gBAAgB,EAAE;IAClC,KAAK,EAAE;QACL,IAAI,CAAC,gBAAgB,EAAE,YAAY,EAAE,YAAY,EAAE,EAAE,CAAC;QACtD,IAAI,CAAC,gBAAgB,EAAE,cAAc,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;KACrD;CACF,CAAA"}

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

@@ -0,0 +1,7 @@
+export { Application } from './class.js';
+export { applicationCore, shellApplication } from './core.js';
+export { applicationInstall, applicationUninstall, type InstallApplicationInput, type InstallApplicationResult, type UninstallApplicationInput, type UninstallApplicationResult, } from './methods.js';
+export { mayAdministerApplication } from './policies.js';
+export { application_of, installed_in } from './relationships.js';
+export { applicationView } from './view.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../schema/application/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AACxC,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAA;AAC7D,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC9B,KAAK,0BAA0B,GAChC,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAA;AACxD,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACjE,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA"}

package/dist/schema/application/index.js

@@ -0,0 +1,7 @@
+export { Application } from './class.js';
+export { applicationCore, shellApplication } from './core.js';
+export { applicationInstall, applicationUninstall, } from './methods.js';
+export { mayAdministerApplication } from './policies.js';
+export { application_of, installed_in } from './relationships.js';
+export { applicationView } from './view.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../schema/application/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AACxC,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAA;AAC7D,OAAO,EACL,kBAAkB,EAClB,oBAAoB,GAKrB,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAA;AACxD,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACjE,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA"}

package/dist/schema/application/methods.d.ts

@@ -0,0 +1,171 @@
+import type { NodeId } from '@astrale-os/sdk/graph/node';
+import type { NodePath, PathLike } from '@astrale-os/sdk/graph/path';
+import { z } from 'zod';
+export interface InstallApplicationInput {
+    readonly domain: PathLike;
+    readonly space: PathLike;
+}
+export interface InstallApplicationResult {
+    readonly application: {
+        readonly id: NodeId;
+        readonly path: NodePath;
+        readonly class: 'Application';
+    };
+    readonly domain: NodePath;
+    readonly space: {
+        readonly id: NodeId;
+        readonly path: NodePath;
+        readonly class: 'Space';
+    };
+}
+export interface UninstallApplicationInput extends Readonly<Record<never, never>> {
+}
+export interface UninstallApplicationResult extends Readonly<Record<never, never>> {
+}
+export declare const applicationInstall: import("@astrale-os/sdk/schema").Function<{
+    readonly description: "Convergently associate one installed Domain with one Space.";
+    readonly static: true;
+    readonly input: z.ZodObject<{
+        domain: import("@astrale-os/sdk/schema").Path<readonly [{
+            origin: string;
+            kind: 'class';
+            name: string;
+        }]>;
+        space: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeClass<{
+            readonly description: "A named Shell collaboration boundary.";
+            readonly implements: readonly [{
+                origin: "kernel.astrale.ai";
+                kind: 'interface';
+                name: string;
+            }, {
+                origin: "kernel.astrale.ai";
+                kind: 'interface';
+                name: string;
+            }];
+            readonly methods: {
+                addUser: import("@astrale-os/sdk/schema").Function<{
+                    readonly description: "Set one User direct member or admin access.";
+                    readonly input: z.ZodObject<{
+                        user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                            readonly description: "A human-facing Shell principal.";
+                            readonly extends: readonly [{
+                                origin: "kernel.astrale.ai";
+                                kind: 'interface';
+                                name: "Identity";
+                            }];
+                        }>]>;
+                        access: z.ZodEnum<{
+                            admin: "admin";
+                            member: "member";
+                        }>;
+                    }, z.core.$strict>;
+                    readonly output: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    };
+                    readonly auth: "authorized";
+                    readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+                removeUser: import("@astrale-os/sdk/schema").Function<{
+                    readonly description: "Remove one User direct access.";
+                    readonly input: z.ZodObject<{
+                        user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                            readonly description: "A human-facing Shell principal.";
+                            readonly extends: readonly [{
+                                origin: "kernel.astrale.ai";
+                                kind: 'interface';
+                                name: "Identity";
+                            }];
+                        }>]>;
+                    }, z.core.$strict>;
+                    readonly output: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    };
+                    readonly auth: "authorized";
+                    readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+                setDefault: import("@astrale-os/sdk/schema").Function<{
+                    readonly description: "Set this accessible Space as the granted User fallback.";
+                    readonly input: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    };
+                    readonly output: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    };
+                    readonly auth: "authorized";
+                    readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+            };
+        }>]>;
+    }, z.core.$strict>;
+    readonly output: {
+        readonly type: "object";
+        readonly properties: {
+            readonly application: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly id: {
+                        readonly type: "string";
+                    };
+                    readonly path: {
+                        type: 'string';
+                        pattern: string;
+                    };
+                    readonly class: {
+                        readonly const: "Application";
+                    };
+                };
+                readonly required: readonly ["id", "path", "class"];
+                readonly additionalProperties: false;
+            };
+            readonly domain: {
+                type: 'string';
+                pattern: string;
+            };
+            readonly space: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly id: {
+                        readonly type: "string";
+                    };
+                    readonly path: {
+                        type: 'string';
+                        pattern: string;
+                    };
+                    readonly class: {
+                        readonly const: "Space";
+                    };
+                };
+                readonly required: readonly ["id", "path", "class"];
+                readonly additionalProperties: false;
+            };
+        };
+        readonly required: readonly ["application", "domain", "space"];
+        readonly additionalProperties: false;
+    } & import("@astrale-os/sdk/schema").TypedValueSchema<InstallApplicationResult>;
+    readonly auth: "authorized";
+    readonly policy: ({ check, input }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+}>;
+export declare const applicationUninstall: import("@astrale-os/sdk/schema").Function<{
+    readonly description: "Remove this Application association without uninstalling its Domain.";
+    readonly input: {
+        type: 'object';
+        properties: {};
+        additionalProperties: boolean;
+    };
+    readonly output: {
+        type: 'object';
+        properties: {};
+        additionalProperties: boolean;
+    } & import("@astrale-os/sdk/schema").TypedValueSchema<UninstallApplicationResult>;
+    readonly auth: "authorized";
+    readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+}>;
+//# sourceMappingURL=methods.d.ts.map

package/dist/schema/application/methods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"methods.d.ts","sourceRoot":"","sources":["../../../schema/application/methods.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAA;AACxD,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAA;AAGpE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAcvB,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAA;CACzB;AACD,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,WAAW,EAAE;QACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;QACnB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;QACvB,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAA;KAC9B,CAAA;IACD,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE;QAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;KAAE,CAAA;CAC1F;AACD,MAAM,WAAW,yBAA0B,SAAQ,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;CAAG;AACpF,MAAM,WAAW,0BAA2B,SAAQ,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;CAAG;AAwBrF,eAAO,MAAM,kBAAkB;;;;;;kBAxC2B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BADxC,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgD/B,CAAA;AAEF,eAAO,MAAM,oBAAoB;;;cAtDzB,QAAQ;;;;;;;;;;;EA4Dd,CAAA"}

package/dist/schema/application/methods.js

@@ -0,0 +1,48 @@
+import { fn, path, valueSchema } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { Space, mayAdministerSpace } from '#schema/space';
+import { mayAdministerApplication } from './policies.js';
+const emptyObject = {
+    type: 'object',
+    properties: {},
+    additionalProperties: false,
+};
+const nodePath = { type: 'string', pattern: '^/' };
+const KernelDomain = { origin: 'kernel.astrale.ai', kind: 'class', name: 'Domain' };
+const installApplicationResult = valueSchema()({
+    type: 'object',
+    properties: {
+        application: {
+            type: 'object',
+            properties: { id: { type: 'string' }, path: nodePath, class: { const: 'Application' } },
+            required: ['id', 'path', 'class'],
+            additionalProperties: false,
+        },
+        domain: nodePath,
+        space: {
+            type: 'object',
+            properties: { id: { type: 'string' }, path: nodePath, class: { const: 'Space' } },
+            required: ['id', 'path', 'class'],
+            additionalProperties: false,
+        },
+    },
+    required: ['application', 'domain', 'space'],
+    additionalProperties: false,
+});
+const uninstallApplicationResult = valueSchema()(emptyObject);
+export const applicationInstall = fn({
+    description: 'Convergently associate one installed Domain with one Space.',
+    static: true,
+    input: z.strictObject({ domain: path(KernelDomain), space: path(Space) }),
+    output: installApplicationResult,
+    auth: 'authorized',
+    policy: ({ check, input }) => check(mayAdministerSpace, input.space),
+});
+export const applicationUninstall = fn({
+    description: 'Remove this Application association without uninstalling its Domain.',
+    input: emptyObject,
+    output: uninstallApplicationResult,
+    auth: 'authorized',
+    policy: ({ check, self }) => check(mayAdministerApplication, self),
+});
+//# sourceMappingURL=methods.js.map

package/dist/schema/application/methods.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"methods.js","sourceRoot":"","sources":["../../../schema/application/methods.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAC9D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAE,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAA;AAEzD,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAA;AAExD,MAAM,WAAW,GAAG;IAClB,IAAI,EAAE,QAAiB;IACvB,UAAU,EAAE,EAAE;IACd,oBAAoB,EAAE,KAAK;CAC5B,CAAA;AACD,MAAM,QAAQ,GAAG,EAAE,IAAI,EAAE,QAAiB,EAAE,OAAO,EAAE,IAAI,EAAE,CAAA;AAC3D,MAAM,YAAY,GAAG,EAAE,MAAM,EAAE,mBAAmB,EAAE,IAAI,EAAE,OAAgB,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAA;AAkB5F,MAAM,wBAAwB,GAAG,WAAW,EAA4B,CAAC;IACvE,IAAI,EAAE,QAAQ;IACd,UAAU,EAAE;QACV,WAAW,EAAE;YACX,IAAI,EAAE,QAAQ;YACd,UAAU,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE,EAAE;YACvF,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC;YACjC,oBAAoB,EAAE,KAAK;SAC5B;QACD,MAAM,EAAE,QAAQ;QAChB,KAAK,EAAE;YACL,IAAI,EAAE,QAAQ;YACd,UAAU,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE;YACjF,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC;YACjC,oBAAoB,EAAE,KAAK;SAC5B;KACF;IACD,QAAQ,EAAE,CAAC,aAAa,EAAE,QAAQ,EAAE,OAAO,CAAC;IAC5C,oBAAoB,EAAE,KAAK;CAC5B,CAAC,CAAA;AACF,MAAM,0BAA0B,GAAG,WAAW,EAA8B,CAAC,WAAW,CAAC,CAAA;AAEzF,MAAM,CAAC,MAAM,kBAAkB,GAAG,EAAE,CAAC;IACnC,WAAW,EAAE,6DAA6D;IAC1E,MAAM,EAAE,IAAI;IACZ,KAAK,EAAE,CAAC,CAAC,YAAY,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;IACzE,MAAM,EAAE,wBAAwB;IAChC,IAAI,EAAE,YAAY;IAClB,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,kBAAkB,EAAE,KAAK,CAAC,KAAK,CAAC;CACrE,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAG,EAAE,CAAC;IACrC,WAAW,EAAE,sEAAsE;IACnF,KAAK,EAAE,WAAW;IAClB,MAAM,EAAE,0BAA0B;IAClC,IAAI,EAAE,YAAY;IAClB,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,wBAAwB,EAAE,IAAI,CAAC;CACnE,CAAC,CAAA"}

package/dist/schema/application/policies.d.ts

@@ -0,0 +1,3 @@
+import { type builder } from '@astrale-os/sdk/schema';
+export declare const mayAdministerApplication: builder.Policy;
+//# sourceMappingURL=policies.d.ts.map

package/dist/schema/application/policies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policies.d.ts","sourceRoot":"","sources":["../../../schema/application/policies.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,OAAO,EAAE,MAAM,wBAAwB,CAAA;AAMnE,eAAO,MAAM,wBAAwB,EAAE,OAAO,CAAC,MAa7C,CAAA"}

package/dist/schema/application/policies.js

@@ -0,0 +1,11 @@
+import { definePolicy } from '@astrale-os/sdk/schema';
+import { Space, administers_space, owns_space } from '#schema/space';
+import { installed_in } from './relationships.js';
+export const mayAdministerApplication = definePolicy({
+    description: 'The effective User Grant administers the Application Space.',
+    match: ({ allOf, anyOf, edge, exists, object, subject }) => exists(({ node }) => {
+        const space = node(Space);
+        return allOf(edge({ source: object, class: installed_in, target: space }), anyOf(edge({ source: subject, class: owns_space, target: space }), edge({ source: subject, class: administers_space, target: space })));
+    }),
+});
+//# sourceMappingURL=policies.js.map

package/dist/schema/application/policies.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"policies.js","sourceRoot":"","sources":["../../../schema/application/policies.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAgB,MAAM,wBAAwB,CAAA;AAEnE,OAAO,EAAE,KAAK,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAEpE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEjD,MAAM,CAAC,MAAM,wBAAwB,GAAmB,YAAY,CAAC;IACnE,WAAW,EAAE,6DAA6D;IAC1E,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,EAAE,CACzD,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE;QAClB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,CAAA;QACzB,OAAO,KAAK,CACV,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAC5D,KAAK,CACH,IAAI,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAC3D,IAAI,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,iBAAiB,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CACnE,CACF,CAAA;IACH,CAAC,CAAC;CACL,CAAC,CAAA"}