@astrale-os/adapter-cloudflare 0.5.0-beta.164 → 0.5.0-beta.166

package/dist/build/worker/modules.js

@@ -5,7 +5,10 @@ const TYPES = Object.freeze({
     text: 'Text',
     data: 'Data',
 });
-/** Project one admitted Worker module inventory into Wrangler's relative module discovery. */
+/**
+ * Project one admitted Worker module inventory into Wrangler's relative module discovery. Rules
+ * follow module kinds, so the projection does not depend on the inventory's order.
+ */
 export function workerModules(worker) {
     const directory = posix.dirname(worker.entrypoint);
     const groups = new Map();
@@ -21,6 +24,9 @@ export function workerModules(worker) {
         globs.push(relative);
         groups.set(type, globs);
     }
-    const rules = [...groups].map(([type, globs]) => Object.freeze({ type, globs: Object.freeze(globs) }));
+    const rules = Object.values(TYPES).flatMap((type) => {
+        const globs = groups.get(type);
+        return globs === undefined ? [] : [Object.freeze({ type, globs: Object.freeze(globs) })];
+    });
     return Object.freeze({ baseDir: `./${directory}`, rules: Object.freeze(rules) });
 }

package/dist/build/worker/specifier.d.ts

@@ -1,3 +1,5 @@
 export declare function workerModuleSpecifier(): string;
 /** The isolate-startup module, which must stay free of the execution Service's dependencies. */
 export declare function frontModuleSpecifier(): string;
+/** The engine's Workers build, resolved from this adapter so a Domain needs no engine dependency. */
+export declare function restateModuleSpecifier(): string;

package/dist/build/worker/specifier.js

@@ -1,5 +1,6 @@
 import { fileURLToPath } from 'node:url';
 const workerModule = import.meta.resolve('@astrale-os/adapter-cloudflare/worker');
+const restateModule = import.meta.resolve('@astrale-os/adapter-cloudflare/worker/restate');
 const frontModule = import.meta.resolve('@astrale-os/adapter-cloudflare/worker/front');
 export function workerModuleSpecifier() {
     return fileURLToPath(workerModule);
@@ -8,3 +9,7 @@ export function workerModuleSpecifier() {
 export function frontModuleSpecifier() {
     return fileURLToPath(frontModule);
 }
+/** The engine's Workers build, resolved from this adapter so a Domain needs no engine dependency. */
+export function restateModuleSpecifier() {
+    return fileURLToPath(restateModule);
+}

package/dist/build/worker/upload.d.ts

@@ -0,0 +1,18 @@
+import type { PreparedArtifact } from '@astrale-os/sdk/deployment/adapter';
+import type { Build } from '@astrale-os/sdk/deployment/build';
+import type { BuildDigest } from '@astrale-os/sdk/deployment/build/manifest';
+import type { WorkerArtifact } from './artifact.js';
+import { type WorkerUpload } from '../../release/build.js';
+/** The portable upload of one prepared Worker: exactly the modules and assets Services receives. */
+export declare function workerUpload(artifact: PreparedArtifact, worker: WorkerArtifact): WorkerUpload;
+/** Build digest of the portable upload of one prepared Worker. */
+export declare function uploadBuildDigest(artifact: PreparedArtifact, worker: WorkerArtifact): BuildDigest;
+/** Record that preparation placed the CLI's Bundle for this Build. */
+export declare function recordPlacedBundle(build: Build): void;
+/**
+ * The `build` field of one prepared Worker's provider evidence: the build digest of its portable
+ * upload, present only when its preparation placed the CLI's Bundle.
+ */
+export declare function uploadBuildEvidence(artifact: PreparedArtifact, worker: WorkerArtifact): {
+    readonly build?: BuildDigest;
+};

package/dist/build/worker/upload.js

@@ -0,0 +1,40 @@
+import { buildDigest } from '@astrale-os/sdk/deployment/build/manifest';
+import { workerBuildManifest } from '../../release/build.js';
+/** The portable upload of one prepared Worker: exactly the modules and assets Services receives. */
+export function workerUpload(artifact, worker) {
+    const root = artifact.build.schema.compiled.root;
+    if (worker.origin !== root.origin || worker.revision !== root.revision) {
+        throw new TypeError('Worker artifact differs from its prepared Build.');
+    }
+    return Object.freeze({
+        origin: root.origin,
+        revision: root.revision,
+        bundle: artifact.build.schema.bundle.ref.digest,
+        entry: worker.release.entrypoint,
+        modules: worker.release.modules.map((module) => ({ name: module.path, bytes: module.bytes() })),
+        ...(worker.assets === undefined
+            ? {}
+            : { assets: worker.assets.files.map((file) => ({ path: file.path, bytes: file.bytes() })) }),
+    });
+}
+/** Build digest of the portable upload of one prepared Worker. */
+export function uploadBuildDigest(artifact, worker) {
+    return buildDigest(workerBuildManifest(workerUpload(artifact, worker)));
+}
+/**
+ * Builds whose preparation placed the Bundle `astrale-domain deploy` passed (`PrepareContext.bundle`).
+ * Only a CLI that passes a Bundle reads `ProviderDeploymentEvidence.build`: an older one refuses an
+ * evidence field it does not know, after the provider has applied the upload.
+ */
+const placedBuilds = new WeakSet();
+/** Record that preparation placed the CLI's Bundle for this Build. */
+export function recordPlacedBundle(build) {
+    placedBuilds.add(build);
+}
+/**
+ * The `build` field of one prepared Worker's provider evidence: the build digest of its portable
+ * upload, present only when its preparation placed the CLI's Bundle.
+ */
+export function uploadBuildEvidence(artifact, worker) {
+    return placedBuilds.has(artifact.build) ? { build: uploadBuildDigest(artifact, worker) } : {};
+}

package/dist/deploy/deploy.d.ts

@@ -1,5 +1,5 @@
 import type { DeployContext, DeployResult } from '@astrale-os/sdk/deployment/adapter';
-import type { Release } from '@astrale-os/sdk/deployment/release';
+import { legacy } from '@astrale-os/sdk/deployment/release';
 import type { materialize } from '../build/artifact.js';
 import type { WorkerArtifact } from '../build/worker/artifact.js';
 import type { signingIdentity } from '../identity/source.js';
@@ -10,7 +10,7 @@ export interface CloudflareDeployDependencies {
     readonly materialize: typeof materialize;
     readonly runWranglerRollout: typeof runWranglerRollout;
     readonly runWranglerDeploymentStatus: typeof runWranglerDeploymentStatus;
-    readonly waitForReadiness: (release: Release, signal: AbortSignal, version: string, worker: WorkerArtifact, workerName?: string) => Promise<void>;
+    readonly waitForReadiness: (release: legacy.Release, signal: AbortSignal, version: string, worker: WorkerArtifact, workerName?: string) => Promise<void>;
     readonly signingIdentity: typeof signingIdentity;
 }
 /** Deploy one stable Worker target and verify its exact serving implementation. */

package/dist/deploy/deploy.js

@@ -1,9 +1,10 @@
-import { addressing, assemble } from '@astrale-os/sdk/deployment/release';
+import { addressing, legacy } from '@astrale-os/sdk/deployment/release';
 import { mkdir, mkdtemp, rm } from 'node:fs/promises';
 import { join } from 'node:path';
-import { workerName } from '../build/configuration.js';
+import { isAdapterVar, workerName } from '../build/configuration.js';
 import { admitDirectPlacement } from '../build/direct.js';
 import { loadWorkerArtifact } from '../build/worker/index.js';
+import { uploadBuildEvidence } from '../build/worker/upload.js';
 import { signingIdentitySecrets } from '../identity/secret.js';
 import { WranglerDeployError } from '../wrangler/deploy.js';
 import { WranglerRolloutError } from '../wrangler/rollout.js';
@@ -24,8 +25,19 @@ export async function deployCloudflare(parameters, context, dependencies) {
         return failed('prerequisite', progress({}), cause);
     }
     let worker;
+    let build;
     try {
         worker = loadWorkerArtifact(context.artifact);
+        build = uploadBuildEvidence(context.artifact, worker);
+        const occupied = new Set([
+            ...Object.keys(worker.bindings.vars),
+            ...worker.bindings.services.map((binding) => binding.name),
+        ]);
+        for (const name of Object.keys(secrets)) {
+            if (occupied.has(name) || isAdapterVar(name)) {
+                throw new TypeError(`Cloudflare Worker secret ${name} collides with a binding.`);
+            }
+        }
         for (const name of worker.bindings.requiredSecrets) {
             if (!Object.hasOwn(secrets, name)) {
                 throw new TypeError(`Cloudflare Worker requires secret ${name}.`);
@@ -51,7 +63,7 @@ export async function deployCloudflare(parameters, context, dependencies) {
                 workerName: name,
                 verifyCandidate: async (candidate) => {
                     const selected = observeAddressing(context.artifact, candidate.url, name);
-                    const release = assemble(context.artifact.build, selected);
+                    const release = legacy.assemble(context.artifact.build, selected);
                     await dependencies.waitForReadiness(release, context.signal, candidate.deploymentVersion, worker, name);
                 },
                 secrets,
@@ -82,6 +94,7 @@ export async function deployCloudflare(parameters, context, dependencies) {
                 provider: 'cloudflare',
                 deployment: deployed.deploymentVersion,
                 artifact: context.artifact.digest,
+                ...build,
             }),
         });
         let selected;
@@ -112,7 +125,7 @@ export async function deployCloudflare(parameters, context, dependencies) {
         }
         let release;
         try {
-            release = assemble(context.artifact.build, selected);
+            release = legacy.assemble(context.artifact.build, selected);
         }
         catch (cause) {
             return failed('release', progress({ provider: retained, configuration }), cause);
@@ -129,6 +142,7 @@ export async function deployCloudflare(parameters, context, dependencies) {
                 provider: 'cloudflare',
                 deployment: deployed.deploymentVersion,
                 artifact: context.artifact.digest,
+                ...build,
                 issuer: selected.issuer,
             }),
         });

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * `@astrale-os/adapter-cloudflare` — deploy an Astrale application through
+ * `@astrale-os/adapter-cloudflare` — deploy an Astrale Domain through
  * Cloudflare Workers on YOUR OWN Cloudflare account.
  *
  *   import { cloudflare } from '@astrale-os/adapter-cloudflare'
@@ -19,4 +19,4 @@
  * tooling owns optional Kernel installation after provider readiness.
  */
 export { cloudflare } from './cloudflare.js';
-export type { CloudflareParams } from './params.js';
+export type { CloudflareParams, DurableWorkerOptions } from './params.js';

package/dist/index.js

@@ -1,5 +1,5 @@
 /**
- * `@astrale-os/adapter-cloudflare` — deploy an Astrale application through
+ * `@astrale-os/adapter-cloudflare` — deploy an Astrale Domain through
  * Cloudflare Workers on YOUR OWN Cloudflare account.
  *
  *   import { cloudflare } from '@astrale-os/adapter-cloudflare'

package/dist/params.d.ts

@@ -1,4 +1,4 @@
-import type { ExchangeOptions } from '@astrale-os/sdk/execution';
+import type { DurableServing, ExchangeOptions } from '@astrale-os/sdk/execution';
 /**
  * `CloudflareParams` — the provider-typed config for the Cloudflare adapter.
  *
@@ -50,6 +50,13 @@ export interface CloudflareParams {
      * The default maximum is 30 minutes; production and CI environments may select a shorter bound.
      */
     readonly tokenExchange?: ExchangeOptions | false;
+    /**
+     * What a Worker serving durable Workflows declares to the workflow engine, as `serve({ durable })`
+     * does: run retention, retry before pausing and the deadline of each Step. Canonical callbacks
+     * discover engine keys from their Kernel. The deprecated `ASTRALE_RESTATE_IDENTITY_KEYS` var
+     * admits retained legacy callbacks only.
+     */
+    readonly durable?: DurableWorkerOptions;
     /**
      * Escape hatch: raw wrangler config deep-merged over the generated base. Use
      * it to declare extra bindings the adapter has no typed field for — KV, R2,
@@ -67,6 +74,13 @@ export interface CloudflareParams {
      * `routes` are rejected — use `workerName` and `route` instead. Avoid
      * the reserved binding names `SELF` and `ASSETS`. Durable Objects need extra
      * worker-entry codegen and aren't supported through this field yet.
+     *
+     * The overlay reaches the deployment configuration, never the bundle: every
+     * Environment of one source bundles the same bytes. Keys the bundler reads
+     * (`alias`, `build`, `define`, `jsx_factory`, `jsx_fragment`, `keep_names`,
+     * `minify`, `no_bundle`, `node_compat`, `preserve_file_names`, `rules`,
+     * `tsconfig`, `upload_source_maps`) and compatibility flags it reads (Node.js,
+     * `navigator`, fetch iterable typing, Python) are rejected.
      */
     readonly wrangler?: Record<string, unknown>;
     /**
@@ -75,8 +89,9 @@ export interface CloudflareParams {
      * same-zone Worker calls honor public routes too.
      *
      * Wires BOTH halves the SDK needs: the `<binding>` service binding in the
-     * generated wrangler config, and a `routeSubrequest` predicate in the worker
-     * entry that diverts matching hosts through it.
+     * deployment's wrangler config, and the host suffix and label rule bound in
+     * `ASTRALE_SETTINGS`, which the Worker applies to divert matching hosts
+     * through that binding.
      *
      * Opt in only when the selected router owns every hostname matched by the
      * suffix/label predicate. A shared DNS suffix is not proof of router ownership:
@@ -96,3 +111,4 @@ export interface CloudflareParams {
         readonly minLabels?: number;
     };
 }
+export type DurableWorkerOptions = Pick<DurableServing, 'retentionMs' | 'retry' | 'stepTimeoutMs'>;

package/dist/release/build.d.ts

@@ -0,0 +1,35 @@
+import type { BuildManifestV1 } from '@astrale-os/sdk/deployment/build/manifest';
+/**
+ * The bundler of every generated Cloudflare Worker, whichever adapter deploys it. Its version names
+ * the upload layout below, not a package release: a Services host recomputes the same build digest
+ * from the same bytes whatever SDK it runs.
+ */
+export declare const CLOUDFLARE_WORKER_BUNDLER: Readonly<{
+    id: "cloudflare-worker";
+    version: "1";
+}>;
+/** Portable Worker upload: what Services receives, and what a dispatch namespace upload carries. */
+export interface WorkerUpload {
+    readonly origin: string;
+    readonly revision: BuildManifestV1['schema']['revision'];
+    /** Digest of the Domain Schema bundle. */
+    readonly bundle: BuildManifestV1['schema']['bundle'];
+    readonly entry: string;
+    readonly modules: readonly {
+        readonly name: string;
+        readonly bytes: Uint8Array;
+    }[];
+    /** Static assets by their absolute Worker asset path (`/index.html`). */
+    readonly assets?: readonly {
+        readonly path: string;
+        readonly bytes: Uint8Array;
+    }[];
+}
+/**
+ * The one build manifest of a Worker upload, computed on the exact upload the deploy sends; the
+ * SDK, Services and namespace mode all identify Worker code through it. Modules keep their uploaded
+ * name; a static asset `/<path>` is the file `assets/<path>`.
+ */
+export declare function workerBuildManifest(upload: WorkerUpload): BuildManifestV1;
+/** The build-manifest file of one Worker asset path. */
+export declare function workerAssetFile(path: string): string;

package/dist/release/build.js

@@ -0,0 +1,44 @@
+import { buildManifest } from '@astrale-os/sdk/deployment/build/manifest';
+/**
+ * The bundler of every generated Cloudflare Worker, whichever adapter deploys it. Its version names
+ * the upload layout below, not a package release: a Services host recomputes the same build digest
+ * from the same bytes whatever SDK it runs.
+ */
+export const CLOUDFLARE_WORKER_BUNDLER = Object.freeze({
+    id: 'cloudflare-worker',
+    version: '1',
+});
+/**
+ * The one build manifest of a Worker upload, computed on the exact upload the deploy sends; the
+ * SDK, Services and namespace mode all identify Worker code through it. Modules keep their uploaded
+ * name; a static asset `/<path>` is the file `assets/<path>`.
+ */
+export function workerBuildManifest(upload) {
+    if (upload === null || typeof upload !== 'object' || !Array.isArray(upload.modules)) {
+        throw new TypeError('Worker upload is invalid.');
+    }
+    if (upload.assets !== undefined && !Array.isArray(upload.assets)) {
+        throw new TypeError('Worker upload assets are invalid.');
+    }
+    return buildManifest({
+        origin: upload.origin,
+        revision: upload.revision,
+        bundle: upload.bundle,
+        bundler: CLOUDFLARE_WORKER_BUNDLER,
+        entrypoint: upload.entry,
+        files: [
+            ...upload.modules.map((module) => ({ path: module.name, content: module.bytes })),
+            ...(upload.assets ?? []).map((asset) => ({
+                path: workerAssetFile(asset.path),
+                content: asset.bytes,
+            })),
+        ],
+    });
+}
+/** The build-manifest file of one Worker asset path. */
+export function workerAssetFile(path) {
+    if (typeof path !== 'string' || !path.startsWith('/')) {
+        throw new TypeError('Worker asset path must be absolute.');
+    }
+    return `assets${path}`;
+}

package/dist/release/index.d.ts

@@ -1,2 +1,3 @@
+export { CLOUDFLARE_WORKER_BUNDLER, workerBuildManifest, type WorkerUpload } from './build.js';
 export { acceptWorkerDeployment, workerDeployment, workerDeploymentMaterial, type WorkerDeploymentId, type WorkerDeploymentInput, } from './deployment.js';
 export { stagedWorkerName } from './staged-worker-name.js';

package/dist/release/index.js

@@ -1,2 +1,3 @@
+export { CLOUDFLARE_WORKER_BUNDLER, workerBuildManifest } from './build.js';
 export { acceptWorkerDeployment, workerDeployment, workerDeploymentMaterial, } from './deployment.js';
 export { stagedWorkerName } from './staged-worker-name.js';

package/dist/worker/durable.d.ts

@@ -0,0 +1,11 @@
+import type { DurableEngine, DurableServing } from '@astrale-os/sdk/execution';
+/** @deprecated Static request identity keys for retained legacy callbacks only. */
+export declare const RESTATE_IDENTITY_KEYS_BINDING = "ASTRALE_RESTATE_IDENTITY_KEYS";
+export interface DurableBindings {
+    readonly [RESTATE_IDENTITY_KEYS_BINDING]?: string;
+}
+/**
+ * Canonical callbacks discover their engine's authority from the Kernel named in their path.
+ * The optional request preserves the three-argument legacy helper's static-key behavior.
+ */
+export declare function restateServing(engine: DurableEngine, bindings: DurableBindings, options?: Pick<DurableServing, 'retentionMs' | 'retry' | 'stepTimeoutMs'>, request?: Request): DurableServing | undefined;

package/dist/worker/durable.js

@@ -0,0 +1,24 @@
+import { isCanonicalDurableRequest, isLegacyDurableRequest } from '@astrale-os/sdk/execution';
+/** @deprecated Static request identity keys for retained legacy callbacks only. */
+export const RESTATE_IDENTITY_KEYS_BINDING = 'ASTRALE_RESTATE_IDENTITY_KEYS';
+/**
+ * Canonical callbacks discover their engine's authority from the Kernel named in their path.
+ * The optional request preserves the three-argument legacy helper's static-key behavior.
+ */
+export function restateServing(engine, bindings, options = {}, request) {
+    const canonical = request !== undefined && isCanonicalDurableRequest(request);
+    if (request !== undefined && !canonical && !isLegacyDurableRequest(request))
+        return undefined;
+    const value = bindings[RESTATE_IDENTITY_KEYS_BINDING];
+    if (value === undefined || value.trim() === '') {
+        return canonical ? Object.freeze({ ...options, engine }) : undefined;
+    }
+    return Object.freeze({
+        ...options,
+        engine,
+        identityKeys: Object.freeze(value
+            .split(',')
+            .map((key) => key.trim())
+            .filter((key) => key.length > 0)),
+    });
+}

package/dist/worker/entry.d.ts

@@ -1,20 +1,25 @@
 import type { JsonWebKey } from '@astrale-os/sdk/auth';
 import type { BuildMaterial, GeneratedBuildMaterial } from '@astrale-os/sdk/deployment/build/material';
-import type { ExchangeOptions, ExecutionContext } from '@astrale-os/sdk/execution';
+import type { DurableServingProvider, ExecutionContext } from '@astrale-os/sdk/execution';
 import type { Runtime } from '@astrale-os/sdk/runtime';
+import type { DurableWorkerOptions } from '../params.js';
 import type { CloudflareAdapterBindings, CloudflareFrontDoorConfig, Fetcher } from './front.js';
+import type { CloudflareWorkerSettings } from './settings.js';
 export type { CloudflareAdapterBindings, Fetcher } from './front.js';
-export interface CloudflareWorkerConfig<RuntimeValue extends Runtime, Bindings extends CloudflareAdapterBindings, Environment, Material = BuildMaterial> extends CloudflareFrontDoorConfig<Bindings> {
+export interface CloudflareWorkerConfig<RuntimeValue extends Runtime, Bindings extends CloudflareAdapterBindings, Environment, Material = BuildMaterial> extends CloudflareFrontDoorConfig<Bindings>, CloudflareWorkerSettings<Bindings> {
     /** Load the exact Runtime and Build once, after the isolate has accepted a request. */
     readonly load: () => CloudflareWorkerSource<RuntimeValue, Material> | Promise<CloudflareWorkerSource<RuntimeValue, Material>>;
     readonly privateKey: JsonWebKey | ((bindings: Bindings) => JsonWebKey);
     readonly resolveEnvironment?: (bindings: Bindings) => Environment;
-    readonly identityIssuer?: string;
     readonly selfBinding?: (bindings: Bindings) => Fetcher | null | undefined;
-    readonly routeSubrequest?: (url: URL, bindings: Bindings) => Fetcher | null | undefined;
-    readonly invocationTimeoutMs?: number;
-    readonly maximumRequestBytes?: number;
-    readonly tokenExchange?: ExchangeOptions | false;
+    /**
+     * Read the execution settings from the deployment's bindings on the isolate's first execution
+     * request, as generated Workers do with `deploymentSettings`. A hand-composed Worker states
+     * them in this configuration instead; one Worker never takes both.
+     */
+    readonly settings?: (bindings: Bindings) => CloudflareWorkerSettings<Bindings>;
+    /** Resolve the engine for this durable request with the deployment's captured options. */
+    readonly durable?: (bindings: Bindings, request: Request, options?: DurableWorkerOptions) => ReturnType<DurableServingProvider>;
 }
 export interface CloudflareWorkerSource<RuntimeValue extends Runtime, Material = BuildMaterial> {
     readonly runtime: RuntimeValue;

package/dist/worker/entry.js

@@ -1,10 +1,11 @@
 import { issuer } from '@astrale-os/sdk/auth';
 import { restoreBuild, restoreGeneratedBuild } from '@astrale-os/sdk/deployment/build/material';
-import { addressing, assemble } from '@astrale-os/sdk/deployment/release/runtime';
+import { addressing, legacy } from '@astrale-os/sdk/deployment/release/runtime';
 import { createIdentity, serve } from '@astrale-os/sdk/execution';
 import { dispatchCloudflareRequest, prepareCloudflareRequest } from './fetch.js';
 import { cloudflareFrontDoor, withProviderVersion } from './front.js';
 import { frontendAsset } from './frontend.js';
+import { DEFAULT_INVOCATION_TIMEOUT_MS, DEFAULT_MAXIMUM_REQUEST_BYTES } from './settings.js';
 /** Compose one Service implementation behind its provider-owned stable address. */
 export function cloudflareWorkerEntry() {
     return createCloudflareWorkerEntry(restoreBuild);
@@ -13,60 +14,82 @@ export function cloudflareWorkerEntry() {
 export function generatedCloudflareWorkerEntry() {
     return createCloudflareWorkerEntry(restoreGeneratedBuild);
 }
+/** The static settings a hand-composed Worker may state instead of reading its bindings. */
+const SETTINGS = [
+    'identityIssuer',
+    'routeSubrequest',
+    'invocationTimeoutMs',
+    'maximumRequestBytes',
+    'tokenExchange',
+    'durableOptions',
+];
 function createCloudflareWorkerEntry(restore) {
     return function (config) {
+        if (config.settings !== undefined && SETTINGS.some((key) => config[key] !== undefined)) {
+            throw new TypeError('Cloudflare Worker settings come from its deployment bindings or its configuration, not both.');
+        }
         const frontDoor = cloudflareFrontDoor(config);
-        let realized;
-        const realize = () => {
-            if (realized !== undefined)
-                return realized;
-            realized = Promise.resolve()
-                .then(config.load)
-                .then((source) => {
-                const build = restore(source.material, source.runtime);
-                const application = serve({
-                    runtime: source.runtime,
-                    load(environment) {
-                        if (frontDoor.current() !== environment.publicUrl) {
-                            throw new TypeError('Cloudflare Worker request origin differs from its current Release.');
-                        }
-                        return assemble(build, addressing(config.identityIssuer ?? environment.publicUrl, {
-                            publicUrl: environment.publicUrl,
-                        }));
-                    },
-                    initialize: (environment) => config.resolveEnvironment === undefined
-                        ? environment.bindings
-                        : config.resolveEnvironment(environment.bindings),
-                    identity(environment) {
-                        return createIdentity({
-                            issuer: issuer.accept(config.identityIssuer ?? environment.publicUrl),
-                            subject: build.schema.compiled.root.origin,
-                            privateKey: typeof config.privateKey === 'function'
-                                ? config.privateKey(environment.bindings)
-                                : config.privateKey,
-                            fetch: routedFetch(application, environment, config),
-                            ...(new URL(environment.publicUrl).protocol === 'http:'
-                                ? { allowInsecureHttp: true }
-                                : {}),
-                            ...(config.tokenExchange === undefined
-                                ? {}
-                                : { tokenExchange: config.tokenExchange }),
-                        });
-                    },
-                    server: {
-                        health: { probe: { check: () => true } },
-                        limits: {
-                            maximumRequestBytes: config.maximumRequestBytes ?? 1024 * 1024,
-                            maximumPublicationBytes: 1024 * 1024,
-                            maximumBundleBytes: 8 * 1024 * 1024,
-                            maximumDeliveryBytes: 8 * 1024 * 1024,
-                            invocationTimeoutMs: config.invocationTimeoutMs ?? 30_000,
-                        },
+        let restored;
+        let application;
+        const realize = () => (restored ??= Promise.resolve()
+            .then(config.load)
+            .then((source) => Object.freeze({
+            runtime: source.runtime,
+            build: restore(source.material, source.runtime),
+        })));
+        // Settings are a deployment's, so they are read from the first execution request's bindings.
+        const served = (source, bindings) => {
+            if (application !== undefined)
+                return application;
+            const { build } = source;
+            const settings = config.settings === undefined ? config : config.settings(bindings);
+            const created = serve({
+                runtime: source.runtime,
+                load(environment) {
+                    if (frontDoor.current() !== environment.publicUrl) {
+                        throw new TypeError('Cloudflare Worker request origin differs from its current Release.');
+                    }
+                    return legacy.assemble(build, addressing(settings.identityIssuer ?? environment.publicUrl, {
+                        publicUrl: environment.publicUrl,
+                    }));
+                },
+                initialize: (environment) => config.resolveEnvironment === undefined
+                    ? environment.bindings
+                    : config.resolveEnvironment(environment.bindings),
+                identity(environment) {
+                    return createIdentity({
+                        issuer: issuer.accept(settings.identityIssuer ?? environment.publicUrl),
+                        subject: build.schema.compiled.root.origin,
+                        privateKey: typeof config.privateKey === 'function'
+                            ? config.privateKey(environment.bindings)
+                            : config.privateKey,
+                        fetch: routedFetch(created, environment, config.selfBinding, settings.routeSubrequest),
+                        ...(new URL(environment.publicUrl).protocol === 'http:'
+                            ? { allowInsecureHttp: true }
+                            : {}),
+                        ...(settings.tokenExchange === undefined
+                            ? {}
+                            : { tokenExchange: settings.tokenExchange }),
+                    });
+                },
+                ...(config.durable === undefined
+                    ? {}
+                    : {
+                        durable: (environment, request) => config.durable(environment.bindings, request, settings.durableOptions),
+                    }),
+                server: {
+                    health: { probe: { check: () => true } },
+                    limits: {
+                        maximumRequestBytes: settings.maximumRequestBytes ?? DEFAULT_MAXIMUM_REQUEST_BYTES,
+                        maximumPublicationBytes: 1024 * 1024,
+                        maximumBundleBytes: 8 * 1024 * 1024,
+                        maximumDeliveryBytes: 8 * 1024 * 1024,
+                        invocationTimeoutMs: settings.invocationTimeoutMs ?? DEFAULT_INVOCATION_TIMEOUT_MS,
                     },
-                });
-                return Object.freeze({ build, application });
+                },
             });
-            return realized;
+            application = created;
+            return created;
         };
         return Object.freeze({
             async fetch(request, bindings, context) {
@@ -74,13 +97,13 @@ function createCloudflareWorkerEntry(restore) {
                 if (admission.kind !== 'execution')
                     return admission.response;
                 const { url, publicUrl } = admission;
-                const { application, build } = await realize();
+                const source = await realize();
                 if (config.frontend === undefined) {
-                    const frontend = await frontendAsset(build.frontend, bindings.ASSETS, url, request, config.frontendRevision, config.frontendAddressed);
+                    const frontend = await frontendAsset(source.build.frontend, bindings.ASSETS, url, request, config.frontendRevision, config.frontendAddressed);
                     if (frontend !== undefined)
                         return withProviderVersion(frontend, bindings);
                 }
-                const response = await application.fetch(request, Object.freeze({ bindings, publicUrl }), context);
+                const response = await served(source, bindings).fetch(request, Object.freeze({ bindings, publicUrl }), context);
                 return withProviderVersion(response, bindings);
             },
             async prepare() {
@@ -89,17 +112,17 @@ function createCloudflareWorkerEntry(restore) {
         });
     };
 }
-function routedFetch(application, environment, config) {
+function routedFetch(application, environment, selfBinding, routeSubrequest) {
     return async (input, init) => {
         const { request, rejectRedirect } = prepareCloudflareRequest(input, init);
         const destination = new URL(request.url);
         if (destination.origin === environment.publicUrl) {
-            const self = config.selfBinding?.(environment.bindings);
+            const self = selfBinding?.(environment.bindings);
             return dispatchCloudflareRequest(request, rejectRedirect, (selected) => self === null || self === undefined
                 ? application.fetch(selected, environment)
                 : self.fetch(selected));
         }
-        const route = config.routeSubrequest?.(destination, environment.bindings);
+        const route = routeSubrequest?.(destination, environment.bindings);
         return dispatchCloudflareRequest(request, rejectRedirect, (selected) => route === null || route === undefined ? fetch(selected) : route.fetch(selected));
     };
 }