@astrale-domains/services 0.5.1 → 0.6.0

package/dist/schema/modules/deployment/types/{frozen-configuration.d.ts → legacy-deployment.d.ts}

@@ -1,14 +1,6 @@
 import { z } from 'zod';
-/**
- * The `FrozenConfigurationV1` (`@astrale-os/sdk/deployment/address`) one deployment freezes beside
- * its build: the author's plain variables, the execution settings and the durable Workflow options
- * it declares, the runtime, the services and dispatch namespaces it binds and the names of the
- * secrets it binds, never their values. Its digest and the build digest make the deployment's
- * address. This shape only bounds what a request and the graph carry; the SDK's
- * `configurationDigest` admits its canonical form, and a hosted deployment's admission decides
- * which bindings Services hosts (`acceptDeploymentRequest`).
- */
-export declare const frozenConfiguration: z.ZodObject<{
+/** 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>;
@@ -49,4 +41,25 @@ export declare const frozenConfiguration: z.ZodObject<{
         minLabels: z.ZodNumber;
     }, z.core.$strict>]>;
 }, z.core.$strict>;
-export type FrozenConfiguration = z.output<typeof frozenConfiguration>;
+/** 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/{frozen-configuration.js → legacy-deployment.js}

@@ -1,16 +1,16 @@
+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);
-/**
- * The `FrozenConfigurationV1` (`@astrale-os/sdk/deployment/address`) one deployment freezes beside
- * its build: the author's plain variables, the execution settings and the durable Workflow options
- * it declares, the runtime, the services and dispatch namespaces it binds and the names of the
- * secrets it binds, never their values. Its digest and the build digest make the deployment's
- * address. This shape only bounds what a request and the graph carry; the SDK's
- * `configurationDigest` admits its canonical form, and a hosted deployment's admission decides
- * which bindings Services hosts (`acceptDeploymentRequest`).
- */
-export const frozenConfiguration = z.strictObject({
+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)),
@@ -53,3 +53,27 @@ export const frozenConfiguration = z.strictObject({
         }),
     ]),
 });
+/** 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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,17 @@
+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/deployment/types/worker-configuration.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+/**
+ * The `WorkerConfigurationV1` (`@astrale-os/sdk/deployment/worker`) one deployment freezes beside
+ * its build: the Workers runtime it runs on, its plain variables, the names of its secrets (never
+ * their values) and what it asks of its host: the record it publishes, a signing identity of its
+ * own, the router. Its digest and the build digest make the deployment's label. This shape only
+ * bounds what a request and the graph carry; the SDK's `acceptWorkerConfiguration` admits its
+ * exact canonical form.
+ */
+export declare const workerConfiguration: z.ZodObject<{
+    format: z.ZodLiteral<"astrale.worker.configuration">;
+    version: z.ZodLiteral<1>;
+    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>;
+export type WorkerConfiguration = z.output<typeof workerConfiguration>;

package/dist/schema/modules/deployment/types/worker-configuration.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+const name = z.string().min(1).max(128);
+/**
+ * The `WorkerConfigurationV1` (`@astrale-os/sdk/deployment/worker`) one deployment freezes beside
+ * its build: the Workers runtime it runs on, its plain variables, the names of its secrets (never
+ * their values) and what it asks of its host: the record it publishes, a signing identity of its
+ * own, the router. Its digest and the build digest make the deployment's label. This shape only
+ * bounds what a request and the graph carry; the SDK's `acceptWorkerConfiguration` admits its
+ * exact canonical form.
+ */
+export const workerConfiguration = z.strictObject({
+    format: z.literal('astrale.worker.configuration'),
+    version: z.literal(1),
+    compatibilityDate: z.string().min(10).max(10),
+    compatibilityFlags: z.array(name).max(64),
+    vars: z.record(name, z.string().max(64 * 1024)),
+    secrets: z.array(name).max(64),
+    record: z.boolean(),
+    signingIdentity: z.boolean(),
+    router: z.boolean(),
+});

package/dist/schema/modules/deployment/types/worker-record.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+/**
+ * The record one deployment publishes (`WorkerRecordWireV1`): opaque bytes, as canonical Base64,
+ * and the media type the dispatcher serves them with at `/.well-known/astrale/deployment.json`.
+ * Services never reads it: it is the deployer's, and a deployment keeps the record it was created
+ * with. The SDK's `decodeWorkerRecord` admits it exactly.
+ */
+export declare const workerRecord: z.ZodObject<{
+    contentType: z.ZodString;
+    contentBase64: z.ZodString;
+}, z.core.$strict>;
+export type WorkerRecordWire = z.output<typeof workerRecord>;

package/dist/schema/modules/deployment/types/worker-record.js

@@ -0,0 +1,15 @@
+import { WORKER_DEPLOYMENT_LIMITS } from '@astrale-os/sdk/deployment/worker';
+import { z } from 'zod';
+/**
+ * The record one deployment publishes (`WorkerRecordWireV1`): opaque bytes, as canonical Base64,
+ * and the media type the dispatcher serves them with at `/.well-known/astrale/deployment.json`.
+ * Services never reads it: it is the deployer's, and a deployment keeps the record it was created
+ * with. The SDK's `decodeWorkerRecord` admits it exactly.
+ */
+export const workerRecord = z.strictObject({
+    contentType: z.string().min(3).max(256),
+    contentBase64: z
+        .string()
+        .min(4)
+        .max(Math.ceil(WORKER_DEPLOYMENT_LIMITS.recordSize / 3) * 4),
+});

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

@@ -1,4 +1,7 @@
-/** One Service whose deployments are Workers for Platforms scripts. */
+/**
+ * One Service whose deployments are Cloudflare Workers for Platforms scripts: any Cloudflare
+ * Worker, an Astrale Domain release or a generic Worker (an API, a cron job) alike.
+ */
 export declare const CloudflareService: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
     readonly description: "One Service whose deployments are Cloudflare Workers for Platforms scripts.";
     readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
@@ -8,7 +11,12 @@ 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: {
-            origin: import("zod").ZodString;
+            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;
+            }>;
             environment: import("zod").ZodString;
             fingerprint: import("zod").ZodString;
             url: import("zod").ZodString;
@@ -25,73 +33,30 @@ export declare const CloudflareService: import("@astrale-os/sdk/schema").Authore
     }>];
     readonly methods: {
         deploy: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
-            format: "astrale.services.deployment-request";
+            format: "astrale.worker.deployment-request";
             version: 1;
             owner?: string | undefined;
-            origin: string;
+            project: string;
             environment: string;
-            addressing: "opaque";
             label: string;
             buildDigest: string;
             configuration: {
-                format: "astrale.deployment.configuration";
+                format: "astrale.worker.configuration";
                 version: 1;
+                compatibilityDate: string;
+                compatibilityFlags: string[];
                 vars: Record<string, string>;
-                settings: {
-                    maximumRequestBytes: number;
-                    invocationTimeoutMs: number;
-                    tokenExchange: false | {
-                        maximumLifetimeSeconds: number;
-                    };
-                    durableOptions?: {
-                        retentionMs?: number | undefined;
-                        retry?: {
-                            initialIntervalMs?: number | undefined;
-                            maxAttempts?: number | undefined;
-                            maxIntervalMs?: number | undefined;
-                        } | undefined;
-                        stepTimeoutMs?: number | undefined;
-                    } | undefined;
-                };
-                runtime: {
-                    compatibilityDate: string;
-                    compatibilityFlags: string[];
-                };
-                bindings: {
-                    services: {
-                        name: string;
-                        service: string;
-                    }[];
-                    dispatchNamespaces: {
-                        name: string;
-                        namespace: string;
-                    }[];
-                    secrets: string[];
-                };
-                router: false | {
-                    service: string;
-                    hostSuffix: string;
-                    minLabels: number;
-                };
-            };
-            record: {
-                releaseDigest: string;
-                schemaRevision: string;
-                schemaBundle: string;
-                commit: {
-                    sha: string;
-                    dirty: boolean;
-                    base?: {
-                        version: string;
-                        distance: number;
-                    } | undefined;
-                } | null;
+                secrets: string[];
+                record: boolean;
+                signingIdentity: boolean;
+                router: boolean;
             };
-            bundle: {
-                entrypoint: string;
+            worker: {
+                manifest: Record<string, unknown>;
+                mainModule: string;
                 modules: {
                     name: string;
-                    kind?: "data" | "esm" | "text" | "wasm" | undefined;
+                    kind: "data" | "esm" | "text" | "wasm";
                     content: {
                         encoding: "gzip" | "identity";
                         decodedSize: number;
@@ -103,29 +68,26 @@ export declare const CloudflareService: import("@astrale-os/sdk/schema").Authore
                     };
                 }[];
                 assets?: {
-                    files: {
-                        path: string;
-                        contentType?: string | undefined;
-                        content: {
-                            encoding: "gzip" | "identity";
-                            decodedSize: number;
-                            contentBase64: string;
-                        } | {
-                            encoding: "gzip" | "identity";
-                            decodedSize: number;
-                            contentBase64Chunks: string[];
-                        };
-                    }[];
-                    notFound?: "404-page" | "none" | "single-page-application" | undefined;
-                    runWorkerFirst?: boolean | undefined;
-                    htmlHandling?: "none" | undefined;
-                } | undefined;
+                    path: string;
+                    contentType?: string | undefined;
+                    content: {
+                        encoding: "gzip" | "identity";
+                        decodedSize: number;
+                        contentBase64: string;
+                    } | {
+                        encoding: "gzip" | "identity";
+                        decodedSize: number;
+                        contentBase64Chunks: string[];
+                    };
+                }[] | undefined;
             };
+            record?: {
+                contentType: string;
+                contentBase64: string;
+            } | undefined;
+            readiness?: string[] | undefined;
             secrets: Record<string, string>;
             promote?: boolean | undefined;
-            readiness?: {
-                paths: string[];
-            } | undefined;
         }, {
             readonly mode: 'value';
             readonly value: {
@@ -145,31 +107,20 @@ export declare const CloudflareService: import("@astrale-os/sdk/schema").Authore
                     label: string;
                     serviceId: string;
                     service: string;
+                    project: string;
+                    environment: string;
                     owner: string;
                     state: "active" | "deploying" | "failed" | "retired" | "retiring";
                     current: boolean;
                     createdAt: string;
                     retiredAt?: string | undefined;
-                    signingKeyId: string;
-                    record: {
-                        format: "astrale.deployment-record";
-                        version: 1;
-                        origin: string;
-                        environment: string;
-                        releaseDigest: string;
-                        buildDigest: string;
-                        schemaRevision: string;
-                        configuration: string;
-                        providerScript: string;
-                        commit: {
-                            sha: string;
-                            dirty: boolean;
-                            base?: {
-                                version: string;
-                                distance: number;
-                            } | undefined;
-                        } | null;
-                    };
+                    buildDigest: string;
+                    configuration: string;
+                    signingKeyId?: string | undefined;
+                    record?: {
+                        contentType: string;
+                        contentBase64: string;
+                    } | undefined;
                 };
             };
         }, "authenticated", true, false, undefined>>;
@@ -177,60 +128,35 @@ export declare const CloudflareService: import("@astrale-os/sdk/schema").Authore
             readonly mode: 'value';
             readonly value: {
                 routingDomain: string;
-                addressing: "opaque";
             };
         }, "authenticated", true, false, undefined>>;
         list: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
-            origin?: string | undefined;
+            project?: string | undefined;
             environment?: string | undefined;
         }, {
             readonly mode: 'value';
             readonly value: {
-                deployments: ({
-                    id: string;
-                    url: string;
-                    label: string;
-                    serviceId: string;
-                    service: string;
-                    owner: string;
-                    state: "active" | "deploying" | "failed" | "retired" | "retiring";
-                    current: boolean;
-                    createdAt: string;
-                    retiredAt?: string | undefined;
-                    signingKeyId: string;
-                    record: {
-                        format: "astrale.deployment-record";
-                        version: 1;
-                        origin: string;
-                        environment: string;
-                        releaseDigest: string;
-                        buildDigest: string;
-                        schemaRevision: string;
-                        configuration: string;
-                        providerScript: string;
-                        commit: {
-                            sha: string;
-                            dirty: boolean;
-                            base?: {
-                                version: string;
-                                distance: number;
-                            } | undefined;
-                        } | null;
-                    };
-                } | {
+                deployments: {
                     id: string;
                     url: string;
                     label: string;
                     serviceId: string;
                     service: string;
+                    project: string;
+                    environment: string;
                     owner: string;
                     state: "active" | "deploying" | "failed" | "retired" | "retiring";
                     current: boolean;
                     createdAt: string;
                     retiredAt?: string | undefined;
-                    signingKeyId: string;
-                    record: unknown;
-                })[];
+                    buildDigest: string;
+                    configuration: string;
+                    signingKeyId?: string | undefined;
+                    record?: {
+                        contentType: string;
+                        contentBase64: string;
+                    } | undefined;
+                }[];
             };
         }, "authenticated", true, false, undefined>>;
         promote: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
@@ -314,6 +240,17 @@ 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,13 +7,17 @@ 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';
 import { transferService } from '../functions/transfer-service.js';
 import { OwnService } from '../policies/own-service.js';
 import { Service } from './service.js';
-/** One Service whose deployments are Workers for Platforms scripts. */
+/**
+ * One Service whose deployments are Cloudflare Workers for Platforms scripts: any Cloudflare
+ * Worker, an Astrale Domain release or a generic Worker (an API, a cron job) alike.
+ */
 export const CloudflareService = nodeClass({
     description: 'One Service whose deployments are Cloudflare Workers for Platforms scripts.',
     icon: classIcon.lucide(CloudCog),
@@ -30,6 +34,7 @@ export const CloudflareService = nodeClass({
         schedules: listServiceSchedules,
         logs: listServiceLogs,
         delete: deleteService,
+        migrate: migrateLegacyDeployments,
     },
     policies: { read: () => OwnService },
 });

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

@@ -1,10 +1,13 @@
 import { z } from 'zod';
 /**
- * One deployed Service: the stable identity of one origin in one environment, owned by one
- * Identity. Every deploy adds an immutable Deployment of it, and its URL serves the one it
- * currently points at. Its `name` derives from the origin and the environment: it is 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.
+ * One Service: the stable identity of one project in one environment, owned by one Identity,
+ * whatever its Worker serves (an Astrale Domain release, an API, a cron job). Every deploy adds an
+ * 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;
@@ -12,9 +15,16 @@ export declare const Service: import("@astrale-os/sdk/schema").AuthoredNodeClass
     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: {
-        origin: z.ZodString;
+        /** 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;
+        }>;
         environment: z.ZodString;
-        /** The 16-character fingerprint of `(origin, environment)`; it alone identifies the Service. */
+        /** `serviceName(project, environment)`, 16 characters; it alone identifies the Service. */
         fingerprint: z.ZodString;
         /** `https://<name>.<routing domain>`: always serves the current deployment. */
         url: z.ZodString;

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

@@ -1,13 +1,16 @@
-import { classIcon, fullMatch, K, nodeClass, stateProperty } from '@astrale-os/sdk/schema';
+import { classIcon, fullMatch, K, nodeClass, property, stateProperty } from '@astrale-os/sdk/schema';
 import { Server } from '@astrale-os/sdk/schema/icons';
 import { z } from 'zod';
 import { serviceLifecycle } from '../states/index.js';
 /**
- * One deployed Service: the stable identity of one origin in one environment, owned by one
- * Identity. Every deploy adds an immutable Deployment of it, and its URL serves the one it
- * currently points at. Its `name` derives from the origin and the environment: it is 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.
+ * One Service: the stable identity of one project in one environment, owned by one Identity,
+ * whatever its Worker serves (an Astrale Domain release, an API, a cron job). Every deploy adds an
+ * 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,
@@ -15,9 +18,12 @@ export const Service = nodeClass({
     icon: classIcon.lucide(Server),
     extends: [K.classes.Named, K.classes.Timestamped],
     properties: {
-        origin: z.string().min(1).max(253),
+        /** 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 }),
         environment: z.string().min(1).max(63),
-        /** The 16-character fingerprint of `(origin, environment)`; it alone identifies the Service. */
+        /** `serviceName(project, environment)`, 16 characters; it alone identifies the Service. */
         fingerprint: z.string().check(fullMatch('[a-z2-7]{16}')),
         /** `https://<name>.<routing domain>`: always serves the current deployment. */
         url: z.string().min(1).max(2_048),