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

package/dist/build/codegen/wrangler.d.ts

@@ -37,8 +37,8 @@ export interface WranglerCodegenOptions {
     selfBinding: boolean;
     /**
      * Add a service binding to a router Worker for instance-host subrequest
-     * routing (see `CloudflareParams.router`). Pairs with the worker
-     * entry's `routeSubrequest`.
+     * routing (see `CloudflareParams.router`). Pairs with the router rule bound
+     * in `ASTRALE_SETTINGS`.
      */
     router?: {
         binding: string;
@@ -49,7 +49,8 @@ export interface WranglerCodegenOptions {
      * hatch for extra bindings (KV, R2, D1, queues, service bindings, extra
      * `compatibility_flags`, cron `triggers`, …). Arrays concat; new keys are
      * added as-is. The adapter-owned keys `name`, `main`, `assets`, `routes` are
-     * rejected (throws) — use `workerName` / `route` instead.
+     * rejected (throws) — use `workerName` / `route` instead — and so are the keys
+     * and compatibility flags Wrangler's bundler reads.
      */
     wrangler?: Record<string, unknown>;
 }

package/dist/build/codegen/wrangler.js

@@ -25,6 +25,7 @@ export function generateWranglerConfig(opts) {
         workers_dev: opts.route === undefined,
         version_metadata: { binding: 'ASTRALE_VERSION_METADATA' },
         observability: { enabled: true },
+        minify: true,
     };
     if (opts.route) {
         config.routes = [{ pattern: opts.route, custom_domain: true }];
@@ -78,9 +79,30 @@ const ADAPTER_OWNED_KEYS = [
     'find_additional_modules',
     'base_dir',
 ];
+/**
+ * Keys Wrangler's bundler reads. Bundling sees the adapter base configuration only, so that every
+ * Environment of one source bundles the same bytes; an Environment's overlay never sets these.
+ */
+const BUNDLING_KEYS = [
+    'alias',
+    'build',
+    'define',
+    'jsx_factory',
+    'jsx_fragment',
+    'keep_names',
+    'minify',
+    'no_bundle',
+    'node_compat',
+    'preserve_file_names',
+    'rules',
+    'tsconfig',
+    'upload_source_maps',
+];
+/** Compatibility flags Wrangler's bundler reads: Node.js polyfills, `navigator`, fetch typing, Python. */
+const BUNDLING_FLAG = /nodejs|navigator|fetch_iterable_type_support|python_workers/u;
 /**
  * Deep-merge the dev's raw wrangler overlay over the generated config, after
- * refusing any attempt to override an adapter-owned key. Throwing (rather than
+ * refusing any attempt to override an adapter-owned key or a bundler input. Throwing (rather than
  * silently dropping) keeps a stray `main` from breaking the Worker unnoticed.
  */
 function mergeUserConfig(base, user) {
@@ -90,5 +112,17 @@ function mergeUserConfig(base, user) {
             'Use `workerName` for the worker name and `route` for routing; ' +
             '`main` and `assets` are generated by the adapter.');
     }
+    const baseFlags = Array.isArray(base.compatibility_flags) ? base.compatibility_flags : [];
+    const bundling = [
+        ...BUNDLING_KEYS.filter((k) => k in user),
+        ...(Array.isArray(user.compatibility_flags) ? user.compatibility_flags : [])
+            .filter((flag) => typeof flag === 'string' && BUNDLING_FLAG.test(flag))
+            .filter((flag) => !baseFlags.includes(flag))
+            .map((flag) => `compatibility_flags ${String(flag)}`),
+    ];
+    if (bundling.length > 0) {
+        throw new Error(`wrangler: ${bundling.join(', ')} shape(s) the bundle, which takes no Environment. ` +
+            'Bundling uses the adapter base configuration only.');
+    }
     return deepMergeConfig(base, user);
 }

package/dist/build/configuration/invocation-timeout.js

@@ -1,8 +1,8 @@
-const MAXIMUM_TIMER_MS = 2_147_483_647;
+import { MAXIMUM_INVOCATION_TIMEOUT_MS } from '../../worker/settings.js';
 export function workerInvocationTimeout(value) {
     if (value === undefined)
         return undefined;
-    if (!Number.isSafeInteger(value) || value <= 0 || value > MAXIMUM_TIMER_MS) {
+    if (!Number.isSafeInteger(value) || value <= 0 || value > MAXIMUM_INVOCATION_TIMEOUT_MS) {
         throw new TypeError('Cloudflare invocationTimeoutMs must be a positive integer within the platform timer range.');
     }
     return value;

package/dist/build/configuration/legacy/direct.d.ts

@@ -0,0 +1,15 @@
+import type { CloudflareParams } from '../../../params.js';
+/**
+ * The bindings legacy direct mode adds to a stable Worker's deployment: the stable issuer it serves
+ * behind its route (`IDENTITY_ISS`), or the workers.dev Worker name a provider-assigned deployment
+ * must claim (`ASTRALE_PROVIDER_ASSIGNED_WORKER`). The Worker reads them through
+ * `worker/legacy/direct.ts`.
+ *
+ * @deprecated Legacy direct mode only. Replacement: an immutable deployment, whose host binds
+ * `WORKER_URL` to the deployment URL, which is also its issuer (Cloudflare namespace mode).
+ * Deleted with direct mode, once the Shell, Services, Issues, domains and ui configurations deploy
+ * in namespace mode and no installation pins a direct Worker.
+ */
+export declare function directDeploymentVars(parameters: Pick<CloudflareParams, 'identityIssuer'>, deployment: {
+    readonly providerAssignedWorker?: string;
+}): Readonly<Record<string, string>>;

package/dist/build/configuration/legacy/direct.js

@@ -0,0 +1,19 @@
+/**
+ * The bindings legacy direct mode adds to a stable Worker's deployment: the stable issuer it serves
+ * behind its route (`IDENTITY_ISS`), or the workers.dev Worker name a provider-assigned deployment
+ * must claim (`ASTRALE_PROVIDER_ASSIGNED_WORKER`). The Worker reads them through
+ * `worker/legacy/direct.ts`.
+ *
+ * @deprecated Legacy direct mode only. Replacement: an immutable deployment, whose host binds
+ * `WORKER_URL` to the deployment URL, which is also its issuer (Cloudflare namespace mode).
+ * Deleted with direct mode, once the Shell, Services, Issues, domains and ui configurations deploy
+ * in namespace mode and no installation pins a direct Worker.
+ */
+export function directDeploymentVars(parameters, deployment) {
+    return Object.freeze({
+        ...(parameters.identityIssuer === undefined ? {} : { IDENTITY_ISS: parameters.identityIssuer }),
+        ...(deployment.providerAssignedWorker === undefined
+            ? {}
+            : { ASTRALE_PROVIDER_ASSIGNED_WORKER: deployment.providerAssignedWorker }),
+    });
+}

package/dist/build/configuration/request-limit.js

@@ -1,4 +1,4 @@
-const MAXIMUM_REQUEST_BYTES = 16 * 1024 * 1024;
+import { MAXIMUM_REQUEST_BYTES } from '../../worker/settings.js';
 export function workerRequestLimit(value) {
     if (value === undefined)
         return undefined;

package/dist/build/configuration/settings.d.ts

@@ -0,0 +1,15 @@
+import type { CloudflareParams } from '../../params.js';
+import type { WorkerSettings } from '../../worker/settings.js';
+/** Whether a binding name is one the adapter owns, so no author var or secret may take it. */
+export declare function isAdapterVar(name: string): boolean;
+/** Resolve one Environment's execution settings, defaults included, as its deployment binds them. */
+export declare function workerSettings(parameters: CloudflareParams): WorkerSettings;
+/**
+ * The plain bindings one stable Worker deployment carries: the author's vars, its execution
+ * settings and serving origin, and the legacy direct-mode bindings. Never `ASTRALE_BUILD_DIGEST`:
+ * only an immutable deployment may answer for a build digest.
+ */
+export declare function deploymentVars(parameters: CloudflareParams, deployment: {
+    readonly configuredIssuer?: string;
+    readonly providerAssignedWorker?: string;
+}): Readonly<Record<string, string>>;

package/dist/build/configuration/settings.js

@@ -0,0 +1,71 @@
+import { maximumExchangeTtl } from '@astrale-os/sdk/execution';
+import { captureDurableOptions, DEFAULT_INVOCATION_TIMEOUT_MS, DEFAULT_MAXIMUM_REQUEST_BYTES, encodeWorkerSettings, SETTINGS_BINDING, } from '../../worker/settings.js';
+import { workerInvocationTimeout } from './invocation-timeout.js';
+import { directDeploymentVars } from './legacy/direct.js';
+import { workerRequestLimit } from './request-limit.js';
+import { resolveRouter } from './router.js';
+/**
+ * Plain bindings the adapter owns on a deployment, bound or not; no author var or secret takes
+ * these names. `IDENTITY_ISS` and `ASTRALE_PROVIDER_ASSIGNED_WORKER` belong to legacy direct mode.
+ */
+const ADAPTER_VARS = new Set([
+    'WORKER_URL',
+    'ASTRALE_BUILD_DIGEST',
+    SETTINGS_BINDING,
+    'IDENTITY_ISS',
+    'ASTRALE_PROVIDER_ASSIGNED_WORKER',
+]);
+/** Whether a binding name is one the adapter owns, so no author var or secret may take it. */
+export function isAdapterVar(name) {
+    return ADAPTER_VARS.has(name);
+}
+/** Resolve one Environment's execution settings, defaults included, as its deployment binds them. */
+export function workerSettings(parameters) {
+    const router = resolveRouter(parameters.router);
+    return Object.freeze({
+        ...(parameters.durable === undefined
+            ? {}
+            : { durableOptions: captureDurableOptions(parameters.durable) }),
+        maximumRequestBytes: workerRequestLimit(parameters.maximumRequestBytes) ?? DEFAULT_MAXIMUM_REQUEST_BYTES,
+        invocationTimeoutMs: workerInvocationTimeout(parameters.invocationTimeoutMs) ?? DEFAULT_INVOCATION_TIMEOUT_MS,
+        tokenExchange: parameters.tokenExchange === false
+            ? false
+            : Object.freeze({ maximumLifetimeSeconds: maximumExchangeTtl(parameters.tokenExchange) }),
+        router: router === undefined
+            ? false
+            : Object.freeze({
+                binding: router.binding,
+                hostSuffix: router.hostSuffix,
+                minLabels: router.minLabels,
+            }),
+    });
+}
+/**
+ * The plain bindings one stable Worker deployment carries: the author's vars, its execution
+ * settings and serving origin, and the legacy direct-mode bindings. Never `ASTRALE_BUILD_DIGEST`:
+ * only an immutable deployment may answer for a build digest.
+ */
+export function deploymentVars(parameters, deployment) {
+    const authored = [
+        ...Object.keys(parameters.vars ?? {}),
+        ...Object.keys(wranglerVars(parameters.wrangler)),
+    ];
+    const owned = authored.filter(isAdapterVar);
+    if (owned.length > 0) {
+        throw new TypeError(`Cloudflare var(s) ${owned.join(', ')} are adapter-owned bindings.`);
+    }
+    return Object.freeze({
+        ...parameters.vars,
+        [SETTINGS_BINDING]: encodeWorkerSettings(workerSettings(parameters)),
+        ...(deployment.configuredIssuer === undefined
+            ? {}
+            : { WORKER_URL: deployment.configuredIssuer }),
+        ...directDeploymentVars(parameters, deployment),
+    });
+}
+function wranglerVars(wrangler) {
+    const vars = wrangler?.vars;
+    return vars !== null && typeof vars === 'object' && !Array.isArray(vars)
+        ? vars
+        : {};
+}

package/dist/build/configuration.d.ts

@@ -2,4 +2,5 @@ export { deploymentAddressing } from './configuration/addressing.js';
 export { workerInvocationTimeout } from './configuration/invocation-timeout.js';
 export { workerRequestLimit } from './configuration/request-limit.js';
 export { resolveRouter } from './configuration/router.js';
+export { deploymentVars, isAdapterVar, workerSettings } from './configuration/settings.js';
 export { workerName } from './configuration/worker-name.js';

package/dist/build/configuration.js

@@ -2,4 +2,5 @@ export { deploymentAddressing } from './configuration/addressing.js';
 export { workerInvocationTimeout } from './configuration/invocation-timeout.js';
 export { workerRequestLimit } from './configuration/request-limit.js';
 export { resolveRouter } from './configuration/router.js';
+export { deploymentVars, isAdapterVar, workerSettings } from './configuration/settings.js';
 export { workerName } from './configuration/worker-name.js';

package/dist/build/frontend/readiness.d.ts

@@ -1,9 +1,9 @@
-import type { Release } from '@astrale-os/sdk/deployment/release';
+import type { legacy } from '@astrale-os/sdk/deployment/release';
 import type { verifyReadiness } from '@astrale-os/sdk/deployment/verify';
 import type { WorkerArtifact } from '../worker/artifact.js';
 type ReadinessFetch = NonNullable<NonNullable<Parameters<typeof verifyReadiness>[1]>['fetch']>;
 /** Publication equality alone cannot prove a frontend-only deployment has propagated. */
-export declare function verifyWorkerFrontend(release: Release, worker: Pick<WorkerArtifact, 'assets'>, options?: {
+export declare function verifyWorkerFrontend(release: legacy.Release, worker: Pick<WorkerArtifact, 'assets'>, options?: {
     readonly fetch?: ReadinessFetch;
     readonly signal?: AbortSignal;
 }): Promise<void>;

package/dist/build/index.d.ts

@@ -1,8 +1,10 @@
 export { generateBuildMaterialModule } from './material.js';
 export { artifact, materialize, prepareWorkerArtifact } from './artifact.js';
+export { cloudflareWorkerBundler } from './bundler.js';
 export { loadWorkerArtifact } from './worker/index.js';
 export type { WorkerArtifact } from './worker/index.js';
-export { resolveRouter, workerName } from './configuration.js';
+export { uploadBuildDigest, uploadBuildEvidence, workerUpload } from './worker/upload.js';
+export { isAdapterVar, resolveRouter, workerName } from './configuration.js';
 export { frontendFiles } from './frontend/files.js';
 export { verifyWorkerFrontend } from './frontend/readiness.js';
 export { qualifyWorkerBundle } from './qualification.js';

package/dist/build/index.js

@@ -1,7 +1,9 @@
 export { generateBuildMaterialModule } from './material.js';
 export { artifact, materialize, prepareWorkerArtifact } from './artifact.js';
+export { cloudflareWorkerBundler } from './bundler.js';
 export { loadWorkerArtifact } from './worker/index.js';
-export { resolveRouter, workerName } from './configuration.js';
+export { uploadBuildDigest, uploadBuildEvidence, workerUpload } from './worker/upload.js';
+export { isAdapterVar, resolveRouter, workerName } from './configuration.js';
 export { frontendFiles } from './frontend/files.js';
 export { verifyWorkerFrontend } from './frontend/readiness.js';
 export { qualifyWorkerBundle } from './qualification.js';

package/dist/build/worker/codegen/entry.d.ts

@@ -5,7 +5,6 @@ export interface ExecutionEntryOptions {
     readonly frontend?: BuildMaterial['frontend'];
     readonly frontendRevision?: string;
     readonly frontendAddressed?: readonly string[];
-    readonly providerAssignedWorker?: string;
 }
 /** Generate the isolate-startup entry that realizes the heavy Service on first request. */
 export declare function generateExecutionEntry(serviceSpecifier: string, options?: ExecutionEntryOptions): string;

package/dist/build/worker/codegen/entry.js

@@ -12,9 +12,6 @@ export function generateExecutionEntry(serviceSpecifier, options = {}) {
         options.frontendAddressed === undefined
             ? ''
             : `  frontendAddressed: ${JSON.stringify(options.frontendAddressed)},\n`,
-        options.providerAssignedWorker === undefined
-            ? ''
-            : `  providerAssignedWorker: ${JSON.stringify(options.providerAssignedWorker)},\n`,
     ].join('');
     return `// AUTO-GENERATED by @astrale-os/adapter-cloudflare — do not edit.
 import type { BuildMaterial } from '@astrale-os/sdk/deployment/build'

package/dist/build/worker/codegen/service.d.ts

@@ -1,5 +1,5 @@
 import type { Build } from '@astrale-os/sdk/deployment/build';
-import type { ExchangeOptions } from '@astrale-os/sdk/execution';
+/** Build inputs only: the deployment binds every environment value (`deploymentSettings`). */
 export interface ExecutionCodegenOptions {
     readonly origin: string;
     readonly runtimeSpecifier: string;
@@ -7,15 +7,8 @@ export interface ExecutionCodegenOptions {
     readonly build: Build;
     readonly frontendRevision?: string;
     readonly frontendAddressed?: readonly string[];
-    readonly maximumRequestBytes?: number;
-    readonly invocationTimeoutMs?: number;
-    readonly identityIssuer?: string;
-    readonly providerAssignedWorker?: string;
-    readonly tokenExchange?: ExchangeOptions | false;
-    readonly router?: {
-        readonly binding: string;
-        readonly hostSuffix: string;
-        readonly minLabels: number;
-    };
+    /** Static Schema capability; deployment options remain in bindings. */
+    readonly durable?: boolean;
+    readonly restateSpecifier?: string;
 }
 export declare function generateExecutionService(options: ExecutionCodegenOptions): string;

package/dist/build/worker/codegen/service.js

@@ -9,39 +9,31 @@ export function generateExecutionService(options) {
     const material = sharedLiteral(generated);
     verifySharedLiteral(material, generated);
     const materialDeclarations = material.declarations.map((line) => `    ${line}\n`).join('');
-    const router = options.router;
-    const routerPredicate = router === undefined
-        ? ''
-        : `
-function isInstanceHost(host: string): boolean {
-  return host.endsWith(${JSON.stringify(router.hostSuffix)}) && host.split('.').length >= ${router.minLabels}
-}
-`;
-    const routeSubrequest = router === undefined
-        ? ''
-        : `
-  routeSubrequest: (url, env) => {
-    // Services own their public ingress, including retirement and private-route isolation.
-    if (url.hostname.split('.')[1] === 'svc') return null
-    if (env.${router.binding} && isInstanceHost(url.hostname)) return env.${router.binding}
-    return null
-  },`;
+    const durableImports = options.durable === true
+        ? `import { RESTATE_IDENTITY_KEYS_BINDING, restateServing } from ${JSON.stringify(workerSpecifier)}
+import { isCanonicalDurableRequest, isLegacyDurableRequest } from '@astrale-os/sdk/execution'
+// A variable specifier preserves the engine as a separate deployed module.
+const RESTATE_SPECIFIER = ${JSON.stringify(options.restateSpecifier ?? './restate.mjs')}
+`
+        : '';
     const frontend = generated.material.frontend === undefined
         ? ''
         : `  frontend: ${JSON.stringify(generated.material.frontend)} as const satisfies NonNullable<BuildMaterial['frontend']>,\n`;
     return `// AUTO-GENERATED by @astrale-os/adapter-cloudflare — do not edit.
 // Domain origin: ${options.origin}
 import type { BuildMaterial, GeneratedBuildMaterial } from '@astrale-os/sdk/deployment/build'
-import type { CloudflareAdapterBindings } from ${JSON.stringify(workerSpecifier)}
+import type { CloudflareAdapterBindings${options.durable === true ? ', DurableBindings' : ''} } from ${JSON.stringify(workerSpecifier)}
 
 import { generatedCloudflareWorkerEntry } from ${JSON.stringify(workerSpecifier)}
-import { decodeSigningIdentity, runtimeBindings } from ${JSON.stringify(workerSpecifier)}
+import { decodeSigningIdentity, deploymentSettings, runtimeBindings } from ${JSON.stringify(workerSpecifier)}
+import { withDirectIssuer } from ${JSON.stringify(workerSpecifier)}
 
-type WorkerEnv = CloudflareEnv & CloudflareAdapterBindings & {
+${durableImports}
+type WorkerEnv = CloudflareEnv & CloudflareAdapterBindings${options.durable === true ? ' & DurableBindings' : ''} & {
   readonly ASTRALE_SIGNING_IDENTITY: string
 }
 type RuntimeEnv = Omit<WorkerEnv, 'ASTRALE_SIGNING_IDENTITY'>
-${routerPredicate}
+
 export default generatedCloudflareWorkerEntry<WorkerEnv, RuntimeEnv>()({
 ${frontend}${options.frontendRevision === undefined ? '' : `  frontendRevision: ${JSON.stringify(options.frontendRevision)},\n`}${options.frontendAddressed === undefined ? '' : `  frontendAddressed: ${JSON.stringify(options.frontendAddressed)},\n`}  load: async () => {
 ${materialDeclarations}    return {
@@ -51,13 +43,16 @@ ${materialDeclarations}    return {
   },
   privateKey: (env) => decodeSigningIdentity(env.ASTRALE_SIGNING_IDENTITY),
   resolveEnvironment: runtimeBindings,
-  resolveUrl: (env, requestOrigin) => env.WORKER_URL ?? env.IDENTITY_ISS ?? requestOrigin,
-  ${options.maximumRequestBytes === undefined ? '' : `maximumRequestBytes: ${options.maximumRequestBytes},`}
-  ${options.invocationTimeoutMs === undefined ? '' : `invocationTimeoutMs: ${options.invocationTimeoutMs},`}
-  ${options.identityIssuer === undefined ? '' : `identityIssuer: ${JSON.stringify(options.identityIssuer)},`}
-  ${options.providerAssignedWorker === undefined ? '' : `providerAssignedWorker: ${JSON.stringify(options.providerAssignedWorker)},`}
-  ${options.tokenExchange === undefined ? '' : `tokenExchange: ${JSON.stringify(options.tokenExchange)} as const,`}
-  selfBinding: (env) => env.SELF,${routeSubrequest}
+  // Legacy direct mode: a bound IDENTITY_ISS signs instead of the serving origin.
+  settings: withDirectIssuer(deploymentSettings),
+  selfBinding: (env) => env.SELF,${options.durable === true
+        ? `
+  durable: async (env, request, options) => {
+    if (!isCanonicalDurableRequest(request) && !(isLegacyDurableRequest(request) && env[RESTATE_IDENTITY_KEYS_BINDING]?.trim())) return undefined
+    const restate = await import(RESTATE_SPECIFIER)
+    return restateServing(restate, env, options, request)
+  },`
+        : ''}
 })
 `;
 }

package/dist/build/worker/execution.prepare.d.ts

@@ -1,20 +1,20 @@
-import type { PrepareContext } from '@astrale-os/sdk/deployment/adapter';
-import type { CloudflareParams } from '../../params.js';
-import type { resolveRouter } from '../configuration.js';
+import type { BundleContext } from '@astrale-os/sdk/deployment/adapter';
 export declare const RELEASE_ENTRY = "bundle/index.mjs";
 export declare const RELEASE_SERVICE = "bundle/service.mjs";
+export declare const RELEASE_RESTATE = "bundle/restate.mjs";
+/** A deployed module retained outside the startup bundle. */
+export interface ReleaseModule {
+    readonly kind: 'esm' | 'wasm';
+    readonly path: string;
+    readonly content: Uint8Array;
+}
 export declare function prepareExecution(input: {
-    readonly params: CloudflareParams;
-    readonly context: PrepareContext;
+    readonly context: BundleContext;
     readonly directory: string;
-    readonly name: string;
-    readonly direct: boolean;
     readonly frontendRevision?: string;
     readonly frontendAddressed?: readonly string[];
-    readonly configuredIssuer?: string;
-    readonly router: ReturnType<typeof resolveRouter>;
 }): Promise<{
     readonly entry: Uint8Array;
-    readonly service: Uint8Array;
+    readonly modules: readonly ReleaseModule[];
 }>;
-export declare function runtimeVars(params: CloudflareParams, configuredIssuer: string | undefined): Record<string, string>;
+export declare function declaresDurable(build: BundleContext['build']): boolean;

package/dist/build/worker/execution.prepare.js

@@ -1,82 +1,83 @@
 import { generatedMaterial } from '@astrale-os/sdk/deployment/build';
-import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { dirname, join, relative, resolve } from 'node:path';
 import { SIGNING_IDENTITY_BINDING } from '../../identity/binding.js';
 import { runWranglerBundle } from '../../wrangler/bundle.js';
-import { admitWorkerBundle } from '../bundle/admit.js';
+import { admitDurableEngineBundle, admitWorkerBundle } from '../bundle/admit.js';
 import { generateExecutionEntry, generateExecutionService } from '../codegen/execution.js';
 import { generateWranglerConfig } from '../codegen/wrangler.js';
-import { workerInvocationTimeout, workerRequestLimit } from '../configuration.js';
 import { qualifyWorkerBundle } from '../qualification.js';
-import { frontModuleSpecifier, workerModuleSpecifier } from './specifier.js';
+import { workerModules } from './modules.js';
+import { frontModuleSpecifier, restateModuleSpecifier, workerModuleSpecifier } from './specifier.js';
 export const RELEASE_ENTRY = 'bundle/index.mjs';
 export const RELEASE_SERVICE = 'bundle/service.mjs';
+export const RELEASE_RESTATE = 'bundle/restate.mjs';
+/**
+ * Bundling sees the adapter base configuration only: no Environment, route, var, router or
+ * `wrangler` overlay reaches the bytes, so every Environment of one source bundles identically.
+ */
+const BUNDLE_WORKER_NAME = 'astrale-domain';
 export async function prepareExecution(input) {
     const runtimePath = resolve(input.context.projectDir, input.context.runtime.reference.path);
     const runtimeSpecifier = moduleSpecifier(relative(input.directory, runtimePath));
     const workerSpecifier = workerModuleSpecifier();
-    const maximumRequestBytes = workerRequestLimit(input.params.maximumRequestBytes);
-    const invocationTimeoutMs = workerInvocationTimeout(input.params.invocationTimeoutMs);
     const serviceSource = generateExecutionService({
         origin: input.context.build.schema.compiled.root.origin,
-        ...(input.params.identityIssuer === undefined
-            ? {}
-            : { identityIssuer: input.params.identityIssuer }),
         runtimeSpecifier,
         workerSpecifier,
         build: input.context.build,
+        ...(declaresDurable(input.context.build)
+            ? { durable: true, restateSpecifier: './restate.mjs' }
+            : {}),
         ...(input.frontendRevision === undefined ? {} : { frontendRevision: input.frontendRevision }),
         ...(input.frontendAddressed === undefined
             ? {}
             : { frontendAddressed: input.frontendAddressed }),
-        ...(maximumRequestBytes === undefined ? {} : { maximumRequestBytes }),
-        ...(invocationTimeoutMs === undefined ? {} : { invocationTimeoutMs }),
-        ...(input.params.tokenExchange === undefined
-            ? {}
-            : { tokenExchange: input.params.tokenExchange }),
-        ...(input.configuredIssuer === undefined && input.direct
-            ? { providerAssignedWorker: input.name }
-            : {}),
-        ...(input.router === undefined
-            ? {}
-            : {
-                router: {
-                    binding: input.router.binding,
-                    hostSuffix: input.router.hostSuffix,
-                    minLabels: input.router.minLabels,
-                },
-            }),
-    });
-    const serviceSourcePath = join(input.directory, 'service.gen.ts');
-    await writeFile(serviceSourcePath, serviceSource);
-    const serviceConfigPath = join(input.directory, 'wrangler.service.prepare.jsonc');
-    await writeFile(serviceConfigPath, generateWranglerConfig({
-        workerName: input.name,
-        main: './service.gen.ts',
-        vars: runtimeVars(input.params, input.configuredIssuer),
-        secretBindings: [SIGNING_IDENTITY_BINDING],
-        ...(input.router === undefined
-            ? {}
-            : { router: { binding: input.router.binding, service: input.router.service } }),
-        ...(input.params.wrangler === undefined ? {} : { wrangler: input.params.wrangler }),
-        selfBinding: false,
-    }));
-    const serviceOutput = join(input.directory, 'dist-service');
-    await rm(serviceOutput, { recursive: true, force: true });
-    const emittedService = await runWranglerBundle({
-        projectDir: input.context.projectDir,
-        configPath: serviceConfigPath,
-        outDir: serviceOutput,
-        signal: input.context.signal,
     });
-    await qualifyWorkerBundle({
-        metafilePath: emittedService.metafilePath,
-        inputRoot: dirname(serviceConfigPath),
-    });
-    await admitWorkerBundle(emittedService.bundlePath);
-    const service = new Uint8Array(await readFile(emittedService.bundlePath));
-    await mkdir(dirname(join(input.directory, RELEASE_SERVICE)), { recursive: true });
-    await writeFile(join(input.directory, RELEASE_SERVICE), service);
+    const modules = [];
+    const bundle = async (name, path, source, admit) => {
+        const sourcePath = join(input.directory, `${name}.gen.ts`);
+        await writeFile(sourcePath, source);
+        const configPath = join(input.directory, `wrangler.${name}.prepare.jsonc`);
+        await writeFile(configPath, generateWranglerConfig({
+            workerName: BUNDLE_WORKER_NAME,
+            main: `./${name}.gen.ts`,
+            secretBindings: [SIGNING_IDENTITY_BINDING],
+            selfBinding: false,
+        }));
+        const output = join(input.directory, `dist-${name}`);
+        await rm(output, { recursive: true, force: true });
+        const emitted = await runWranglerBundle({
+            projectDir: input.context.projectDir,
+            configPath,
+            outDir: output,
+            signal: input.context.signal,
+        });
+        await qualifyWorkerBundle({
+            metafilePath: emitted.metafilePath,
+            inputRoot: dirname(configPath),
+        });
+        await admit(emitted.bundlePath);
+        const content = new Uint8Array(await readFile(emitted.bundlePath));
+        await mkdir(dirname(join(input.directory, path)), { recursive: true });
+        await writeFile(join(input.directory, path), content);
+        modules.push(Object.freeze({ path, kind: 'esm', content }));
+        // Imported WASM modules are emitted beside their owner under content-hashed names.
+        for (const file of (await readdir(output)).filter((name) => name.endsWith('.wasm')).sort()) {
+            const wasmPath = `${dirname(path)}/${file}`;
+            const content = new Uint8Array(await readFile(join(output, file)));
+            await writeFile(join(input.directory, wasmPath), content);
+            if (!modules.some((module) => module.path === wasmPath)) {
+                modules.push(Object.freeze({ path: wasmPath, kind: 'wasm', content }));
+            }
+        }
+    };
+    await bundle('service', RELEASE_SERVICE, serviceSource, admitWorkerBundle);
+    if (declaresDurable(input.context.build)) {
+        await bundle('restate', RELEASE_RESTATE, 
+        // Wrangler requires a default export to classify an independently bundled ESM entry.
+        `export { createEndpointHandler, workflow, TerminalError, CancelledError } from ${JSON.stringify(restateModuleSpecifier())}\nexport default {}\n`, admitDurableEngineBundle);
+    }
     const sourcePath = join(input.directory, 'worker.gen.ts');
     const frontend = generatedMaterial(input.context.build).material.frontend;
     await writeFile(sourcePath, generateExecutionEntry('./service.mjs', {
@@ -87,21 +88,12 @@ export async function prepareExecution(input) {
         ...(input.frontendAddressed === undefined
             ? {}
             : { frontendAddressed: input.frontendAddressed }),
-        ...(input.configuredIssuer === undefined && input.direct
-            ? { providerAssignedWorker: input.name }
-            : {}),
     }));
     const configPath = join(input.directory, 'wrangler.prepare.jsonc');
     await writeFile(configPath, generateWranglerConfig({
-        workerName: input.name,
-        ...(input.params.route === undefined ? {} : { route: input.params.route }),
-        vars: runtimeVars(input.params, input.configuredIssuer),
+        workerName: BUNDLE_WORKER_NAME,
         secretBindings: [SIGNING_IDENTITY_BINDING],
-        modules: { baseDir: '.', rules: [{ type: 'ESModule', globs: [RELEASE_SERVICE] }] },
-        ...(input.router === undefined
-            ? {}
-            : { router: { binding: input.router.binding, service: input.router.service } }),
-        ...(input.params.wrangler === undefined ? {} : { wrangler: input.params.wrangler }),
+        modules: workerModules({ entrypoint: 'worker.gen.ts', modules }),
         selfBinding: false,
     }));
     const output = join(input.directory, 'dist-prepare');
@@ -119,16 +111,19 @@ export async function prepareExecution(input) {
     await admitWorkerBundle(emitted.bundlePath);
     return Object.freeze({
         entry: new Uint8Array(await readFile(emitted.bundlePath)),
-        service,
+        modules: Object.freeze(modules),
     });
 }
-export function runtimeVars(params, configuredIssuer) {
-    return {
-        ...params.vars,
-        ...(configuredIssuer === undefined ? {} : { WORKER_URL: configuredIssuer }),
-    };
-}
 function moduleSpecifier(input) {
     const normalized = input.split('\\').join('/');
     return normalized.startsWith('.') ? normalized : `./${normalized}`;
 }
+export function declaresDurable(build) {
+    const compiled = build.schema.compiled;
+    const root = compiled.closure.find(({ origin }) => origin === compiled.root.origin);
+    if (root === undefined)
+        return false;
+    return (root.definitions.functions.some((definition) => definition.execution?.durable === true) ||
+        root.definitions.classes.some((definition) => 'methods' in definition &&
+            definition.methods.some((method) => method.execution?.durable === true)));
+}

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

@@ -1,7 +1,13 @@
 import type { WorkerArtifact } from './artifact.js';
 type WranglerModuleType = 'ESModule' | 'CompiledWasm' | 'Text' | 'Data';
-/** Project one admitted Worker module inventory into Wrangler's relative module discovery. */
-export declare function workerModules(worker: WorkerArtifact['release']): {
+/**
+ * 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 declare function workerModules(worker: {
+    readonly entrypoint: string;
+    readonly modules: readonly Pick<WorkerArtifact['release']['modules'][number], 'path' | 'kind'>[];
+}): {
     readonly baseDir: string;
     readonly rules: readonly {
         readonly type: WranglerModuleType;