@astrale-domains/services 0.4.6 → 0.4.8

package/dist/schema/schema.d.ts

@@ -61,10 +61,10 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                 }, {
                     readonly mode: 'value';
                     readonly value: {
-                        name: string;
-                    } | {
                         kind: "rejected";
                         reason: "binding-unavailable" | "invalid-secret-name" | "service-unavailable";
+                    } | {
+                        name: string;
                     };
                 }, "authorized", false, true, undefined>>;
                 deleteSecret: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
@@ -72,10 +72,10 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                 }, {
                     readonly mode: 'value';
                     readonly value: {
+                        ok: true;
+                    } | {
                         kind: "rejected";
                         reason: "binding-unavailable" | "invalid-secret-name" | "service-unavailable";
-                    } | {
-                        ok: true;
                     };
                 }, "authorized", false, true, undefined>>;
                 secrets: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
@@ -182,10 +182,10 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                     }, {
                         readonly mode: 'value';
                         readonly value: {
-                            name: string;
-                        } | {
                             kind: "rejected";
                             reason: "binding-unavailable" | "invalid-secret-name" | "service-unavailable";
+                        } | {
+                            name: string;
                         };
                     }, "authorized", false, true, undefined>>;
                     deleteSecret: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
@@ -193,10 +193,10 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                     }, {
                         readonly mode: 'value';
                         readonly value: {
+                            ok: true;
+                        } | {
                             kind: "rejected";
                             reason: "binding-unavailable" | "invalid-secret-name" | "service-unavailable";
-                        } | {
-                            ok: true;
                         };
                     }, "authorized", false, true, undefined>>;
                     secrets: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
@@ -409,10 +409,10 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                 }, {
                     readonly mode: 'value';
                     readonly value: {
-                        name: string;
-                    } | {
                         kind: "rejected";
                         reason: "binding-unavailable" | "invalid-secret-name" | "service-unavailable";
+                    } | {
+                        name: string;
                     };
                 }, "authorized", false, false, undefined>>;
                 deleteSecret: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
@@ -420,10 +420,10 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                 }, {
                     readonly mode: 'value';
                     readonly value: {
+                        ok: true;
+                    } | {
                         kind: "rejected";
                         reason: "binding-unavailable" | "invalid-secret-name" | "service-unavailable";
-                    } | {
-                        ok: true;
                     };
                 }, "authorized", false, false, undefined>>;
                 secrets: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
@@ -525,6 +525,7 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                     };
                     readonly failed: {
                         readonly retry: "deploying";
+                        readonly retire: "retiring";
                     };
                 }, "deploying">, {
                     required?: boolean;
@@ -553,9 +554,65 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                         }, import("zod/v4/core").$strict>>;
                     }, import("zod/v4/core").$strict>>;
                 }, import("zod/v4/core").$strict>;
+                configuration: import("zod").ZodObject<{
+                    format: import("zod").ZodLiteral<"astrale.deployment.configuration">;
+                    version: import("zod").ZodLiteral<1>;
+                    vars: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+                    settings: import("zod").ZodObject<{
+                        maximumRequestBytes: import("zod").ZodNumber;
+                        invocationTimeoutMs: import("zod").ZodNumber;
+                        tokenExchange: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<false>, import("zod").ZodObject<{
+                            maximumLifetimeSeconds: import("zod").ZodNumber;
+                        }, import("zod/v4/core").$strict>]>;
+                        durableOptions: import("zod").ZodOptional<import("zod").ZodObject<{
+                            retentionMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                            retry: import("zod").ZodOptional<import("zod").ZodObject<{
+                                initialIntervalMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                                maxAttempts: import("zod").ZodOptional<import("zod").ZodNumber>;
+                                maxIntervalMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                            }, import("zod/v4/core").$strict>>;
+                            stepTimeoutMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                        }, import("zod/v4/core").$strict>>;
+                    }, import("zod/v4/core").$strict>;
+                    runtime: import("zod").ZodObject<{
+                        compatibilityDate: import("zod").ZodString;
+                        compatibilityFlags: import("zod").ZodArray<import("zod").ZodString>;
+                    }, import("zod/v4/core").$strict>;
+                    bindings: import("zod").ZodObject<{
+                        services: import("zod").ZodArray<import("zod").ZodObject<{
+                            name: import("zod").ZodString;
+                            service: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>>;
+                        dispatchNamespaces: import("zod").ZodArray<import("zod").ZodObject<{
+                            name: import("zod").ZodString;
+                            namespace: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>>;
+                        secrets: import("zod").ZodArray<import("zod").ZodString>;
+                    }, import("zod/v4/core").$strict>;
+                    router: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<false>, import("zod").ZodObject<{
+                        service: import("zod").ZodString;
+                        hostSuffix: import("zod").ZodString;
+                        minLabels: import("zod").ZodNumber;
+                    }, import("zod/v4/core").$strict>]>;
+                }, import("zod/v4/core").$strict>;
+                secretDigests: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodArray<import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    digest: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>>, {
+                    readonly required: false;
+                }>;
+                scriptEtag: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {
+                    readonly required: false;
+                }>;
                 signingKeyId: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {
                     readonly required: false;
                 }>;
+                activatedAt: import("@astrale-os/sdk/schema").AuthoredProperty<Readonly<{
+                    readonly type: 'string';
+                    readonly 'x-astrale-value-kind': 'instant';
+                }>, {
+                    readonly required: false;
+                }>;
                 lastCallAt: import("@astrale-os/sdk/schema").AuthoredProperty<Readonly<{
                     readonly type: 'string';
                     readonly 'x-astrale-value-kind': 'instant';
@@ -590,6 +647,26 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                     readonly required: false;
                 }>;
             };
+            readonly methods: {
+                setSecret: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                    value: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        name: string;
+                    } | {
+                        kind: "rejected";
+                        reason: "secret-undeclared" | "service-unavailable";
+                        message: string;
+                        retryAfter?: string | undefined;
+                    };
+                }, "authenticated", false, true, undefined>>;
+                secrets: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+                    readonly mode: 'value';
+                    readonly value: string[];
+                }, "authenticated", false, true, undefined>>;
+            };
         }>;
         readonly CloudflareDeployment: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
             readonly description: "One Deployment uploaded as the Workers for Platforms script its label names.";
@@ -618,6 +695,7 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                         };
                         readonly failed: {
                             readonly retry: "deploying";
+                            readonly retire: "retiring";
                         };
                     }, "deploying">, {
                         required?: boolean;
@@ -646,9 +724,65 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                             }, import("zod/v4/core").$strict>>;
                         }, import("zod/v4/core").$strict>>;
                     }, import("zod/v4/core").$strict>;
+                    configuration: import("zod").ZodObject<{
+                        format: import("zod").ZodLiteral<"astrale.deployment.configuration">;
+                        version: import("zod").ZodLiteral<1>;
+                        vars: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+                        settings: import("zod").ZodObject<{
+                            maximumRequestBytes: import("zod").ZodNumber;
+                            invocationTimeoutMs: import("zod").ZodNumber;
+                            tokenExchange: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<false>, import("zod").ZodObject<{
+                                maximumLifetimeSeconds: import("zod").ZodNumber;
+                            }, import("zod/v4/core").$strict>]>;
+                            durableOptions: import("zod").ZodOptional<import("zod").ZodObject<{
+                                retentionMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                                retry: import("zod").ZodOptional<import("zod").ZodObject<{
+                                    initialIntervalMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                                    maxAttempts: import("zod").ZodOptional<import("zod").ZodNumber>;
+                                    maxIntervalMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                                }, import("zod/v4/core").$strict>>;
+                                stepTimeoutMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                            }, import("zod/v4/core").$strict>>;
+                        }, import("zod/v4/core").$strict>;
+                        runtime: import("zod").ZodObject<{
+                            compatibilityDate: import("zod").ZodString;
+                            compatibilityFlags: import("zod").ZodArray<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strict>;
+                        bindings: import("zod").ZodObject<{
+                            services: import("zod").ZodArray<import("zod").ZodObject<{
+                                name: import("zod").ZodString;
+                                service: import("zod").ZodString;
+                            }, import("zod/v4/core").$strict>>;
+                            dispatchNamespaces: import("zod").ZodArray<import("zod").ZodObject<{
+                                name: import("zod").ZodString;
+                                namespace: import("zod").ZodString;
+                            }, import("zod/v4/core").$strict>>;
+                            secrets: import("zod").ZodArray<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strict>;
+                        router: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<false>, import("zod").ZodObject<{
+                            service: import("zod").ZodString;
+                            hostSuffix: import("zod").ZodString;
+                            minLabels: import("zod").ZodNumber;
+                        }, import("zod/v4/core").$strict>]>;
+                    }, import("zod/v4/core").$strict>;
+                    secretDigests: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodArray<import("zod").ZodObject<{
+                        name: import("zod").ZodString;
+                        digest: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>>, {
+                        readonly required: false;
+                    }>;
+                    scriptEtag: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {
+                        readonly required: false;
+                    }>;
                     signingKeyId: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {
                         readonly required: false;
                     }>;
+                    activatedAt: import("@astrale-os/sdk/schema").AuthoredProperty<Readonly<{
+                        readonly type: 'string';
+                        readonly 'x-astrale-value-kind': 'instant';
+                    }>, {
+                        readonly required: false;
+                    }>;
                     lastCallAt: import("@astrale-os/sdk/schema").AuthoredProperty<Readonly<{
                         readonly type: 'string';
                         readonly 'x-astrale-value-kind': 'instant';
@@ -683,7 +817,316 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                         readonly required: false;
                     }>;
                 };
+                readonly methods: {
+                    setSecret: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                        name: string;
+                        value: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            name: string;
+                        } | {
+                            kind: "rejected";
+                            reason: "secret-undeclared" | "service-unavailable";
+                            message: string;
+                            retryAfter?: string | undefined;
+                        };
+                    }, "authenticated", false, true, undefined>>;
+                    secrets: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+                        readonly mode: 'value';
+                        readonly value: string[];
+                    }, "authenticated", false, true, undefined>>;
+                };
             }>];
+            readonly methods: {
+                deploy: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    format: "astrale.services.deployment-request";
+                    version: 1;
+                    organization?: string | undefined;
+                    origin: string;
+                    environment: string;
+                    addressing: "opaque" | "readable";
+                    label: string;
+                    buildDigest: string;
+                    configuration: {
+                        format: "astrale.deployment.configuration";
+                        version: 1;
+                        vars: Record<string, string>;
+                        settings: {
+                            maximumRequestBytes: number;
+                            invocationTimeoutMs: number;
+                            tokenExchange: false | {
+                                maximumLifetimeSeconds: number;
+                            };
+                            durableOptions?: {
+                                retentionMs?: number | undefined;
+                                retry?: {
+                                    initialIntervalMs?: number | undefined;
+                                    maxAttempts?: number | undefined;
+                                    maxIntervalMs?: number | undefined;
+                                } | undefined;
+                                stepTimeoutMs?: number | undefined;
+                            } | undefined;
+                        };
+                        runtime: {
+                            compatibilityDate: string;
+                            compatibilityFlags: string[];
+                        };
+                        bindings: {
+                            services: {
+                                name: string;
+                                service: string;
+                            }[];
+                            dispatchNamespaces: {
+                                name: string;
+                                namespace: string;
+                            }[];
+                            secrets: string[];
+                        };
+                        router: false | {
+                            service: string;
+                            hostSuffix: string;
+                            minLabels: number;
+                        };
+                    };
+                    record: {
+                        releaseDigest: string;
+                        schemaRevision: string;
+                        schemaBundle: string;
+                        commit: {
+                            sha: string;
+                            dirty: boolean;
+                            base?: {
+                                version: string;
+                                distance: number;
+                            } | undefined;
+                        } | null;
+                    };
+                    bundle: {
+                        entrypoint: string;
+                        modules: ({
+                            name: string;
+                            kind?: "data" | "esm" | "text" | "wasm" | undefined;
+                            content: {
+                                encoding: "gzip" | "identity";
+                                decodedSize: number;
+                                contentBase64: string;
+                            } | {
+                                encoding: "gzip" | "identity";
+                                decodedSize: number;
+                                contentBase64Chunks: string[];
+                            };
+                        } | {
+                            contentBase64: string;
+                            name: string;
+                            kind?: "data" | "esm" | "text" | "wasm" | undefined;
+                        } | {
+                            contentBase64Chunks: string[];
+                            name: string;
+                            kind?: "data" | "esm" | "text" | "wasm" | undefined;
+                        })[];
+                        assets?: {
+                            files: ({
+                                path: string;
+                                contentType?: string | undefined;
+                                content: {
+                                    encoding: "gzip" | "identity";
+                                    decodedSize: number;
+                                    contentBase64: string;
+                                } | {
+                                    encoding: "gzip" | "identity";
+                                    decodedSize: number;
+                                    contentBase64Chunks: string[];
+                                };
+                            } | {
+                                contentBase64: string;
+                                path: string;
+                                contentType?: string | undefined;
+                            } | {
+                                contentBase64Chunks: string[];
+                                path: string;
+                                contentType?: string | undefined;
+                            })[];
+                            notFound?: "404-page" | "none" | "single-page-application" | undefined;
+                            runWorkerFirst?: boolean | undefined;
+                            htmlHandling?: "none" | undefined;
+                        } | undefined;
+                    };
+                    secrets: Record<string, string>;
+                    readiness?: {
+                        paths: string[];
+                    } | undefined;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        kind: "rejected";
+                        reason: "address-mismatch" | "build-mismatch" | "deployment-conflict" | "deployment-retired" | "hosting-unavailable" | "invalid-deployment" | "line-owned-elsewhere" | "service-unavailable";
+                        message: string;
+                        retryAfter?: string | undefined;
+                    } | {
+                        kind: "deployed";
+                        state: "created" | "reused";
+                        secrets: {
+                            state: "bound" | "unchanged" | "updated";
+                        };
+                        deployment: {
+                            id: string;
+                            url: string;
+                            label: string;
+                            line: string;
+                            owner: string;
+                            state: "active" | "deploying" | "failed" | "retired" | "retiring";
+                            retention: "preview" | "published";
+                            createdAt: string;
+                            lastCallAt?: string | undefined;
+                            expiresAt?: string | undefined;
+                            retiredAt?: string | undefined;
+                            retirement?: "expired" | "withdrawn" | undefined;
+                            signingKeyId: string;
+                            record: {
+                                format: "astrale.deployment-record";
+                                version: 1;
+                                origin: string;
+                                environment: string;
+                                releaseDigest: string;
+                                buildDigest: string;
+                                schemaRevision: string;
+                                configuration: string;
+                                providerScript: string;
+                                commit: {
+                                    sha: string;
+                                    dirty: boolean;
+                                    base?: {
+                                        version: string;
+                                        distance: number;
+                                    } | undefined;
+                                } | null;
+                            };
+                        };
+                    };
+                }, "authenticated", true, false, undefined>>;
+                hosting: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        routingDomain: string;
+                        addressing: "opaque" | "readable";
+                    };
+                }, "authenticated", true, false, undefined>>;
+                list: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    origin?: string | undefined;
+                    environment?: string | undefined;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        deployments: ({
+                            id: string;
+                            url: string;
+                            label: string;
+                            line: string;
+                            owner: string;
+                            state: "active" | "deploying" | "failed" | "retired" | "retiring";
+                            retention: "preview" | "published";
+                            createdAt: string;
+                            lastCallAt?: string | undefined;
+                            expiresAt?: string | undefined;
+                            retiredAt?: string | undefined;
+                            retirement?: "expired" | "withdrawn" | undefined;
+                            signingKeyId: string;
+                            record: {
+                                format: "astrale.deployment-record";
+                                version: 1;
+                                origin: string;
+                                environment: string;
+                                releaseDigest: string;
+                                buildDigest: string;
+                                schemaRevision: string;
+                                configuration: string;
+                                providerScript: string;
+                                commit: {
+                                    sha: string;
+                                    dirty: boolean;
+                                    base?: {
+                                        version: string;
+                                        distance: number;
+                                    } | undefined;
+                                } | null;
+                            };
+                        } | {
+                            id: string;
+                            url: string;
+                            label: string;
+                            line: string;
+                            owner: string;
+                            state: "active" | "deploying" | "failed" | "retired" | "retiring";
+                            retention: "preview" | "published";
+                            createdAt: string;
+                            lastCallAt?: string | undefined;
+                            expiresAt?: string | undefined;
+                            retiredAt?: string | undefined;
+                            retirement?: "expired" | "withdrawn" | undefined;
+                            signingKeyId: string;
+                            record: unknown;
+                        })[];
+                    };
+                }, "authenticated", true, false, undefined>>;
+                setSecret: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                    value: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        name: string;
+                    } | {
+                        kind: "rejected";
+                        reason: "secret-undeclared" | "service-unavailable";
+                        message: string;
+                        retryAfter?: string | undefined;
+                    };
+                }, "authenticated", false, false, undefined>>;
+                secrets: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+                    readonly mode: 'value';
+                    readonly value: string[];
+                }, "authenticated", false, false, undefined>>;
+                lastCalls: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    labels: string[];
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, string | null>;
+                }, "authenticated", true, false, undefined>>;
+                expirePreviews: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    limit?: number | undefined;
+                    apply?: boolean | undefined;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        planned: string[];
+                        retired: string[];
+                        pending: string[];
+                    };
+                }, "authenticated", true, false, undefined>>;
+                retain: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    label: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        retention: "published";
+                    };
+                }, "authenticated", true, false, undefined>>;
+                retire: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        kind: "retired";
+                    } | {
+                        kind: "retiring";
+                        retryAfterMs: number;
+                    } | {
+                        kind: "rejected";
+                        reason: "address-mismatch" | "build-mismatch" | "deployment-conflict" | "deployment-retired" | "hosting-unavailable" | "invalid-deployment" | "line-owned-elsewhere" | "service-unavailable";
+                        message: string;
+                        retryAfter?: string | undefined;
+                    };
+                }, "authenticated", false, false, undefined>>;
+            };
             readonly policies: {
                 read: () => import("@astrale-os/sdk/schema").Policy;
             };
@@ -726,6 +1169,7 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
         readonly TraverseOwnedService: import("@astrale-os/sdk/schema").Policy;
         readonly OwnLine: import("@astrale-os/sdk/schema").Policy;
         readonly OwnDeployment: import("@astrale-os/sdk/schema").Policy;
+        readonly ActForOrganization: import("@astrale-os/sdk/schema").Policy;
         readonly TraverseOwnedLine: import("@astrale-os/sdk/schema").Policy;
         readonly TraverseOwnedLineDeployment: import("@astrale-os/sdk/schema").Policy;
     };

package/dist/schema/schema.js

@@ -1,5 +1,5 @@
 import { KernelSchema, defineSchema, view } from '@astrale-os/sdk/schema';
-import { CloudflareDeployment, Deployment, DeploymentLine, OwnDeployment, OwnLine, TraverseOwnedLine, TraverseOwnedLineDeployment, deployment_on_line, line_owned_by, } from './modules/deployment/index.js';
+import { ActForOrganization, CloudflareDeployment, Deployment, DeploymentLine, OwnDeployment, OwnLine, TraverseOwnedLine, TraverseOwnedLineDeployment, deployment_on_line, line_owned_by, } from './modules/deployment/index.js';
 import { CloudflareWorker, OwnService, Service, TraverseOwnedService, service_owned_by, } from './modules/service/index.js';
 const origin = 'services.astrale.ai';
 const classes = {
@@ -17,6 +17,7 @@ const policies = {
     TraverseOwnedService,
     OwnLine,
     OwnDeployment,
+    ActForOrganization,
     TraverseOwnedLine,
     TraverseOwnedLineDeployment,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-domains/services",
-  "version": "0.4.6",
+  "version": "0.4.8",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/astrale-os/domains.git",
@@ -31,14 +31,14 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@astrale-os/sdk": "0.6.0-beta.11",
+    "@astrale-os/sdk": "0.6.0-beta.14",
     "zod": "4.4.3"
   },
   "devDependencies": {
-    "@astrale-os/adapter-cloudflare": "0.5.0-beta.166",
+    "@astrale-os/adapter-cloudflare": "0.5.0-beta.169",
     "@astrale-os/ox": ">=0.1.4 <1.0.0",
-    "@astrale-os/shell": "0.6.0-beta.7",
-    "@astrale-os/shell-react": "0.5.0-beta.7",
+    "@astrale-os/shell": "0.6.0-beta.8",
+    "@astrale-os/shell-react": "0.5.0-beta.8",
     "@astrale-os/ui": "0.3.0-beta.32",
     "@cloudflare/workers-types": "5.20260821.1",
     "@tailwindcss/vite": "^4.3.3",
@@ -71,15 +71,19 @@
     "workerd"
   ],
   "scripts": {
-    "dev": "astrale-domain dev",
     "deploy": "astrale-domain deploy",
     "build": "astrale-domain build",
     "lint": "astrale-domain lint",
     "lint:fix": "astrale-domain lint --fix",
     "package": "astrale-domain package && node tooling/package-scaffolder.mjs",
     "provider:bootstrap": "bun providers/cloudflare/operator/provision/bootstrap.ts",
+    "provider:deployment-audit": "bun providers/cloudflare/operator/maintenance/deployment-audit.ts",
     "provider:doctor": "bun providers/cloudflare/operator/maintenance/doctor.ts",
     "provider:orphan-audit": "bun providers/cloudflare/operator/maintenance/orphan-audit.ts",
+    "provider:platform-bootstrap": "bun providers/cloudflare/operator/platform-namespace/bootstrap.ts",
+    "provider:platform-expiry": "bun scripts/platform-namespace/expiry.ts",
+    "provider:platform-retire": "bun scripts/platform-namespace/retire.ts",
+    "provider:platform-secret": "bun providers/cloudflare/operator/platform-namespace/secret.ts",
     "provider:reclaim-service": "bun providers/cloudflare/operator/maintenance/reclaim-service.ts",
     "provider:route-wildcard": "bun providers/cloudflare/operator/routing/wildcard.ts",
     "provider:route-tenant": "bun providers/cloudflare/operator/routing/tenant.ts",