@astrale-domains/services 0.4.6 → 0.4.7

package/dist/schema/modules/deployment/functions/list-deployment-secret-names.js

@@ -0,0 +1,6 @@
+import { method } from '@astrale-os/sdk/schema';
+import { listDeploymentSecretNamesContract } from '../types/deployment-secret.js';
+export const listDeploymentSecretNames = method({
+    ...listDeploymentSecretNamesContract,
+    abstract: true,
+});

package/dist/schema/modules/deployment/functions/read-deployment-last-calls.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The last call of each deployment named, as the dispatcher counted it. The caller must hold
+ * every label's line; the registry Domain may read any label.
+ */
+export declare const readDeploymentLastCalls: 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>>;

package/dist/schema/modules/deployment/functions/read-deployment-last-calls.js

@@ -0,0 +1,13 @@
+import { method } from '@astrale-os/sdk/schema';
+import { lastCallsInput, lastCallsOutput } from '../types/deployment-retention.js';
+/**
+ * The last call of each deployment named, as the dispatcher counted it. The caller must hold
+ * every label's line; the registry Domain may read any label.
+ */
+export const readDeploymentLastCalls = method({
+    description: 'Read the instant of the last call of each named deployment.',
+    auth: 'authenticated',
+    static: true,
+    input: lastCallsInput,
+    output: lastCallsOutput,
+});

package/dist/schema/modules/deployment/functions/retain-deployment.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Mark one deployment published, so it is served as long as it exists. Only the registry Domain
+ * marks, after the Publication that names the release; a line holder cannot keep its own preview.
+ */
+export declare const retainDeployment: 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>>;

package/dist/schema/modules/deployment/functions/retain-deployment.js

@@ -0,0 +1,13 @@
+import { method } from '@astrale-os/sdk/schema';
+import { retainInput, retainOutput } from '../types/deployment-retention.js';
+/**
+ * Mark one deployment published, so it is served as long as it exists. Only the registry Domain
+ * marks, after the Publication that names the release; a line holder cannot keep its own preview.
+ */
+export const retainDeployment = method({
+    description: 'Mark one deployment published so that it never expires.',
+    auth: 'authenticated',
+    static: true,
+    input: retainInput,
+    output: retainOutput,
+});

package/dist/schema/modules/deployment/functions/retire-deployment.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Withdraw one deployment for good: the emergency stop of its line holder. Its URL then answers
+ * `DEPLOYMENT_RETIRED`, its script and key are deleted, and no redeploy serves it again.
+ *
+ * Only the holder of the deployment's line, or an Identity acting for it, withdraws it: the
+ * handler asks the Kernel `OwnDeployment` for the caller before it reads the deployment, as
+ * `setSecret` does. An `authorized` Method would also require the caller's principal to hold
+ * `can_use` on this Function, which no publisher identity holds on the Admin instance.
+ */
+export declare const retireDeployment: 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>>;

package/dist/schema/modules/deployment/functions/retire-deployment.js

@@ -0,0 +1,17 @@
+import { method } from '@astrale-os/sdk/schema';
+import { retireDeploymentInput, retireDeploymentOutput } from '../types/deployment-retire.js';
+/**
+ * Withdraw one deployment for good: the emergency stop of its line holder. Its URL then answers
+ * `DEPLOYMENT_RETIRED`, its script and key are deleted, and no redeploy serves it again.
+ *
+ * Only the holder of the deployment's line, or an Identity acting for it, withdraws it: the
+ * handler asks the Kernel `OwnDeployment` for the caller before it reads the deployment, as
+ * `setSecret` does. An `authorized` Method would also require the caller's principal to hold
+ * `can_use` on this Function, which no publisher identity holds on the Admin instance.
+ */
+export const retireDeployment = method({
+    description: 'Withdraw this deployment for good: an emergency stop.',
+    auth: 'authenticated',
+    input: retireDeploymentInput,
+    output: retireDeploymentOutput,
+});

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

@@ -0,0 +1,18 @@
+/**
+ * Only the holder of the deployment's line, or an Identity acting for it, rewrites its secrets:
+ * the handler asks the Kernel `OwnDeployment` for the caller before it reads the deployment.
+ */
+export declare const setCloudflareDeploymentSecret: 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>>;

package/dist/schema/modules/deployment/functions/set-cloudflare-deployment-secret.js

@@ -0,0 +1,7 @@
+import { method } from '@astrale-os/sdk/schema';
+import { setDeploymentSecretContract } from '../types/deployment-secret.js';
+/**
+ * Only the holder of the deployment's line, or an Identity acting for it, rewrites its secrets:
+ * the handler asks the Kernel `OwnDeployment` for the caller before it reads the deployment.
+ */
+export const setCloudflareDeploymentSecret = method(setDeploymentSecretContract);

package/dist/schema/modules/deployment/functions/set-deployment-secret.d.ts

@@ -0,0 +1,14 @@
+export declare const setDeploymentSecret: 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>>;

package/dist/schema/modules/deployment/functions/set-deployment-secret.js

@@ -0,0 +1,3 @@
+import { method } from '@astrale-os/sdk/schema';
+import { setDeploymentSecretContract } from '../types/deployment-secret.js';
+export const setDeploymentSecret = method({ ...setDeploymentSecretContract, abstract: true });

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

@@ -1,6 +1,8 @@
 export { CloudflareDeployment, Deployment, DeploymentLine, deployment_on_line, line_owned_by, } from './classes/index.js';
-export { OwnDeployment, OwnLine, TraverseOwnedLine, TraverseOwnedLineDeployment, } from './policies/index.js';
+export { deploymentHostingUnavailable, deploymentLabelNotFound, deploymentNotFound, deploymentRegistryOnly, } from './errors/index.js';
+export { deployCloudflareDeployment, describeDeploymentHosting, expireDeploymentPreviews, listCloudflareDeploymentSecretNames, listCloudflareDeployments, listDeploymentSecretNames, readDeploymentLastCalls, retainDeployment, retireDeployment, setCloudflareDeploymentSecret, setDeploymentSecret, } from './functions/index.js';
+export { ActForOrganization, OwnDeployment, OwnLine, TraverseOwnedLine, TraverseOwnedLineDeployment, } from './policies/index.js';
 export { deploymentLifecycle } from './states/index.js';
 export type { DeploymentLifecycle, DeploymentLifecycleEvent } from './states/index.js';
-export { deploymentCommit, deploymentRecord, deploymentRetention, deploymentRetirement, } from './types/index.js';
-export type { DeploymentRecord, DeploymentRetention, DeploymentRetirement } from './types/index.js';
+export { deploymentCommit, deploymentHosting, deploymentLabel, deploymentRecord, deploymentRejection, deploymentRejectionReason, deploymentRequest, deploymentResponse, deploymentRetention, deploymentRetirement, deploymentSecretDigest, deploymentSecretDigests, deploymentSecretRejection, deploymentSummary, expirePreviewsInput, expirePreviewsOutput, frozenConfiguration, lastCallsInput, lastCallsOutput, listDeploymentSecretNamesContract, listedDeploymentSummary, listDeploymentsInput, listDeploymentsOutput, MAXIMUM_LAST_CALL_LABELS, MAXIMUM_PREVIEW_EXPIRY_WRITES, retainInput, retainOutput, retireDeploymentInput, retireDeploymentOutput, setDeploymentSecretContract, unadmittedDeploymentSummary, } from './types/index.js';
+export type { DeploymentHosting, DeploymentRecord, DeploymentRejection, DeploymentRejectionReason, DeploymentRequest, DeploymentResponse, DeploymentRetention, DeploymentRetirement, DeploymentSecretDigest, DeploymentSecretRejection, DeploymentSummary, ExpirePreviewsResult, FrozenConfiguration, ListedDeploymentSummary, RetireDeploymentResult, UnadmittedDeploymentSummary, } from './types/index.js';

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

@@ -1,4 +1,6 @@
 export { CloudflareDeployment, Deployment, DeploymentLine, deployment_on_line, line_owned_by, } from './classes/index.js';
-export { OwnDeployment, OwnLine, TraverseOwnedLine, TraverseOwnedLineDeployment, } from './policies/index.js';
+export { deploymentHostingUnavailable, deploymentLabelNotFound, deploymentNotFound, deploymentRegistryOnly, } from './errors/index.js';
+export { deployCloudflareDeployment, describeDeploymentHosting, expireDeploymentPreviews, listCloudflareDeploymentSecretNames, listCloudflareDeployments, listDeploymentSecretNames, readDeploymentLastCalls, retainDeployment, retireDeployment, setCloudflareDeploymentSecret, setDeploymentSecret, } from './functions/index.js';
+export { ActForOrganization, OwnDeployment, OwnLine, TraverseOwnedLine, TraverseOwnedLineDeployment, } from './policies/index.js';
 export { deploymentLifecycle } from './states/index.js';
-export { deploymentCommit, deploymentRecord, deploymentRetention, deploymentRetirement, } from './types/index.js';
+export { deploymentCommit, deploymentHosting, deploymentLabel, deploymentRecord, deploymentRejection, deploymentRejectionReason, deploymentRequest, deploymentResponse, deploymentRetention, deploymentRetirement, deploymentSecretDigest, deploymentSecretDigests, deploymentSecretRejection, deploymentSummary, expirePreviewsInput, expirePreviewsOutput, frozenConfiguration, lastCallsInput, lastCallsOutput, listDeploymentSecretNamesContract, listedDeploymentSummary, listDeploymentsInput, listDeploymentsOutput, MAXIMUM_LAST_CALL_LABELS, MAXIMUM_PREVIEW_EXPIRY_WRITES, retainInput, retainOutput, retireDeploymentInput, retireDeploymentOutput, setDeploymentSecretContract, unadmittedDeploymentSummary, } from './types/index.js';

package/dist/schema/modules/deployment/policies/act-for-organization.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The subject is this organisation, or an Identity acting for it: a member or a CI identity
+ * reaches its organisation through `extends_with`, which the Kernel expands for the subject. Deploy
+ * asks it of the caller, on the organisation it names, before registering a line for it.
+ */
+export declare const ActForOrganization: import("@astrale-os/sdk/schema").Policy;

package/dist/schema/modules/deployment/policies/act-for-organization.js

@@ -0,0 +1,10 @@
+import { policy } from '@astrale-os/sdk/schema';
+/**
+ * The subject is this organisation, or an Identity acting for it: a member or a CI identity
+ * reaches its organisation through `extends_with`, which the Kernel expands for the subject. Deploy
+ * asks it of the caller, on the organisation it names, before registering a line for it.
+ */
+export const ActForOrganization = policy({
+    description: 'The subject is this organisation or acts for it through extends_with.',
+    match: ({ sameNode, subject, object }) => sameNode(subject, object),
+});

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

@@ -1,3 +1,4 @@
+export { ActForOrganization } from './act-for-organization.js';
 export { OwnDeployment } from './own-deployment.js';
 export { OwnLine } from './own-line.js';
 export { TraverseOwnedLine } from './traverse-owned-line.js';

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

@@ -1,3 +1,4 @@
+export { ActForOrganization } from './act-for-organization.js';
 export { OwnDeployment } from './own-deployment.js';
 export { OwnLine } from './own-line.js';
 export { TraverseOwnedLine } from './traverse-owned-line.js';

package/dist/schema/modules/deployment/states/deployment-lifecycle.d.ts

@@ -1,9 +1,11 @@
 import { type EventOf, type StateOf } from '@astrale-os/sdk/state';
 /**
  * Lifecycle of one immutable deployment. A deployment never changes code: it is created
- * `deploying`, becomes `active` once its script serves, and leaves only by retirement. A failed
- * creation can be retried on the same label; an expired retirement can be revived for the same
- * owner and artifact.
+ * `deploying`, becomes `active` once its script serves, and leaves only by retirement, in two
+ * phases: `retiring` once its tombstone is written, `retired` once its script and key are deleted.
+ * A failed creation can be retried on the same label, or retired, since it may have left a
+ * script. An expired retirement can be revived for the same line holder and artifact; a withdrawn
+ * one never.
  */
 export declare const deploymentLifecycle: import("@astrale-os/sdk/schema").StateMachine<{
     readonly deploying: {
@@ -21,6 +23,7 @@ export declare const deploymentLifecycle: import("@astrale-os/sdk/schema").State
     };
     readonly failed: {
         readonly retry: "deploying";
+        readonly retire: "retiring";
     };
 }, "deploying">;
 export type DeploymentLifecycle = StateOf<typeof deploymentLifecycle>;

package/dist/schema/modules/deployment/states/deployment-lifecycle.js

@@ -1,9 +1,11 @@
 import { stateMachine } from '@astrale-os/sdk/state';
 /**
  * Lifecycle of one immutable deployment. A deployment never changes code: it is created
- * `deploying`, becomes `active` once its script serves, and leaves only by retirement. A failed
- * creation can be retried on the same label; an expired retirement can be revived for the same
- * owner and artifact.
+ * `deploying`, becomes `active` once its script serves, and leaves only by retirement, in two
+ * phases: `retiring` once its tombstone is written, `retired` once its script and key are deleted.
+ * A failed creation can be retried on the same label, or retired, since it may have left a
+ * script. An expired retirement can be revived for the same line holder and artifact; a withdrawn
+ * one never.
  */
 export const deploymentLifecycle = stateMachine({
     initial: 'deploying',
@@ -12,6 +14,6 @@ export const deploymentLifecycle = stateMachine({
         active: { retire: 'retiring' },
         retiring: { completeRetirement: 'retired' },
         retired: { revive: 'deploying' },
-        failed: { retry: 'deploying' },
+        failed: { retry: 'deploying', retire: 'retiring' },
     },
 });

package/dist/schema/modules/deployment/types/deployment-hosting.d.ts

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+/** Where this Services runtime addresses deployments, and how the caller's own lines read. */
+export declare const deploymentHosting: z.ZodObject<{
+    routingDomain: z.ZodString;
+    addressing: z.ZodEnum<{
+        opaque: "opaque";
+        readable: "readable";
+    }>;
+}, z.core.$strict>;
+export declare const listDeploymentsInput: z.ZodObject<{
+    origin: z.ZodOptional<z.ZodString>;
+    environment: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * The deployments of the caller's lines. A deployment whose stored record or configuration this
+ * Services SDK no longer admits is listed from its facts with its record as stored, never dropped,
+ * and never fails the listing.
+ */
+export declare const listDeploymentsOutput: z.ZodObject<{
+    deployments: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        id: z.ZodString;
+        url: z.ZodString;
+        label: z.ZodString;
+        line: z.ZodString;
+        owner: z.ZodString;
+        state: z.ZodEnum<{
+            active: "active";
+            deploying: "deploying";
+            failed: "failed";
+            retired: "retired";
+            retiring: "retiring";
+        }>;
+        retention: z.ZodEnum<{
+            preview: "preview";
+            published: "published";
+        }>;
+        createdAt: z.ZodString;
+        lastCallAt: z.ZodOptional<z.ZodString>;
+        expiresAt: z.ZodOptional<z.ZodString>;
+        retiredAt: z.ZodOptional<z.ZodString>;
+        retirement: z.ZodOptional<z.ZodEnum<{
+            expired: "expired";
+            withdrawn: "withdrawn";
+        }>>;
+        signingKeyId: z.ZodString;
+        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>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        url: z.ZodString;
+        label: z.ZodString;
+        line: z.ZodString;
+        owner: z.ZodString;
+        state: z.ZodEnum<{
+            active: "active";
+            deploying: "deploying";
+            failed: "failed";
+            retired: "retired";
+            retiring: "retiring";
+        }>;
+        retention: z.ZodEnum<{
+            preview: "preview";
+            published: "published";
+        }>;
+        createdAt: z.ZodString;
+        lastCallAt: z.ZodOptional<z.ZodString>;
+        expiresAt: z.ZodOptional<z.ZodString>;
+        retiredAt: z.ZodOptional<z.ZodString>;
+        retirement: z.ZodOptional<z.ZodEnum<{
+            expired: "expired";
+            withdrawn: "withdrawn";
+        }>>;
+        signingKeyId: z.ZodString;
+        record: z.ZodUnknown;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>;
+export type DeploymentHosting = z.output<typeof deploymentHosting>;

package/dist/schema/modules/deployment/types/deployment-hosting.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { listedDeploymentSummary } from './deployment-summary.js';
+/** Where this Services runtime addresses deployments, and how the caller's own lines read. */
+export const deploymentHosting = z.strictObject({
+    routingDomain: z.string().min(1).max(253),
+    addressing: z.enum(['readable', 'opaque']),
+});
+export const listDeploymentsInput = z.strictObject({
+    origin: z.string().min(1).max(253).optional(),
+    environment: z.string().min(1).max(63).optional(),
+});
+/**
+ * The deployments of the caller's lines. A deployment whose stored record or configuration this
+ * Services SDK no longer admits is listed from its facts with its record as stored, never dropped,
+ * and never fails the listing.
+ */
+export const listDeploymentsOutput = z.strictObject({
+    deployments: z.array(listedDeploymentSummary),
+});

package/dist/schema/modules/deployment/types/deployment-request.d.ts

@@ -0,0 +1,161 @@
+import { z } from 'zod';
+/**
+ * `DeploymentRequestV1`: one release to host on the line of its origin and environment. Services
+ * recomputes the build digest from the uploaded bytes and the label from the line, the build and
+ * the configuration; the request states both so a deployer that computed another address is
+ * refused rather than served elsewhere. The secrets are the environment's current values, bound to
+ * the new deployment only.
+ */
+export declare const deploymentRequest: z.ZodObject<{
+    format: z.ZodLiteral<"astrale.services.deployment-request">;
+    version: z.ZodLiteral<1>;
+    organization: z.ZodOptional<z.ZodString>;
+    origin: z.ZodString;
+    environment: z.ZodString;
+    addressing: z.ZodEnum<{
+        opaque: "opaque";
+        readable: "readable";
+    }>;
+    label: z.ZodString;
+    buildDigest: z.ZodString;
+    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>;
+    record: z.ZodObject<{
+        releaseDigest: z.ZodString;
+        schemaRevision: z.ZodString;
+        schemaBundle: 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>;
+    bundle: z.ZodObject<{
+        entrypoint: z.ZodString;
+        modules: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            name: z.ZodString;
+            kind: z.ZodOptional<z.ZodEnum<{
+                data: "data";
+                esm: "esm";
+                text: "text";
+                wasm: "wasm";
+            }>>;
+            content: z.ZodUnion<readonly [z.ZodObject<{
+                encoding: z.ZodEnum<{
+                    gzip: "gzip";
+                    identity: "identity";
+                }>;
+                decodedSize: z.ZodNumber;
+                contentBase64: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                encoding: z.ZodEnum<{
+                    gzip: "gzip";
+                    identity: "identity";
+                }>;
+                decodedSize: z.ZodNumber;
+                contentBase64Chunks: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>, z.ZodObject<{
+            contentBase64: z.ZodString;
+            name: z.ZodString;
+            kind: z.ZodOptional<z.ZodEnum<{
+                data: "data";
+                esm: "esm";
+                text: "text";
+                wasm: "wasm";
+            }>>;
+        }, z.core.$strict>, z.ZodObject<{
+            contentBase64Chunks: z.ZodArray<z.ZodString>;
+            name: z.ZodString;
+            kind: z.ZodOptional<z.ZodEnum<{
+                data: "data";
+                esm: "esm";
+                text: "text";
+                wasm: "wasm";
+            }>>;
+        }, z.core.$strict>]>>;
+        assets: z.ZodOptional<z.ZodObject<{
+            files: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                path: z.ZodString;
+                contentType: z.ZodOptional<z.ZodString>;
+                content: z.ZodUnion<readonly [z.ZodObject<{
+                    encoding: z.ZodEnum<{
+                        gzip: "gzip";
+                        identity: "identity";
+                    }>;
+                    decodedSize: z.ZodNumber;
+                    contentBase64: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    encoding: z.ZodEnum<{
+                        gzip: "gzip";
+                        identity: "identity";
+                    }>;
+                    decodedSize: z.ZodNumber;
+                    contentBase64Chunks: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>]>;
+            }, z.core.$strict>, z.ZodObject<{
+                contentBase64: z.ZodString;
+                path: z.ZodString;
+                contentType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                contentBase64Chunks: z.ZodArray<z.ZodString>;
+                path: z.ZodString;
+                contentType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>]>>;
+            notFound: z.ZodOptional<z.ZodEnum<{
+                "404-page": "404-page";
+                none: "none";
+                "single-page-application": "single-page-application";
+            }>>;
+            runWorkerFirst: z.ZodOptional<z.ZodBoolean>;
+            htmlHandling: z.ZodOptional<z.ZodLiteral<"none">>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    secrets: z.ZodRecord<z.ZodString, z.ZodString>;
+    readiness: z.ZodOptional<z.ZodObject<{
+        paths: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type DeploymentRequest = z.output<typeof deploymentRequest>;

package/dist/schema/modules/deployment/types/deployment-request.js

@@ -0,0 +1,40 @@
+import { fullMatch } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { artifactModule, assetBundle } from '../../service/index.js';
+import { deploymentCommit } from './deployment-record.js';
+import { frozenConfiguration } from './frozen-configuration.js';
+const digest = z.string().check(fullMatch('sha256:[0-9a-f]{64}'));
+/**
+ * `DeploymentRequestV1`: one release to host on the line of its origin and environment. Services
+ * recomputes the build digest from the uploaded bytes and the label from the line, the build and
+ * the configuration; the request states both so a deployer that computed another address is
+ * refused rather than served elsewhere. The secrets are the environment's current values, bound to
+ * the new deployment only.
+ */
+export const deploymentRequest = z.strictObject({
+    format: z.literal('astrale.services.deployment-request'),
+    version: z.literal(1),
+    /** The Identity of the Admin instance the deploy acts for; the exact caller when absent. */
+    organization: z.string().min(1).max(256).optional(),
+    origin: z.string().min(1).max(253),
+    environment: z.string().min(1).max(63),
+    addressing: z.enum(['readable', 'opaque']),
+    label: z.string().min(1).max(63),
+    buildDigest: digest,
+    configuration: frozenConfiguration,
+    record: z.strictObject({
+        releaseDigest: digest,
+        schemaRevision: digest,
+        schemaBundle: digest,
+        commit: deploymentCommit.nullable(),
+    }),
+    bundle: z.strictObject({
+        entrypoint: z.string().min(1).max(256),
+        modules: z.array(artifactModule).min(1).max(40),
+        assets: assetBundle.optional(),
+    }),
+    secrets: z.record(z.string().min(1).max(128), z.string().max(64 * 1024)),
+    readiness: z
+        .strictObject({ paths: z.array(z.string().min(1).max(1_024)).min(1).max(8) })
+        .optional(),
+});