@astrale-domains/services 0.6.0 → 0.7.1

package/README.md

@@ -52,8 +52,8 @@ caller in three groups also reaches the Services of each.
   Service of the group, deletion included.
 - `OwnDeployment` gives a deployment to the owner of its Service.
 
-Every Method but `migrate` is `authenticated`: a deployer's identities on the Admin instance hold
-no `can_use` on Services' Functions, which an `authorized` Method requires of every non-Root caller.
+Every Method is `authenticated`: a deployer's identities on the Admin instance hold no `can_use`
+on Services' Functions, which an `authorized` Method requires of every non-Root caller.
 Each handler asks the Kernel `Identity.can` for the caller on its own session before it reads
 anything: a caller who does not own the Service finds none (`SERVICE_NOT_FOUND`,
 `DEPLOYMENT_NOT_FOUND`), and a deploy of another owner's Service is refused
@@ -81,7 +81,6 @@ Call them on the Admin instance (`astrale call ... --admin`). Their wire contrac
 | `setSchedule`, `schedules` | `CloudflareService` | Replaces or reads the Service's UTC cron set; each cron fires on the current deployment. |
 | `logs` | `CloudflareService` | Recent logs of the current deployment, or of one deployment named by `label`. |
 | `delete` | `CloudflareService` | Stops routing the Service, retires every deployment of it, then deletes it and frees its name. |
-| `migrate` | `CloudflareService` (static, Root) | Once, after this revision is installed: rewrites the Services and deployments stored before Services hosted any Worker (see [Migration](#migration-to-the-agnostic-model)). |
 | `retire` | `CloudflareDeployment` | Withdraws one deployment for good. The current deployment is never retired alone. |
 
 ## Deploying
@@ -221,39 +220,6 @@ build (esbuild) and deploy scripts. `npm run deploy -- <environment>` builds it,
 explains promotion and rollback, secrets, crons, logs and deletion. The scaffold lives in
 [`tooling/scaffold`](tooling/scaffold); `pnpm package` copies it to `dist/scaffold`.
 
-## Migration to the agnostic model
-
-The Kernel installs no Schema revision that existing data does not satisfy
-(`DATA_MIGRATION_REQUIRED`), and the SDK has no install-time migration: a Service stored before
-Services hosted any Worker names its project `origin`, and its deployments store the Domain's
-`FrozenConfigurationV1` and `DeploymentRecordV1`. The transition is expand, migrate, contract:
-
-1. **Expand** — this revision admits both forms. Every reader reads a legacy node as the Worker
-   deployment it is (`convertLegacyDeployment`): its build digest is its record's; its
-   configuration binds what the runtime that uploaded it bound (the compatibility date and flags,
-   the author's variables, `ASTRALE_SETTINGS` encoded from the frozen settings as that runtime
-   encoded it, the secret names, `record: true`, `signingIdentity: true`, `router` as it was); its
-   record is the RFC 8785 JSON its activation published, with the Astrale record media type. Its
-   label stays: a stored label is never derived again. Every writer writes the agnostic form only.
-2. **Migrate** — the Kernel's Root calls `CloudflareService.migrate` once. Each legacy Service and
-   deployment is rewritten by its own fenced Mutation (`origin` becomes `project`; a deployment
-   stores its reading), nothing is written at Cloudflare, and a rerun rewrites nothing more. It
-   answers how many it rewrote and names any deployment it could not read (`unconverted`, empty
-   when everything converted).
-3. **Contract** — the next revision drops the legacy shapes and `migrate`; the Kernel installs it
-   only once no legacy value remains.
-
-Call it as the Admin Kernel's Root, with a short-lived root credential file (`--creds`) removed
-once the call answers:
-
-```sh
-astrale call "/:services.astrale.ai:class.CloudflareService:migrate" --admin --json \
-  --creds "$ROOT_CREDENTIAL_FILE"
-```
-
-It answers `{ "services": <n>, "deployments": <n>, "unconverted": [] }`; a second call answers
-zeros.
-
 ## Admin-hosted runtime
 
 Services are hosted for the Admin instance's Kernel alone: its graph is the registry of Service

package/dist/scaffold/template/README.md

@@ -48,7 +48,7 @@ astrale call "$SERVICE.method.schedules" --admin --json
 astrale call "$SERVICE.method.logs" --admin -d '{"tail":50}' --json
 astrale call "$SERVICE.method.setSecret" --admin -d @secret.json --json   # { "name", "value" }
 astrale call "$SERVICE.method.secrets" --admin --json                      # names only
-astrale call "$SERVICE.method.delete" --admin --json
+astrale call "$SERVICE.method.delete" --admin --json                       # again after retryAfterMs (~65 s)
 astrale call /:services.astrale.ai:class.CloudflareService:list \
   project=<project> environment=production --admin --json
 ```
@@ -63,7 +63,7 @@ astrale call /:services.astrale.ai:class.CloudflareService:list \
   binds the values it carries.
 - **Crons**: five-field UTC expressions. Each due cron is posted by the Services dispatcher to the
   deployment the Service serves, as `POST https://cron.internal/__scheduled` with `x-astrale-cron`
-  (the expression) and `x-astrale-scheduled-time` (the minute it fired for, in epoch ms), within a
+  (the expression) and `x-astrale-scheduled-time` (the dispatcher's scheduled time in epoch ms, not rounded to the minute), within a
   10 s deadline. The public never reaches `/__scheduled`, in any spelling, and a run is at most once
   per minute but not exactly once: make the job safe to repeat.
 - **Logs**: `logs` reads the recent logs of the current deployment, or of one by `label`.

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

@@ -7,8 +7,8 @@ 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.
+   * in `x-astrale-cron` and the dispatcher's scheduled time (epoch ms, not rounded to the minute) 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

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 { 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';
+export { CloudflareDeployment, Deployment, OwnDeployment, TraverseOwnedServiceDeployment, current_deployment, deployment_of, deploymentHosting, deploymentLifecycle, deploymentRejection, deploymentRequest, deploymentResponse, deploymentSecretDigests, deploymentSecretRejection, deploymentSummary, retireDeploymentOutput, workerConfiguration, workerRecord, } from './modules/deployment/index.js';
+export type { DeploymentHosting, DeploymentLifecycle, DeploymentLifecycleEvent, DeploymentRejection, DeploymentRejectionReason, DeploymentRequest, DeploymentResponse, DeploymentSecretDigest, DeploymentSecretRejection, DeploymentSummary, 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 { 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 { CloudflareDeployment, Deployment, OwnDeployment, TraverseOwnedServiceDeployment, current_deployment, deployment_of, deploymentHosting, deploymentLifecycle, deploymentRejection, deploymentRequest, deploymentResponse, deploymentSecretDigests, deploymentSecretRejection, deploymentSummary, retireDeploymentOutput, workerConfiguration, workerRecord, } from './modules/deployment/index.js';

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

@@ -29,10 +29,8 @@ export declare const CloudflareDeployment: import("@astrale-os/sdk/schema").Auth
                 required?: boolean;
                 description?: string;
             }>;
-            buildDigest: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {
-                readonly required: false;
-            }>;
-            configuration: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            buildDigest: import("zod").ZodString;
+            configuration: import("zod").ZodObject<{
                 format: import("zod").ZodLiteral<"astrale.worker.configuration">;
                 version: import("zod").ZodLiteral<1>;
                 compatibilityDate: import("zod").ZodString;
@@ -42,72 +40,12 @@ export declare const CloudflareDeployment: import("@astrale-os/sdk/schema").Auth
                 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>;
-                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>]>;
-            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<{
+            }, import("zod/v4/core").$strict>;
+            configurationDigest: import("zod").ZodString;
+            record: import("@astrale-os/sdk/schema").AuthoredProperty<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>]>, {
+            }, import("zod/v4/core").$strict>, {
                 readonly required: false;
             }>;
             secretDigests: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodArray<import("zod").ZodObject<{

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

@@ -4,10 +4,6 @@ import { z } from 'zod';
  * 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;
@@ -39,11 +35,9 @@ export declare const Deployment: import("@astrale-os/sdk/schema").AuthoredNodeCl
             description?: string;
         }>;
         /** The build digest of the uploaded Worker, bound as `ASTRALE_BUILD_DIGEST`. */
-        buildDigest: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodString, {
-            readonly required: false;
-        }>;
+        buildDigest: z.ZodString;
         /** The configuration frozen into this deployment. */
-        configuration: z.ZodUnion<readonly [z.ZodObject<{
+        configuration: z.ZodObject<{
             format: z.ZodLiteral<"astrale.worker.configuration">;
             version: z.ZodLiteral<1>;
             compatibilityDate: z.ZodString;
@@ -53,74 +47,14 @@ export declare const Deployment: import("@astrale-os/sdk/schema").AuthoredNodeCl
             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>;
-            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>]>;
+        }, z.core.$strict>;
         /** The digest of `configuration` (`workerConfigurationDigest`). */
-        configurationDigest: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodString, {
-            readonly required: false;
-        }>;
+        configurationDigest: z.ZodString;
         /** The record the deployment publishes, when its configuration asks for one. */
-        record: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodUnion<readonly [z.ZodObject<{
+        record: import("@astrale-os/sdk/schema").AuthoredProperty<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>]>, {
+        }, z.core.$strict>, {
             readonly required: false;
         }>;
         /** The keyed digest of each secret bound to this deployment, never a value. */

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

@@ -2,17 +2,13 @@ import { classIcon, fullMatch, K, nodeClass, property, schema as valueSchema, st
 import { Rocket } from '@astrale-os/sdk/schema/icons';
 import { z } from 'zod';
 import { deploymentLifecycle } from '../states/index.js';
-import { deploymentSecretDigests, legacyDeploymentRecord, legacyFrozenConfiguration, workerConfiguration, workerRecord, } from '../types/index.js';
+import { deploymentSecretDigests, workerConfiguration, workerRecord } from '../types/index.js';
 const digest = z.string().check(fullMatch('sha256:[0-9a-f]{64}'));
 /**
  * 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,
@@ -25,13 +21,13 @@ export const Deployment = nodeClass({
         url: z.string().min(1).max(2_048),
         state: stateProperty(deploymentLifecycle),
         /** The build digest of the uploaded Worker, bound as `ASTRALE_BUILD_DIGEST`. */
-        buildDigest: property(digest, { required: false }),
+        buildDigest: digest,
         /** The configuration frozen into this deployment. */
-        configuration: z.union([workerConfiguration, legacyFrozenConfiguration]),
+        configuration: workerConfiguration,
         /** The digest of `configuration` (`workerConfigurationDigest`). */
-        configurationDigest: property(digest, { required: false }),
+        configurationDigest: digest,
         /** The record the deployment publishes, when its configuration asks for one. */
-        record: property(z.union([workerRecord, legacyDeploymentRecord]), { required: false }),
+        record: property(workerRecord, { required: false }),
         /** The keyed digest of each secret bound to this deployment, never a value. */
         secretDigests: property(deploymentSecretDigests, { 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: "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;
+    } | {
+        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;
     };
 }, "authenticated", false, false, undefined>>;

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

@@ -1,5 +1,5 @@
-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 { deploymentHosting, deploymentRejection, deploymentRejectionReason, deploymentRequest, deploymentResponse, deploymentSecretDigest, deploymentSecretDigests, deploymentSecretRejection, deploymentSummary, listDeploymentsInput, listDeploymentsOutput, retireDeploymentInput, retireDeploymentOutput, workerConfiguration, workerRecord, } from './types/index.js';
+export type { DeploymentHosting, DeploymentRejection, DeploymentRejectionReason, DeploymentRequest, DeploymentResponse, DeploymentSecretDigest, DeploymentSecretRejection, DeploymentSummary, 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 { deploymentHosting, deploymentRejection, deploymentRejectionReason, deploymentRequest, deploymentResponse, deploymentSecretDigest, deploymentSecretDigests, deploymentSecretRejection, deploymentSummary, legacyDeploymentRecord, legacyFrozenConfiguration, listDeploymentsInput, listDeploymentsOutput, migrateLegacyInput, migrateLegacyOutput, retireDeploymentInput, retireDeploymentOutput, workerConfiguration, workerRecord, } from './types/index.js';
+export { deploymentHosting, deploymentRejection, deploymentRejectionReason, deploymentRequest, deploymentResponse, deploymentSecretDigest, deploymentSecretDigests, deploymentSecretRejection, deploymentSummary, listDeploymentsInput, listDeploymentsOutput, 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/index.d.ts

@@ -12,10 +12,6 @@ export { deploymentSecretDigest, deploymentSecretDigests } from './deployment-se
 export type { DeploymentSecretDigest } from './deployment-secret-digest.js';
 export { deploymentSummary } from './deployment-summary.js';
 export type { DeploymentSummary } from './deployment-summary.js';
-export { legacyDeploymentRecord, legacyFrozenConfiguration } from './legacy-deployment.js';
-export type { LegacyDeploymentRecord, LegacyFrozenConfiguration } from './legacy-deployment.js';
-export { migrateLegacyInput, migrateLegacyOutput } from './legacy-migration.js';
-export type { MigrateLegacyResult } from './legacy-migration.js';
 export { workerConfiguration } from './worker-configuration.js';
 export type { WorkerConfiguration } from './worker-configuration.js';
 export { workerRecord } from './worker-record.js';

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

@@ -5,7 +5,5 @@ export { retireDeploymentInput, retireDeploymentOutput } from './deployment-reti
 export { deploymentSecretRejection } from './deployment-secret.js';
 export { deploymentSecretDigest, deploymentSecretDigests } from './deployment-secret-digest.js';
 export { deploymentSummary } from './deployment-summary.js';
-export { legacyDeploymentRecord, legacyFrozenConfiguration } from './legacy-deployment.js';
-export { migrateLegacyInput, migrateLegacyOutput } from './legacy-migration.js';
 export { workerConfiguration } from './worker-configuration.js';
 export { workerRecord } from './worker-record.js';

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

@@ -11,12 +11,7 @@ export declare const CloudflareService: import("@astrale-os/sdk/schema").Authore
         readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
         readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
         readonly properties: {
-            project: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {
-                readonly required: false;
-            }>;
-            origin: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {
-                readonly required: false;
-            }>;
+            project: import("zod").ZodString;
             environment: import("zod").ZodString;
             fingerprint: import("zod").ZodString;
             url: import("zod").ZodString;
@@ -240,17 +235,6 @@ export declare const CloudflareService: import("@astrale-os/sdk/schema").Authore
                 retryAfterMs: number;
             };
         }, "authenticated", false, false, undefined>>;
-        migrate: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
-            readonly mode: 'value';
-            readonly value: {
-                services: number;
-                deployments: number;
-                unconverted: {
-                    id: string;
-                    reason: string;
-                }[];
-            };
-        }, "authorized", true, false, undefined>>;
     };
     readonly policies: {
         read: () => import("@astrale-os/sdk/schema").Policy;

package/dist/schema/modules/service/classes/cloudflare-service.js

@@ -7,7 +7,6 @@ import { listServiceDeployments } from '../functions/list-service-deployments.js
 import { listServiceLogs } from '../functions/list-service-logs.js';
 import { listServiceSchedules } from '../functions/list-service-schedules.js';
 import { listServiceSecretNames } from '../functions/list-service-secret-names.js';
-import { migrateLegacyDeployments } from '../functions/migrate-legacy-deployments.js';
 import { promoteService } from '../functions/promote-service.js';
 import { replaceServiceSchedules } from '../functions/replace-service-schedules.js';
 import { setServiceSecret } from '../functions/set-service-secret.js';
@@ -34,7 +33,6 @@ export const CloudflareService = nodeClass({
         schedules: listServiceSchedules,
         logs: listServiceLogs,
         delete: deleteService,
-        migrate: migrateLegacyDeployments,
     },
     policies: { read: () => OwnService },
 });

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

@@ -5,9 +5,6 @@ import { z } from 'zod';
  * immutable Deployment of it, and its URL serves the one it currently points at. Its `name` is the
  * SDK's `serviceName(project, environment)`: the DNS label of the Service and the prefix of each
  * deployment's label, unique among Services, and free again once the Service is deleted.
- *
- * LEGACY: a Service created before Services hosted any Worker names its project `origin` until
- * `CloudflareService.migrate` renames it; the next Schema revision requires `project`.
  */
 export declare const Service: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
     readonly abstract: true;
@@ -16,13 +13,7 @@ export declare const Service: import("@astrale-os/sdk/schema").AuthoredNodeClass
     readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
     readonly properties: {
         /** Any project name; a Domain deployer names its Domain's origin. */
-        project: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodString, {
-            readonly required: false;
-        }>;
-        /** LEGACY: the project of a Service created before Services hosted any Worker. */
-        origin: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodString, {
-            readonly required: false;
-        }>;
+        project: z.ZodString;
         environment: z.ZodString;
         /** `serviceName(project, environment)`, 16 characters; it alone identifies the Service. */
         fingerprint: z.ZodString;

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

@@ -1,4 +1,4 @@
-import { classIcon, fullMatch, K, nodeClass, property, stateProperty } from '@astrale-os/sdk/schema';
+import { classIcon, fullMatch, K, nodeClass, stateProperty } from '@astrale-os/sdk/schema';
 import { Server } from '@astrale-os/sdk/schema/icons';
 import { z } from 'zod';
 import { serviceLifecycle } from '../states/index.js';
@@ -8,9 +8,6 @@ import { serviceLifecycle } from '../states/index.js';
  * immutable Deployment of it, and its URL serves the one it currently points at. Its `name` is the
  * SDK's `serviceName(project, environment)`: the DNS label of the Service and the prefix of each
  * deployment's label, unique among Services, and free again once the Service is deleted.
- *
- * LEGACY: a Service created before Services hosted any Worker names its project `origin` until
- * `CloudflareService.migrate` renames it; the next Schema revision requires `project`.
  */
 export const Service = nodeClass({
     abstract: true,
@@ -19,9 +16,7 @@ export const Service = nodeClass({
     extends: [K.classes.Named, K.classes.Timestamped],
     properties: {
         /** Any project name; a Domain deployer names its Domain's origin. */
-        project: property(z.string().min(1).max(253), { required: false }),
-        /** LEGACY: the project of a Service created before Services hosted any Worker. */
-        origin: property(z.string().min(1).max(253), { required: false }),
+        project: z.string().min(1).max(253),
         environment: z.string().min(1).max(63),
         /** `serviceName(project, environment)`, 16 characters; it alone identifies the Service. */
         fingerprint: z.string().check(fullMatch('[a-z2-7]{16}')),

package/dist/schema/modules/service/functions/index.d.ts

@@ -5,7 +5,6 @@ export { listServiceDeployments } from './list-service-deployments.js';
 export { listServiceLogs } from './list-service-logs.js';
 export { listServiceSchedules } from './list-service-schedules.js';
 export { listServiceSecretNames } from './list-service-secret-names.js';
-export { migrateLegacyDeployments } from './migrate-legacy-deployments.js';
 export { promoteService } from './promote-service.js';
 export { replaceServiceSchedules } from './replace-service-schedules.js';
 export { setServiceSecret } from './set-service-secret.js';

package/dist/schema/modules/service/functions/index.js

@@ -5,7 +5,6 @@ export { listServiceDeployments } from './list-service-deployments.js';
 export { listServiceLogs } from './list-service-logs.js';
 export { listServiceSchedules } from './list-service-schedules.js';
 export { listServiceSecretNames } from './list-service-secret-names.js';
-export { migrateLegacyDeployments } from './migrate-legacy-deployments.js';
 export { promoteService } from './promote-service.js';
 export { replaceServiceSchedules } from './replace-service-schedules.js';
 export { setServiceSecret } from './set-service-secret.js';

package/dist/schema/modules/service/functions/promote-service.d.ts

@@ -4,11 +4,11 @@ export declare const promoteService: import("@astrale-os/sdk/schema").Method<imp
 }, {
     readonly mode: 'value';
     readonly value: {
-        current: string;
-    } | {
         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;
+    } | {
+        current: string;
     };
 }, "authenticated", false, false, undefined>>;

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

@@ -4,11 +4,11 @@ export declare const setServiceSecret: import("@astrale-os/sdk/schema").Method<i
 }, {
     readonly mode: 'value';
     readonly value: {
-        name: string;
-    } | {
         kind: "rejected";
         reason: "secret-undeclared" | "service-unavailable";
         message: string;
         retryAfter?: string | undefined;
+    } | {
+        name: string;
     };
 }, "authenticated", false, false, undefined>>;

package/dist/schema/modules/service/functions/transfer-service.d.ts

@@ -4,11 +4,11 @@ export declare const transferService: import("@astrale-os/sdk/schema").Method<im
 }, {
     readonly mode: 'value';
     readonly value: {
+        owner: string;
+    } | {
         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;
-    } | {
-        owner: string;
     };
 }, "authenticated", false, false, undefined>>;

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

@@ -1,5 +1,5 @@
 export { CloudflareService, Service, service_owned_by } from './classes/index.js';
-export { deleteService, deployService, describeHosting, listServiceDeployments, listServiceLogs, listServiceSchedules, listServiceSecretNames, migrateLegacyDeployments, promoteService, replaceServiceSchedules, setServiceSecret, transferService, } from './functions/index.js';
+export { deleteService, deployService, describeHosting, listServiceDeployments, listServiceLogs, listServiceSchedules, listServiceSecretNames, promoteService, replaceServiceSchedules, setServiceSecret, transferService, } from './functions/index.js';
 export { serviceNotFound } from './errors/index.js';
 export { ActAs, OwnService, TraverseOwnedService } from './policies/index.js';
 export { serviceLifecycle } from './states/index.js';

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

@@ -1,5 +1,5 @@
 export { CloudflareService, Service, service_owned_by } from './classes/index.js';
-export { deleteService, deployService, describeHosting, listServiceDeployments, listServiceLogs, listServiceSchedules, listServiceSecretNames, migrateLegacyDeployments, promoteService, replaceServiceSchedules, setServiceSecret, transferService, } from './functions/index.js';
+export { deleteService, deployService, describeHosting, listServiceDeployments, listServiceLogs, listServiceSchedules, listServiceSecretNames, promoteService, replaceServiceSchedules, setServiceSecret, transferService, } from './functions/index.js';
 export { serviceNotFound } from './errors/index.js';
 export { ActAs, OwnService, TraverseOwnedService } from './policies/index.js';
 export { serviceLifecycle } from './states/index.js';

package/dist/schema/schema.d.ts

@@ -8,12 +8,7 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
             readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
             readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
             readonly properties: {
-                project: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {
-                    readonly required: false;
-                }>;
-                origin: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {
-                    readonly required: false;
-                }>;
+                project: import("zod").ZodString;
                 environment: import("zod").ZodString;
                 fingerprint: import("zod").ZodString;
                 url: import("zod").ZodString;
@@ -37,12 +32,7 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                 readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
                 readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
                 readonly properties: {
-                    project: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {
-                        readonly required: false;
-                    }>;
-                    origin: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {
-                        readonly required: false;
-                    }>;
+                    project: import("zod").ZodString;
                     environment: import("zod").ZodString;
                     fingerprint: import("zod").ZodString;
                     url: import("zod").ZodString;
@@ -190,12 +180,12 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                 }, {
                     readonly mode: 'value';
                     readonly value: {
-                        current: string;
-                    } | {
                         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;
+                    } | {
+                        current: string;
                     };
                 }, "authenticated", false, false, undefined>>;
                 transfer: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
@@ -266,17 +256,6 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                         retryAfterMs: number;
                     };
                 }, "authenticated", false, false, undefined>>;
-                migrate: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
-                    readonly mode: 'value';
-                    readonly value: {
-                        services: number;
-                        deployments: number;
-                        unconverted: {
-                            id: string;
-                            reason: string;
-                        }[];
-                    };
-                }, "authorized", true, false, undefined>>;
             };
             readonly policies: {
                 read: () => import("@astrale-os/sdk/schema").Policy;
@@ -326,10 +305,8 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                     required?: boolean;
                     description?: string;
                 }>;
-                buildDigest: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {
-                    readonly required: false;
-                }>;
-                configuration: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                buildDigest: import("zod").ZodString;
+                configuration: import("zod").ZodObject<{
                     format: import("zod").ZodLiteral<"astrale.worker.configuration">;
                     version: import("zod").ZodLiteral<1>;
                     compatibilityDate: import("zod").ZodString;
@@ -339,72 +316,12 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                     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>;
-                    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>]>;
-                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<{
+                }, import("zod/v4/core").$strict>;
+                configurationDigest: import("zod").ZodString;
+                record: import("@astrale-os/sdk/schema").AuthoredProperty<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>]>, {
+                }, import("zod/v4/core").$strict>, {
                     readonly required: false;
                 }>;
                 secretDigests: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodArray<import("zod").ZodObject<{
@@ -473,10 +390,8 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                         required?: boolean;
                         description?: string;
                     }>;
-                    buildDigest: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {
-                        readonly required: false;
-                    }>;
-                    configuration: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                    buildDigest: import("zod").ZodString;
+                    configuration: import("zod").ZodObject<{
                         format: import("zod").ZodLiteral<"astrale.worker.configuration">;
                         version: import("zod").ZodLiteral<1>;
                         compatibilityDate: import("zod").ZodString;
@@ -486,72 +401,12 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                         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>;
-                        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>]>;
-                    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<{
+                    }, import("zod/v4/core").$strict>;
+                    configurationDigest: import("zod").ZodString;
+                    record: import("@astrale-os/sdk/schema").AuthoredProperty<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>]>, {
+                    }, import("zod/v4/core").$strict>, {
                         readonly required: false;
                     }>;
                     secretDigests: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodArray<import("zod").ZodObject<{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-domains/services",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/astrale-os/domains.git",
@@ -84,7 +84,9 @@
     "provider:doctor": "bun providers/cloudflare/operator/maintenance/doctor.ts",
     "provider:platform-bootstrap": "bun providers/cloudflare/operator/platform-namespace/bootstrap.ts",
     "provider:platform-retire": "bun scripts/platform-namespace/retire.ts",
+    "provider:platform-record-metadata": "bun providers/cloudflare/operator/platform-namespace/record-metadata.ts",
     "provider:platform-secret": "bun providers/cloudflare/operator/platform-namespace/secret.ts",
+    "provider:record-metadata": "bun providers/cloudflare/operator/maintenance/record-metadata.ts",
     "typecheck": "tsc --noEmit && tsc --project providers/cloudflare/legacy/tsconfig.json",
     "test": "vitest run --config vitest.config.ts && pnpm run accessibility:check",
     "accessibility:check": "oxlint ui views frontend/src --jsx-a11y-plugin --react-plugin --deny-warnings",

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

@@ -1,65 +0,0 @@
-import { z } from 'zod';
-/** The `FrozenConfigurationV1` a legacy deployment stores. */
-export declare const legacyFrozenConfiguration: 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 `DeploymentRecordV1` a legacy deployment stores, as its deployer declared it. */
-export declare const legacyDeploymentRecord: 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>;
-export type LegacyFrozenConfiguration = z.output<typeof legacyFrozenConfiguration>;
-export type LegacyDeploymentRecord = z.output<typeof legacyDeploymentRecord>;

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

@@ -1,79 +0,0 @@
-import { fullMatch } from '@astrale-os/sdk/schema';
-import { z } from 'zod';
-/*
- * LEGACY — what a deployment created before Services hosted any Worker stores: the Domain's
- * `FrozenConfigurationV1` in `configuration` and its `DeploymentRecordV1` in `record`. Nothing
- * writes them any more: `CloudflareService.migrate` rewrites each one as a Worker deployment, and
- * the next Schema revision drops these shapes.
- */
-const name = z.string().min(1).max(128);
-const positive = z.number().int().min(1);
-const digest = z.string().check(fullMatch('sha256:[0-9a-f]{64}'));
-/** The `FrozenConfigurationV1` a legacy deployment stores. */
-export const legacyFrozenConfiguration = z.strictObject({
-    format: z.literal('astrale.deployment.configuration'),
-    version: z.literal(1),
-    vars: z.record(name, z.string().max(64 * 1024)),
-    settings: z.strictObject({
-        maximumRequestBytes: z.number().int().min(1),
-        invocationTimeoutMs: z.number().int().min(1),
-        tokenExchange: z.union([
-            z.literal(false),
-            z.strictObject({ maximumLifetimeSeconds: z.number().int().min(1) }),
-        ]),
-        durableOptions: z
-            .strictObject({
-            retentionMs: positive.optional(),
-            retry: z
-                .strictObject({
-                initialIntervalMs: positive.optional(),
-                maxAttempts: positive.optional(),
-                maxIntervalMs: positive.optional(),
-            })
-                .optional(),
-            stepTimeoutMs: positive.optional(),
-        })
-            .optional(),
-    }),
-    runtime: z.strictObject({
-        compatibilityDate: z.string().min(1).max(32),
-        compatibilityFlags: z.array(name).max(64),
-    }),
-    bindings: z.strictObject({
-        services: z.array(z.strictObject({ name, service: name })).max(32),
-        dispatchNamespaces: z.array(z.strictObject({ name, namespace: name })).max(32),
-        secrets: z.array(name).max(64),
-    }),
-    router: z.union([
-        z.literal(false),
-        z.strictObject({
-            service: name,
-            hostSuffix: z.string().max(253),
-            minLabels: z.number().int().min(0).max(127),
-        }),
-    ]),
-});
-/** The `DeploymentRecordV1` a legacy deployment stores, as its deployer declared it. */
-export const legacyDeploymentRecord = z.strictObject({
-    format: z.literal('astrale.deployment-record'),
-    version: z.literal(1),
-    origin: z.string().min(1).max(253),
-    environment: z.string().min(1).max(63),
-    releaseDigest: digest,
-    buildDigest: digest,
-    schemaRevision: digest,
-    configuration: digest,
-    providerScript: z.string().min(1).max(57),
-    commit: z
-        .strictObject({
-        sha: z.string().check(fullMatch('[0-9a-fA-F]{40}')),
-        dirty: z.boolean(),
-        base: z
-            .strictObject({
-            version: z.string().min(1).max(256),
-            distance: z.number().int().min(0),
-        })
-            .optional(),
-    })
-        .nullable(),
-});

package/dist/schema/modules/deployment/types/legacy-migration.d.ts

@@ -1,17 +0,0 @@
-import { z } from 'zod';
-export declare const migrateLegacyInput: z.ZodObject<{}, z.core.$strict>;
-/**
- * What one migration rewrote: the Services whose `origin` became their `project`, and the
- * deployments whose Domain configuration and record became a Worker configuration and an opaque
- * record. A rerun rewrites nothing more. `unconverted` names the deployments it could not rewrite,
- * which stay as they are for the operator to inspect.
- */
-export declare const migrateLegacyOutput: z.ZodObject<{
-    services: z.ZodNumber;
-    deployments: z.ZodNumber;
-    unconverted: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        reason: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type MigrateLegacyResult = z.output<typeof migrateLegacyOutput>;

package/dist/schema/modules/deployment/types/legacy-migration.js

@@ -1,17 +0,0 @@
-import { z } from 'zod';
-/*
- * LEGACY — the transition of the deployments created before Services hosted any Worker. Removed
- * with the legacy shapes once every node is migrated.
- */
-export const migrateLegacyInput = z.strictObject({});
-/**
- * What one migration rewrote: the Services whose `origin` became their `project`, and the
- * deployments whose Domain configuration and record became a Worker configuration and an opaque
- * record. A rerun rewrites nothing more. `unconverted` names the deployments it could not rewrite,
- * which stay as they are for the operator to inspect.
- */
-export const migrateLegacyOutput = z.strictObject({
-    services: z.number().int().min(0),
-    deployments: z.number().int().min(0),
-    unconverted: z.array(z.strictObject({ id: z.string().min(1), reason: z.string().max(500) })),
-});

package/dist/schema/modules/service/functions/migrate-legacy-deployments.d.ts

@@ -1,17 +0,0 @@
-/**
- * LEGACY — rewrite every Service and deployment created before Services hosted any Worker in the
- * agnostic form, once, after this revision is installed and before the next one is. Only the
- * Kernel's Root calls it: an `authorized` Method without a Policy admits no other caller. Removed
- * with the legacy shapes.
- */
-export declare const migrateLegacyDeployments: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
-    readonly mode: 'value';
-    readonly value: {
-        services: number;
-        deployments: number;
-        unconverted: {
-            id: string;
-            reason: string;
-        }[];
-    };
-}, "authorized", true, false, undefined>>;

package/dist/schema/modules/service/functions/migrate-legacy-deployments.js

@@ -1,15 +0,0 @@
-import { method } from '@astrale-os/sdk/schema';
-import { migrateLegacyInput, migrateLegacyOutput } from '../../deployment/index.js';
-/**
- * LEGACY — rewrite every Service and deployment created before Services hosted any Worker in the
- * agnostic form, once, after this revision is installed and before the next one is. Only the
- * Kernel's Root calls it: an `authorized` Method without a Policy admits no other caller. Removed
- * with the legacy shapes.
- */
-export const migrateLegacyDeployments = method({
-    description: 'Rewrite the legacy Services and deployments in the agnostic Worker form.',
-    auth: 'authorized',
-    static: true,
-    input: migrateLegacyInput,
-    output: migrateLegacyOutput,
-});