@astrale-domains/services 0.4.5 → 0.4.7

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

@@ -0,0 +1,189 @@
+import { z } from 'zod';
+/**
+ * One immutable deployment of a release: one build in one environment with its frozen
+ * configuration, served by one script at its own URL. It never changes code; a new release is a
+ * new deployment on the same line. Its secrets alone rotate in place, on this deployment only,
+ * and only under the names its configuration declares: a name added or removed is a new release.
+ */
+export declare const Deployment: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+    readonly abstract: true;
+    readonly description: "One immutable deployment of a release on a publisher line.";
+    readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+    readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
+    readonly properties: {
+        /** `<line>-<content16>`, the DNS label and provider script name of this deployment. */
+        label: z.ZodString;
+        url: z.ZodString;
+        state: import("@astrale-os/sdk/schema").StateProperty<import("@astrale-os/sdk/schema").StateMachine<{
+            readonly deploying: {
+                readonly activate: "active";
+                readonly fail: "failed";
+            };
+            readonly active: {
+                readonly retire: "retiring";
+            };
+            readonly retiring: {
+                readonly completeRetirement: "retired";
+            };
+            readonly retired: {
+                readonly revive: "deploying";
+            };
+            readonly failed: {
+                readonly retry: "deploying";
+                readonly retire: "retiring";
+            };
+        }, "deploying">, {
+            required?: boolean;
+            description?: string;
+        }>;
+        retention: z.ZodEnum<{
+            preview: "preview";
+            published: "published";
+        }>;
+        record: z.ZodObject<{
+            format: z.ZodLiteral<"astrale.deployment-record">;
+            version: z.ZodLiteral<1>;
+            origin: z.ZodString;
+            environment: z.ZodString;
+            releaseDigest: z.ZodString;
+            buildDigest: z.ZodString;
+            schemaRevision: z.ZodString;
+            configuration: z.ZodString;
+            providerScript: z.ZodString;
+            commit: z.ZodNullable<z.ZodObject<{
+                sha: z.ZodString;
+                dirty: z.ZodBoolean;
+                base: z.ZodOptional<z.ZodObject<{
+                    version: z.ZodString;
+                    distance: z.ZodNumber;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        /** The configuration frozen into this deployment; its digest is `record.configuration`. */
+        configuration: z.ZodObject<{
+            format: z.ZodLiteral<"astrale.deployment.configuration">;
+            version: z.ZodLiteral<1>;
+            vars: z.ZodRecord<z.ZodString, z.ZodString>;
+            settings: z.ZodObject<{
+                maximumRequestBytes: z.ZodNumber;
+                invocationTimeoutMs: z.ZodNumber;
+                tokenExchange: z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodObject<{
+                    maximumLifetimeSeconds: z.ZodNumber;
+                }, z.core.$strict>]>;
+                durableOptions: z.ZodOptional<z.ZodObject<{
+                    retentionMs: z.ZodOptional<z.ZodNumber>;
+                    retry: z.ZodOptional<z.ZodObject<{
+                        initialIntervalMs: z.ZodOptional<z.ZodNumber>;
+                        maxAttempts: z.ZodOptional<z.ZodNumber>;
+                        maxIntervalMs: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                    stepTimeoutMs: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            runtime: z.ZodObject<{
+                compatibilityDate: z.ZodString;
+                compatibilityFlags: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            bindings: z.ZodObject<{
+                services: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    service: z.ZodString;
+                }, z.core.$strict>>;
+                dispatchNamespaces: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    namespace: z.ZodString;
+                }, z.core.$strict>>;
+                secrets: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            router: z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodObject<{
+                service: z.ZodString;
+                hostSuffix: z.ZodString;
+                minLabels: z.ZodNumber;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>;
+        /** The keyed digest of each secret bound to this deployment, never a value. */
+        secretDigests: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>>, {
+            readonly required: false;
+        }>;
+        /**
+         * The provider's code hash of the script. With the artifact tag and the configuration digest it
+         * identifies the deployment; a secret rewritten in place keeps it, unlike a provider version.
+         */
+        scriptEtag: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodString, {
+            readonly required: false;
+        }>;
+        signingKeyId: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodString, {
+            readonly required: false;
+        }>;
+        /**
+         * The last time this deployment became active: its creation, or its revival after it expired.
+         * A preview's 30 days run from it or from its last call, whichever is later.
+         */
+        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';
+        }>, {
+            readonly required: false;
+        }>;
+        expiresAt: import("@astrale-os/sdk/schema").AuthoredProperty<Readonly<{
+            readonly type: 'string';
+            readonly 'x-astrale-value-kind': 'instant';
+        }>, {
+            readonly required: false;
+        }>;
+        retiredAt: import("@astrale-os/sdk/schema").AuthoredProperty<Readonly<{
+            readonly type: 'string';
+            readonly 'x-astrale-value-kind': 'instant';
+        }>, {
+            readonly required: false;
+        }>;
+        retirement: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodEnum<{
+            expired: "expired";
+            withdrawn: "withdrawn";
+        }>, {
+            readonly required: false;
+        }>;
+        /**
+         * The graph lease of the provider operation in flight on this deployment: its creation, or an
+         * in-place rewrite of its secrets once it serves.
+         */
+        operationReceipt: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodString, {
+            readonly required: false;
+        }>;
+        operationExpiresAt: import("@astrale-os/sdk/schema").AuthoredProperty<Readonly<{
+            readonly type: 'string';
+            readonly 'x-astrale-value-kind': 'instant';
+        }>, {
+            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>>;
+    };
+}>;

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

@@ -0,0 +1,56 @@
+import { classIcon, K, nodeClass, property, schema as valueSchema, stateProperty, } from '@astrale-os/sdk/schema';
+import { Rocket } from '@astrale-os/sdk/schema/icons';
+import { z } from 'zod';
+import { listDeploymentSecretNames } from '../functions/list-deployment-secret-names.js';
+import { setDeploymentSecret } from '../functions/set-deployment-secret.js';
+import { deploymentLifecycle } from '../states/index.js';
+import { deploymentRecord, deploymentRetention, deploymentRetirement, deploymentSecretDigests, frozenConfiguration, } from '../types/index.js';
+/**
+ * One immutable deployment of a release: one build in one environment with its frozen
+ * configuration, served by one script at its own URL. It never changes code; a new release is a
+ * new deployment on the same line. Its secrets alone rotate in place, on this deployment only,
+ * and only under the names its configuration declares: a name added or removed is a new release.
+ */
+export const Deployment = nodeClass({
+    abstract: true,
+    description: 'One immutable deployment of a release on a publisher line.',
+    icon: classIcon.lucide(Rocket),
+    extends: [K.classes.Timestamped],
+    properties: {
+        /** `<line>-<content16>`, the DNS label and provider script name of this deployment. */
+        label: z.string().min(33).max(57),
+        url: z.string().min(1).max(2_048),
+        state: stateProperty(deploymentLifecycle),
+        retention: deploymentRetention,
+        record: deploymentRecord,
+        /** The configuration frozen into this deployment; its digest is `record.configuration`. */
+        configuration: frozenConfiguration,
+        /** The keyed digest of each secret bound to this deployment, never a value. */
+        secretDigests: property(deploymentSecretDigests, { required: false }),
+        /**
+         * The provider's code hash of the script. With the artifact tag and the configuration digest it
+         * identifies the deployment; a secret rewritten in place keeps it, unlike a provider version.
+         */
+        scriptEtag: property(z.string().min(1).max(128), { required: false }),
+        signingKeyId: property(z.string().min(1).max(128), { required: false }),
+        /**
+         * The last time this deployment became active: its creation, or its revival after it expired.
+         * A preview's 30 days run from it or from its last call, whichever is later.
+         */
+        activatedAt: property(valueSchema.values.instant, { required: false }),
+        lastCallAt: property(valueSchema.values.instant, { required: false }),
+        expiresAt: property(valueSchema.values.instant, { required: false }),
+        retiredAt: property(valueSchema.values.instant, { required: false }),
+        retirement: property(deploymentRetirement, { required: false }),
+        /**
+         * The graph lease of the provider operation in flight on this deployment: its creation, or an
+         * in-place rewrite of its secrets once it serves.
+         */
+        operationReceipt: property(z.string().min(1).max(128), { required: false }),
+        operationExpiresAt: property(valueSchema.values.instant, { required: false }),
+    },
+    methods: {
+        setSecret: setDeploymentSecret,
+        secrets: listDeploymentSecretNames,
+    },
+});

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

@@ -0,0 +1,5 @@
+export { CloudflareDeployment } from './cloudflare-deployment.js';
+export { Deployment } from './deployment.js';
+export { DeploymentLine } from './deployment-line.js';
+export { deployment_on_line } from './deployment-on-line.js';
+export { line_owned_by } from './line-owned-by.js';

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

@@ -0,0 +1,5 @@
+export { CloudflareDeployment } from './cloudflare-deployment.js';
+export { Deployment } from './deployment.js';
+export { DeploymentLine } from './deployment-line.js';
+export { deployment_on_line } from './deployment-on-line.js';
+export { line_owned_by } from './line-owned-by.js';

package/dist/schema/modules/deployment/classes/line-owned-by.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The organisation holding one deployment line: an Identity of the Admin instance, a Shell User
+ * or Group, whose members and CI identities act for it through `extends_with`. A line outlives
+ * this Edge: deleting its organisation removes the Edge and leaves the line held by nobody until
+ * an operator transfer.
+ *
+ * Hence at most one holder, not exactly one: the Kernel deletes a Node only together with every
+ * incident Edge, so a required holder would make the organisation undeletable unless its lines
+ * went with it, and a deleted line would free its fingerprint for another organisation.
+ */
+export declare const line_owned_by: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+    readonly depth: 0;
+    readonly abstract: false;
+    readonly extends: readonly [];
+    readonly properties: never;
+    readonly source: {
+        readonly as: "line";
+        readonly outgoing: "0..1";
+    };
+    readonly target: {
+        readonly as: "owner";
+        readonly incoming: "0..*";
+    };
+    readonly constraints: Record<never, never>;
+    readonly effectiveProperties: never;
+}>;

package/dist/schema/modules/deployment/classes/line-owned-by.js

@@ -0,0 +1,19 @@
+import { edgeClass, K } from '@astrale-os/sdk/schema';
+import { TraverseOwnedLine } from '../policies/traverse-owned-line.js';
+import { DeploymentLine } from './deployment-line.js';
+/**
+ * The organisation holding one deployment line: an Identity of the Admin instance, a Shell User
+ * or Group, whose members and CI identities act for it through `extends_with`. A line outlives
+ * this Edge: deleting its organisation removes the Edge and leaves the line held by nobody until
+ * an operator transfer.
+ *
+ * Hence at most one holder, not exactly one: the Kernel deletes a Node only together with every
+ * incident Edge, so a required holder would make the organisation undeletable unless its lines
+ * went with it, and a deleted line would free its fingerprint for another organisation.
+ */
+export const line_owned_by = edgeClass.directed({
+    description: 'The organisation that holds one deployment line.',
+    source: { as: 'line', accepts: [() => DeploymentLine], outgoing: '0..1' },
+    target: { as: 'owner', accepts: [K.classes.Identity], incoming: '0..*' },
+    policies: { traverse: () => TraverseOwnedLine },
+});

package/dist/schema/modules/deployment/errors/deployment-hosting-unavailable.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+/** Asked of a Services runtime that hosts no deployments: only Admin's Services host them. */
+export declare const deploymentHostingUnavailable: Readonly<{
+    readonly family: "UNSUPPORTED";
+    readonly message: "This Services runtime does not host deployments.";
+    readonly details: z.ZodObject<{}, z.core.$strict>;
+}>;

package/dist/schema/modules/deployment/errors/deployment-hosting-unavailable.js

@@ -0,0 +1,8 @@
+import { error } from '@astrale-os/sdk/schema/errors';
+import { z } from 'zod';
+/** Asked of a Services runtime that hosts no deployments: only Admin's Services host them. */
+export const deploymentHostingUnavailable = error({
+    family: 'UNSUPPORTED',
+    message: 'This Services runtime does not host deployments.',
+    details: z.strictObject({}),
+});

package/dist/schema/modules/deployment/errors/deployment-label-not-found.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+/**
+ * A label that names no deployment the caller may read: an unknown label and another
+ * organisation's deployment answer alike, so the answer never tells one from the other.
+ */
+export declare const deploymentLabelNotFound: Readonly<{
+    readonly family: "NOT_FOUND";
+    readonly message: "No deployment of yours has this label.";
+    readonly details: z.ZodObject<{
+        label: z.ZodString;
+    }, z.core.$strict>;
+}>;

package/dist/schema/modules/deployment/errors/deployment-label-not-found.js

@@ -0,0 +1,11 @@
+import { error } from '@astrale-os/sdk/schema/errors';
+import { z } from 'zod';
+/**
+ * A label that names no deployment the caller may read: an unknown label and another
+ * organisation's deployment answer alike, so the answer never tells one from the other.
+ */
+export const deploymentLabelNotFound = error({
+    family: 'NOT_FOUND',
+    message: 'No deployment of yours has this label.',
+    details: z.strictObject({ label: z.string().min(1).max(63) }),
+});

package/dist/schema/modules/deployment/errors/deployment-not-found.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+/**
+ * Asked about a deployment the caller does not hold: a deployment of a line held by another
+ * organisation is invisible to the caller, as its read Policy keeps it.
+ */
+export declare const deploymentNotFound: Readonly<{
+    readonly family: "NOT_FOUND";
+    readonly message: "No deployment of a line the caller holds has this id.";
+    readonly details: z.ZodObject<{}, z.core.$strict>;
+}>;

package/dist/schema/modules/deployment/errors/deployment-not-found.js

@@ -0,0 +1,11 @@
+import { error } from '@astrale-os/sdk/schema/errors';
+import { z } from 'zod';
+/**
+ * Asked about a deployment the caller does not hold: a deployment of a line held by another
+ * organisation is invisible to the caller, as its read Policy keeps it.
+ */
+export const deploymentNotFound = error({
+    family: 'NOT_FOUND',
+    message: 'No deployment of a line the caller holds has this id.',
+    details: z.strictObject({}),
+});

package/dist/schema/modules/deployment/errors/deployment-registry-only.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+/**
+ * Asked of retention by anyone but the registry Domain (`SERVICES_REGISTRY_ORIGIN`). Only the
+ * registry knows which releases are published, so a line holder cannot keep its own preview by
+ * marking it, and only the registry runs the expiry of every organisation's previews.
+ */
+export declare const deploymentRegistryOnly: Readonly<{
+    readonly family: "UNSUPPORTED";
+    readonly message: "Only the registry Domain marks deployments published and expires previews.";
+    readonly details: z.ZodObject<{}, z.core.$strict>;
+}>;

package/dist/schema/modules/deployment/errors/deployment-registry-only.js

@@ -0,0 +1,12 @@
+import { error } from '@astrale-os/sdk/schema/errors';
+import { z } from 'zod';
+/**
+ * Asked of retention by anyone but the registry Domain (`SERVICES_REGISTRY_ORIGIN`). Only the
+ * registry knows which releases are published, so a line holder cannot keep its own preview by
+ * marking it, and only the registry runs the expiry of every organisation's previews.
+ */
+export const deploymentRegistryOnly = error({
+    family: 'UNSUPPORTED',
+    message: 'Only the registry Domain marks deployments published and expires previews.',
+    details: z.strictObject({}),
+});

package/dist/schema/modules/deployment/errors/index.d.ts

@@ -0,0 +1,4 @@
+export { deploymentHostingUnavailable } from './deployment-hosting-unavailable.js';
+export { deploymentLabelNotFound } from './deployment-label-not-found.js';
+export { deploymentNotFound } from './deployment-not-found.js';
+export { deploymentRegistryOnly } from './deployment-registry-only.js';

package/dist/schema/modules/deployment/errors/index.js

@@ -0,0 +1,4 @@
+export { deploymentHostingUnavailable } from './deployment-hosting-unavailable.js';
+export { deploymentLabelNotFound } from './deployment-label-not-found.js';
+export { deploymentNotFound } from './deployment-not-found.js';
+export { deploymentRegistryOnly } from './deployment-registry-only.js';

package/dist/schema/modules/deployment/functions/deploy-cloudflare-deployment.d.ts

@@ -0,0 +1,170 @@
+/**
+ * Host one release as an immutable deployment on its publisher's line. Any authenticated identity
+ * may ask; the handler proves that it acts for the organisation it names before any write.
+ */
+export declare const deployCloudflareDeployment: 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: "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;
+            };
+        };
+    } | {
+        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", true, false, undefined>>;

package/dist/schema/modules/deployment/functions/deploy-cloudflare-deployment.js

@@ -0,0 +1,14 @@
+import { method } from '@astrale-os/sdk/schema';
+import { deploymentRequest } from '../types/deployment-request.js';
+import { deploymentResponse } from '../types/deployment-response.js';
+/**
+ * Host one release as an immutable deployment on its publisher's line. Any authenticated identity
+ * may ask; the handler proves that it acts for the organisation it names before any write.
+ */
+export const deployCloudflareDeployment = method({
+    description: 'Host one release as an immutable deployment on its publisher line.',
+    auth: 'authenticated',
+    static: true,
+    input: deploymentRequest,
+    output: deploymentResponse,
+});

package/dist/schema/modules/deployment/functions/describe-deployment-hosting.d.ts

@@ -0,0 +1,8 @@
+/** Where this Services runtime addresses the deployments it hosts. */
+export declare const describeDeploymentHosting: 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>>;

package/dist/schema/modules/deployment/functions/describe-deployment-hosting.js

@@ -0,0 +1,11 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { deploymentHosting } from '../types/deployment-hosting.js';
+/** Where this Services runtime addresses the deployments it hosts. */
+export const describeDeploymentHosting = method({
+    description: 'Describe the routing domain and line addressing of hosted deployments.',
+    auth: 'authenticated',
+    static: true,
+    input: z.strictObject({}),
+    output: deploymentHosting,
+});

package/dist/schema/modules/deployment/functions/expire-deployment-previews.d.ts

@@ -0,0 +1,16 @@
+/**
+ * One pass of preview expiry over every line: a preview expires 30 days after its last call or
+ * its activation, whichever is later, and a published deployment never does. The pass is a plan
+ * unless the runtime enforces expiry. Only the registry Domain runs it.
+ */
+export declare const expireDeploymentPreviews: 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>>;

package/dist/schema/modules/deployment/functions/expire-deployment-previews.js

@@ -0,0 +1,14 @@
+import { method } from '@astrale-os/sdk/schema';
+import { expirePreviewsInput, expirePreviewsOutput } from '../types/deployment-retention.js';
+/**
+ * One pass of preview expiry over every line: a preview expires 30 days after its last call or
+ * its activation, whichever is later, and a published deployment never does. The pass is a plan
+ * unless the runtime enforces expiry. Only the registry Domain runs it.
+ */
+export const expireDeploymentPreviews = method({
+    description: 'Plan, or where enforced apply, the expiry of previews uncalled for 30 days.',
+    auth: 'authenticated',
+    static: true,
+    input: expirePreviewsInput,
+    output: expirePreviewsOutput,
+});