@astrale-domains/services 0.5.0 → 0.6.0

package/dist/scaffold/template/src/account.js

@@ -0,0 +1,31 @@
+import { issuer, jwk, register } from '@astrale-os/sdk/auth'
+import { connect } from '@astrale-os/sdk/client/session'
+import { importJWK, SignJWT } from 'jose'
+
+/**
+ * A session on `kernel` as the Identity registered with this ES256 key: each call presents a
+ * short-lived self-signed credential. Register the key on a dedicated Identity of the target's
+ * Domain and grant it only the callables the job needs; never a Root or admin credential.
+ */
+export function openAccount(kernel, privateJwk) {
+  if (privateJwk.kty !== 'EC' || privateJwk.crv !== 'P-256' || !privateJwk.d) {
+    throw new TypeError('ACCOUNT_PRIVATE_JWK must be a registered ES256 private JWK.')
+  }
+  const publicKey = jwk.acceptPublic({ kty: 'EC', crv: 'P-256', x: privateJwk.x, y: privateJwk.y })
+  return connect({
+    url: kernel,
+    auth: {
+      ttlSeconds: 60,
+      resolve: async () => ({
+        credential: await new SignJWT({})
+          .setProtectedHeader({ alg: 'ES256', kid: privateJwk.kid, typ: 'JWT' })
+          .setIssuer(await register.selfIssuer(issuer.accept(kernel), publicKey))
+          .setSubject('self')
+          .setAudience(kernel)
+          .setIssuedAt()
+          .setExpirationTime('3m')
+          .sign(await importJWK(privateJwk, 'ES256')),
+      }),
+    },
+  })
+}

package/dist/scaffold/template/src/index.js

@@ -0,0 +1,50 @@
+import { runJob } from './job.js'
+
+/** The call budget of one scheduled run, under the dispatcher's 10 s deadline. */
+const JOB_BUDGET_MS = 9_000
+
+export default {
+  /**
+   * Admin's Services serves this Worker at its deployment URL and at its Service's URL. A cron of
+   * the Service reaches it as `POST /__scheduled` from the Services dispatcher alone, with the cron
+   * in `x-astrale-cron` and the minute it fired for (epoch ms) in `x-astrale-scheduled-time`: the
+   * dispatcher refuses that path to the public, in every spelling.
+   */
+  async fetch(request, env) {
+    const path = new URL(request.url).pathname
+    if (path === '/health' && request.method === 'GET') {
+      return new Response('ok', {
+        headers: { 'x-astrale-worker-version': env.ASTRALE_VERSION_METADATA?.id ?? '' },
+      })
+    }
+    if (path === '/__scheduled' && request.method === 'POST') return scheduled(request, env)
+    return new Response(null, { status: 404 })
+  },
+}
+
+async function scheduled(request, env) {
+  const cron = request.headers.get('x-astrale-cron')
+  const scheduledAt = Number(request.headers.get('x-astrale-scheduled-time'))
+  if (cron === null || !Number.isSafeInteger(scheduledAt) || scheduledAt <= 0) {
+    return new Response(null, { status: 400 })
+  }
+  const started = Date.now()
+  try {
+    await runJob({ cron, scheduledAt, env, signal: AbortSignal.timeout(JOB_BUDGET_MS) })
+    console.log(
+      JSON.stringify({ event: 'job.completed', cron, scheduledAt, ms: Date.now() - started }),
+    )
+    return Response.json({ status: 'completed' })
+  } catch (error) {
+    // Never log a credential, a provider envelope or a business value: only the error's code.
+    console.error(
+      JSON.stringify({
+        event: 'job.failed',
+        cron,
+        scheduledAt,
+        code: typeof error?.code === 'number' ? error.code : undefined,
+      }),
+    )
+    return Response.json({ status: 'failed' }, { status: 503 })
+  }
+}

package/dist/scaffold/template/src/job.js

@@ -0,0 +1,22 @@
+import { Path } from '@astrale-os/sdk/graph/path'
+
+import { openAccount } from './account.js'
+
+/**
+ * The job one cron runs: call one callable of an Astrale Kernel as this Service's own account.
+ * Adapt its input to the target's contract; a repeated or uncertain run is the target's to absorb.
+ */
+export async function runJob({ cron, scheduledAt, env, signal }) {
+  if (!env.KERNEL || !env.TARGET || !env.ACCOUNT_PRIVATE_JWK) {
+    throw new Error('Configure KERNEL, TARGET and the ACCOUNT_PRIVATE_JWK secret.')
+  }
+  const session = openAccount(env.KERNEL, JSON.parse(env.ACCOUNT_PRIVATE_JWK))
+  try {
+    return await session.call(
+      { target: Path.parse(env.TARGET), input: { cron, scheduledAt } },
+      { signal },
+    )
+  } finally {
+    session.close()
+  }
+}

package/dist/schema/index.d.ts

@@ -2,5 +2,5 @@ export { schema } from './schema.js';
 export type { ServicesDomain, ServicesSchema } from './schema.js';
 export { ActAs, CloudflareService, OwnService, Service, TraverseOwnedService, serviceLifecycle, service_owned_by, } from './modules/service/index.js';
 export type { ServiceLifecycle, ServiceLifecycleEvent } from './modules/service/index.js';
-export { artifactModule, assetBundle, assetFile, CloudflareDeployment, Deployment, OwnDeployment, TraverseOwnedServiceDeployment, current_deployment, deployment_of, deploymentCommit, deploymentHosting, deploymentLifecycle, deploymentRecord, deploymentRejection, deploymentRequest, deploymentResponse, deploymentSecretDigests, deploymentSecretRejection, deploymentSummary, frozenConfiguration, listedDeploymentSummary, retireDeploymentOutput, unadmittedDeploymentSummary, } from './modules/deployment/index.js';
-export type { ArtifactModule, AssetBundle, DeploymentHosting, DeploymentLifecycle, DeploymentLifecycleEvent, DeploymentRecord, DeploymentRejection, DeploymentRejectionReason, DeploymentRequest, DeploymentResponse, DeploymentSecretDigest, DeploymentSecretRejection, DeploymentSummary, FrozenConfiguration, ListedDeploymentSummary, RetireDeploymentResult, UnadmittedDeploymentSummary, } from './modules/deployment/index.js';
+export { CloudflareDeployment, Deployment, OwnDeployment, TraverseOwnedServiceDeployment, current_deployment, deployment_of, deploymentHosting, deploymentLifecycle, deploymentRejection, deploymentRequest, deploymentResponse, deploymentSecretDigests, deploymentSecretRejection, deploymentSummary, legacyDeploymentRecord, legacyFrozenConfiguration, retireDeploymentOutput, workerConfiguration, workerRecord, } from './modules/deployment/index.js';
+export type { DeploymentHosting, DeploymentLifecycle, DeploymentLifecycleEvent, DeploymentRejection, DeploymentRejectionReason, DeploymentRequest, DeploymentResponse, DeploymentSecretDigest, DeploymentSecretRejection, DeploymentSummary, LegacyDeploymentRecord, LegacyFrozenConfiguration, MigrateLegacyResult, RetireDeploymentResult, WorkerConfiguration, WorkerRecordWire, } from './modules/deployment/index.js';

package/dist/schema/index.js

@@ -1,3 +1,3 @@
 export { schema } from './schema.js';
 export { ActAs, CloudflareService, OwnService, Service, TraverseOwnedService, serviceLifecycle, service_owned_by, } from './modules/service/index.js';
-export { artifactModule, assetBundle, assetFile, CloudflareDeployment, Deployment, OwnDeployment, TraverseOwnedServiceDeployment, current_deployment, deployment_of, deploymentCommit, deploymentHosting, deploymentLifecycle, deploymentRecord, deploymentRejection, deploymentRequest, deploymentResponse, deploymentSecretDigests, deploymentSecretRejection, deploymentSummary, frozenConfiguration, listedDeploymentSummary, retireDeploymentOutput, unadmittedDeploymentSummary, } from './modules/deployment/index.js';
+export { CloudflareDeployment, Deployment, OwnDeployment, TraverseOwnedServiceDeployment, current_deployment, deployment_of, deploymentHosting, deploymentLifecycle, deploymentRejection, deploymentRequest, deploymentResponse, deploymentSecretDigests, deploymentSecretRejection, deploymentSummary, legacyDeploymentRecord, legacyFrozenConfiguration, retireDeploymentOutput, workerConfiguration, workerRecord, } from './modules/deployment/index.js';

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

@@ -29,26 +29,20 @@ export declare const CloudflareDeployment: import("@astrale-os/sdk/schema").Auth
                 required?: boolean;
                 description?: string;
             }>;
-            record: import("zod").ZodObject<{
-                format: import("zod").ZodLiteral<"astrale.deployment-record">;
+            buildDigest: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {
+                readonly required: false;
+            }>;
+            configuration: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                format: import("zod").ZodLiteral<"astrale.worker.configuration">;
                 version: import("zod").ZodLiteral<1>;
-                origin: import("zod").ZodString;
-                environment: import("zod").ZodString;
-                releaseDigest: import("zod").ZodString;
-                buildDigest: import("zod").ZodString;
-                schemaRevision: import("zod").ZodString;
-                configuration: import("zod").ZodString;
-                providerScript: import("zod").ZodString;
-                commit: import("zod").ZodNullable<import("zod").ZodObject<{
-                    sha: import("zod").ZodString;
-                    dirty: import("zod").ZodBoolean;
-                    base: import("zod").ZodOptional<import("zod").ZodObject<{
-                        version: import("zod").ZodString;
-                        distance: import("zod").ZodNumber;
-                    }, import("zod/v4/core").$strict>>;
-                }, import("zod/v4/core").$strict>>;
-            }, import("zod/v4/core").$strict>;
-            configuration: import("zod").ZodObject<{
+                compatibilityDate: import("zod").ZodString;
+                compatibilityFlags: import("zod").ZodArray<import("zod").ZodString>;
+                vars: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+                secrets: import("zod").ZodArray<import("zod").ZodString>;
+                record: import("zod").ZodBoolean;
+                signingIdentity: import("zod").ZodBoolean;
+                router: import("zod").ZodBoolean;
+            }, import("zod/v4/core").$strict>, 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>;
@@ -88,7 +82,34 @@ export declare const CloudflareDeployment: import("@astrale-os/sdk/schema").Auth
                     hostSuffix: import("zod").ZodString;
                     minLabels: import("zod").ZodNumber;
                 }, import("zod/v4/core").$strict>]>;
-            }, import("zod/v4/core").$strict>;
+            }, import("zod/v4/core").$strict>]>;
+            configurationDigest: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {
+                readonly required: false;
+            }>;
+            record: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                contentType: import("zod").ZodString;
+                contentBase64: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                format: import("zod").ZodLiteral<"astrale.deployment-record">;
+                version: import("zod").ZodLiteral<1>;
+                origin: import("zod").ZodString;
+                environment: import("zod").ZodString;
+                releaseDigest: import("zod").ZodString;
+                buildDigest: import("zod").ZodString;
+                schemaRevision: import("zod").ZodString;
+                configuration: import("zod").ZodString;
+                providerScript: import("zod").ZodString;
+                commit: import("zod").ZodNullable<import("zod").ZodObject<{
+                    sha: import("zod").ZodString;
+                    dirty: import("zod").ZodBoolean;
+                    base: import("zod").ZodOptional<import("zod").ZodObject<{
+                        version: import("zod").ZodString;
+                        distance: import("zod").ZodNumber;
+                    }, import("zod/v4/core").$strict>>;
+                }, import("zod/v4/core").$strict>>;
+            }, import("zod/v4/core").$strict>]>, {
+                readonly required: false;
+            }>;
             secretDigests: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodArray<import("zod").ZodObject<{
                 name: import("zod").ZodString;
                 digest: import("zod").ZodString;

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

@@ -1,9 +1,13 @@
 import { z } from 'zod';
 /**
- * One immutable deployment of one Service: 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 of the same Service. Only its secrets rotate in place, under the names its
- * configuration declares.
+ * One immutable deployment of one Service: one Worker build with its configuration, served by one
+ * script at its own URL. It never changes code; a new release is a new deployment of the
+ * same Service. Only its secrets rotate in place, under the names its configuration declares.
+ * Services knows nothing of what the Worker serves: the record it publishes is opaque bytes.
+ *
+ * LEGACY: a deployment created before Services hosted any Worker still stores the Domain's frozen
+ * configuration and record, and no build or configuration digest, until `CloudflareService.migrate`
+ * rewrites it; the next Schema revision admits the Worker form only.
  */
 export declare const Deployment: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
     readonly abstract: true;
@@ -34,27 +38,22 @@ export declare const Deployment: import("@astrale-os/sdk/schema").AuthoredNodeCl
             required?: boolean;
             description?: string;
         }>;
-        record: z.ZodObject<{
-            format: z.ZodLiteral<"astrale.deployment-record">;
+        /** The build digest of the uploaded Worker, bound as `ASTRALE_BUILD_DIGEST`. */
+        buildDigest: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodString, {
+            readonly required: false;
+        }>;
+        /** The configuration frozen into this deployment. */
+        configuration: z.ZodUnion<readonly [z.ZodObject<{
+            format: z.ZodLiteral<"astrale.worker.configuration">;
             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<{
+            compatibilityDate: z.ZodString;
+            compatibilityFlags: z.ZodArray<z.ZodString>;
+            vars: z.ZodRecord<z.ZodString, z.ZodString>;
+            secrets: z.ZodArray<z.ZodString>;
+            record: z.ZodBoolean;
+            signingIdentity: z.ZodBoolean;
+            router: z.ZodBoolean;
+        }, z.core.$strict>, z.ZodObject<{
             format: z.ZodLiteral<"astrale.deployment.configuration">;
             version: z.ZodLiteral<1>;
             vars: z.ZodRecord<z.ZodString, z.ZodString>;
@@ -94,7 +93,36 @@ export declare const Deployment: import("@astrale-os/sdk/schema").AuthoredNodeCl
                 hostSuffix: z.ZodString;
                 minLabels: z.ZodNumber;
             }, z.core.$strict>]>;
-        }, z.core.$strict>;
+        }, z.core.$strict>]>;
+        /** The digest of `configuration` (`workerConfigurationDigest`). */
+        configurationDigest: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodString, {
+            readonly required: false;
+        }>;
+        /** The record the deployment publishes, when its configuration asks for one. */
+        record: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodUnion<readonly [z.ZodObject<{
+            contentType: z.ZodString;
+            contentBase64: z.ZodString;
+        }, z.core.$strict>, 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>]>, {
+            readonly required: false;
+        }>;
         /** 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;
@@ -109,6 +137,7 @@ export declare const Deployment: import("@astrale-os/sdk/schema").AuthoredNodeCl
         scriptEtag: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodString, {
             readonly required: false;
         }>;
+        /** The thumbprint of the deployment's own key, when its configuration asks for one. */
         signingKeyId: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodString, {
             readonly required: false;
         }>;

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

@@ -1,13 +1,18 @@
-import { classIcon, K, nodeClass, property, schema as valueSchema, stateProperty, } from '@astrale-os/sdk/schema';
+import { classIcon, fullMatch, 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 { deploymentLifecycle } from '../states/index.js';
-import { deploymentRecord, deploymentSecretDigests, frozenConfiguration } from '../types/index.js';
+import { deploymentSecretDigests, legacyDeploymentRecord, legacyFrozenConfiguration, workerConfiguration, workerRecord, } from '../types/index.js';
+const digest = z.string().check(fullMatch('sha256:[0-9a-f]{64}'));
 /**
- * One immutable deployment of one Service: 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 of the same Service. Only its secrets rotate in place, under the names its
- * configuration declares.
+ * One immutable deployment of one Service: one Worker build with its configuration, served by one
+ * script at its own URL. It never changes code; a new release is a new deployment of the
+ * same Service. Only its secrets rotate in place, under the names its configuration declares.
+ * Services knows nothing of what the Worker serves: the record it publishes is opaque bytes.
+ *
+ * LEGACY: a deployment created before Services hosted any Worker still stores the Domain's frozen
+ * configuration and record, and no build or configuration digest, until `CloudflareService.migrate`
+ * rewrites it; the next Schema revision admits the Worker form only.
  */
 export const Deployment = nodeClass({
     abstract: true,
@@ -19,9 +24,14 @@ export const Deployment = nodeClass({
         label: z.string().min(33).max(57),
         url: z.string().min(1).max(2_048),
         state: stateProperty(deploymentLifecycle),
-        record: deploymentRecord,
-        /** The configuration frozen into this deployment; its digest is `record.configuration`. */
-        configuration: frozenConfiguration,
+        /** The build digest of the uploaded Worker, bound as `ASTRALE_BUILD_DIGEST`. */
+        buildDigest: property(digest, { required: false }),
+        /** The configuration frozen into this deployment. */
+        configuration: z.union([workerConfiguration, legacyFrozenConfiguration]),
+        /** The digest of `configuration` (`workerConfigurationDigest`). */
+        configurationDigest: property(digest, { required: false }),
+        /** The record the deployment publishes, when its configuration asks for one. */
+        record: property(z.union([workerRecord, legacyDeploymentRecord]), { required: false }),
         /** The keyed digest of each secret bound to this deployment, never a value. */
         secretDigests: property(deploymentSecretDigests, { required: false }),
         /**
@@ -29,6 +39,7 @@ export const Deployment = nodeClass({
          * identifies the deployment; a secret rewritten in place keeps it, unlike a provider version.
          */
         scriptEtag: property(z.string().min(1).max(128), { required: false }),
+        /** The thumbprint of the deployment's own key, when its configuration asks for one. */
         signingKeyId: property(z.string().min(1).max(128), { required: false }),
         activatedAt: property(valueSchema.values.instant, { required: false }),
         retiredAt: property(valueSchema.values.instant, { required: false }),

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

@@ -11,14 +11,14 @@
 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" | "service-owned-elsewhere" | "service-unavailable";
         message: string;
         retryAfter?: string | undefined;
+    } | {
+        kind: "retired";
+    } | {
+        kind: "retiring";
+        retryAfterMs: number;
     };
 }, "authenticated", false, false, undefined>>;

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

@@ -1,5 +1,5 @@
-export { artifactModule, assetBundle, assetFile, deploymentCommit, deploymentHosting, deploymentRecord, deploymentRejection, deploymentRejectionReason, deploymentRequest, deploymentResponse, deploymentSecretDigest, deploymentSecretDigests, deploymentSecretRejection, deploymentSummary, frozenConfiguration, listDeploymentsInput, listDeploymentsOutput, listedDeploymentSummary, retireDeploymentInput, retireDeploymentOutput, unadmittedDeploymentSummary, } from './types/index.js';
-export type { ArtifactModule, AssetBundle, ServiceDeploymentContent, DeploymentHosting, DeploymentRecord, DeploymentRejection, DeploymentRejectionReason, DeploymentRequest, DeploymentResponse, DeploymentSecretDigest, DeploymentSecretRejection, DeploymentSummary, FrozenConfiguration, ListedDeploymentSummary, RetireDeploymentResult, UnadmittedDeploymentSummary, } from './types/index.js';
+export { deploymentHosting, deploymentRejection, deploymentRejectionReason, deploymentRequest, deploymentResponse, deploymentSecretDigest, deploymentSecretDigests, deploymentSecretRejection, deploymentSummary, legacyDeploymentRecord, legacyFrozenConfiguration, listDeploymentsInput, listDeploymentsOutput, migrateLegacyInput, migrateLegacyOutput, retireDeploymentInput, retireDeploymentOutput, workerConfiguration, workerRecord, } from './types/index.js';
+export type { DeploymentHosting, DeploymentRejection, DeploymentRejectionReason, DeploymentRequest, DeploymentResponse, DeploymentSecretDigest, DeploymentSecretRejection, DeploymentSummary, LegacyDeploymentRecord, LegacyFrozenConfiguration, MigrateLegacyResult, RetireDeploymentResult, WorkerConfiguration, WorkerRecordWire, } from './types/index.js';
 export { CloudflareDeployment, Deployment, current_deployment, deployment_of, } from './classes/index.js';
 export { deploymentHostingUnavailable, deploymentNotFound } from './errors/index.js';
 export { retireDeployment } from './functions/index.js';

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

@@ -1,6 +1,6 @@
 // Types first: the service module's Methods read them while this module's classes, which refer
 // to the Service class, are still evaluating.
-export { artifactModule, assetBundle, assetFile, deploymentCommit, deploymentHosting, deploymentRecord, deploymentRejection, deploymentRejectionReason, deploymentRequest, deploymentResponse, deploymentSecretDigest, deploymentSecretDigests, deploymentSecretRejection, deploymentSummary, frozenConfiguration, listDeploymentsInput, listDeploymentsOutput, listedDeploymentSummary, retireDeploymentInput, retireDeploymentOutput, unadmittedDeploymentSummary, } from './types/index.js';
+export { deploymentHosting, deploymentRejection, deploymentRejectionReason, deploymentRequest, deploymentResponse, deploymentSecretDigest, deploymentSecretDigests, deploymentSecretRejection, deploymentSummary, legacyDeploymentRecord, legacyFrozenConfiguration, listDeploymentsInput, listDeploymentsOutput, migrateLegacyInput, migrateLegacyOutput, retireDeploymentInput, retireDeploymentOutput, workerConfiguration, workerRecord, } from './types/index.js';
 export { CloudflareDeployment, Deployment, current_deployment, deployment_of, } from './classes/index.js';
 export { deploymentHostingUnavailable, deploymentNotFound } from './errors/index.js';
 export { retireDeployment } from './functions/index.js';

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

@@ -1,62 +1,27 @@
 import { z } from 'zod';
-/** Where this Services runtime addresses Services and deployments; their names are opaque. */
+/**
+ * `WorkerHostingV1`: the routing domain Services and deployments are addressed under. Every name is
+ * opaque: `https://<service>.<routing domain>` serves a Service, `https://<label>.<routing domain>`
+ * one deployment.
+ */
 export declare const deploymentHosting: z.ZodObject<{
     routingDomain: z.ZodString;
-    addressing: z.ZodLiteral<"opaque">;
 }, z.core.$strict>;
+/** `WorkerDeploymentListRequestV1`: the caller's deployments, of one project or environment. */
 export declare const listDeploymentsInput: z.ZodObject<{
-    origin: z.ZodOptional<z.ZodString>;
+    project: z.ZodOptional<z.ZodString>;
     environment: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
-/**
- * The deployments of the caller's Services. 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.
- */
+/** The deployments of the caller's Services, by creation then label. */
 export declare const listDeploymentsOutput: z.ZodObject<{
-    deployments: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        id: z.ZodString;
-        url: z.ZodString;
-        label: z.ZodString;
-        serviceId: z.ZodString;
-        service: z.ZodString;
-        owner: z.ZodString;
-        state: z.ZodEnum<{
-            active: "active";
-            deploying: "deploying";
-            failed: "failed";
-            retired: "retired";
-            retiring: "retiring";
-        }>;
-        current: z.ZodBoolean;
-        createdAt: z.ZodString;
-        retiredAt: z.ZodOptional<z.ZodString>;
-        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<{
+    deployments: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         url: z.ZodString;
         label: z.ZodString;
         serviceId: z.ZodString;
         service: z.ZodString;
+        project: z.ZodString;
+        environment: z.ZodString;
         owner: z.ZodString;
         state: z.ZodEnum<{
             active: "active";
@@ -68,8 +33,13 @@ export declare const listDeploymentsOutput: z.ZodObject<{
         current: z.ZodBoolean;
         createdAt: z.ZodString;
         retiredAt: z.ZodOptional<z.ZodString>;
-        signingKeyId: z.ZodString;
-        record: z.ZodUnknown;
-    }, z.core.$strict>]>>;
+        buildDigest: z.ZodString;
+        configuration: z.ZodString;
+        signingKeyId: z.ZodOptional<z.ZodString>;
+        record: z.ZodOptional<z.ZodObject<{
+            contentType: z.ZodString;
+            contentBase64: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type DeploymentHosting = z.output<typeof deploymentHosting>;

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

@@ -1,19 +1,19 @@
 import { z } from 'zod';
-import { listedDeploymentSummary } from './deployment-summary.js';
-/** Where this Services runtime addresses Services and deployments; their names are opaque. */
+import { deploymentSummary } from './deployment-summary.js';
+/**
+ * `WorkerHostingV1`: the routing domain Services and deployments are addressed under. Every name is
+ * opaque: `https://<service>.<routing domain>` serves a Service, `https://<label>.<routing domain>`
+ * one deployment.
+ */
 export const deploymentHosting = z.strictObject({
     routingDomain: z.string().min(1).max(253),
-    addressing: z.literal('opaque'),
 });
+/** `WorkerDeploymentListRequestV1`: the caller's deployments, of one project or environment. */
 export const listDeploymentsInput = z.strictObject({
-    origin: z.string().min(1).max(253).optional(),
+    project: z.string().min(1).max(253).optional(),
     environment: z.string().min(1).max(63).optional(),
 });
-/**
- * The deployments of the caller's Services. 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.
- */
+/** The deployments of the caller's Services, by creation then label. */
 export const listDeploymentsOutput = z.strictObject({
-    deployments: z.array(listedDeploymentSummary),
+    deployments: z.array(deploymentSummary),
 });