@astrale-os/adapter-cloudflare 0.5.0-beta.163 → 0.5.0-beta.165

package/README.md

@@ -16,6 +16,10 @@ as `deploy`; it starts no local Worker, Vite server, or tunnel. Omitting `route`
 stable `*.workers.dev` issuer. Add `installation: { instance: '...' }` to the Project Environment
 when generic tooling should reconcile the ready Release onto an Astrale Kernel.
 
+Generated Worker modules are minified by default, including separately loaded runtime modules.
+The Environment's `wrangler` overlay cannot change minification: every Environment of one source
+must emit the same JavaScript bytes. `cloudflare({ wrangler: { minify: false } })` is rejected.
+
 One watcher serializes its own updates. For an existing Worker, it uploads a candidate, reconciles
 configured triggers, and stages the candidate at 0% while the previous version retains 100% of normal
 HTTP traffic. Exact-version probes verify Publication, Bundle, and serving identity before promotion;
@@ -76,6 +80,34 @@ candidate. The public Worker name and `/invoke` endpoint remain stable across co
 implementation and Schema updates. Provider staging identity never enters Release, Publication,
 Kernel routing, or graph identity.
 
+## Deployment bindings
+
+The bundled Worker carries no Environment value, so every Environment of one source bundles the
+same bytes. Each deployment binds its own values as plain Worker bindings:
+
+| Binding | Value |
+| --- | --- |
+| `WORKER_URL` | serving origin of the deployment |
+| `ASTRALE_SETTINGS` | canonical JSON of `{ invocationTimeoutMs, maximumRequestBytes, router, tokenExchange }`, defaults resolved, with optional `durableOptions` |
+| `ASTRALE_BUILD_DIGEST` | build digest, bound only by hosts that deploy immutable Workers; never by a stable Worker |
+| `IDENTITY_ISS`, `ASTRALE_PROVIDER_ASSIGNED_WORKER` | **legacy direct mode only** (deprecated): a stable issuer behind another route, and the workers.dev claim |
+
+These names are adapter-owned: preparation refuses an author var, or a `wrangler.vars` entry, that
+takes one, and deployment refuses a secret that does. A host that deploys the Worker itself encodes
+the settings with `encodeWorkerSettings` from `@astrale-os/adapter-cloudflare/worker`. A generated
+Worker refuses execution without `ASTRALE_SETTINGS`.
+
+The two direct-mode bindings are deprecated. Their replacement is an immutable deployment, whose
+host binds `WORKER_URL` to the deployment URL, which is also its issuer (namespace mode). They are
+deleted with direct mode, once the Shell, Services, Issues, domains and ui configurations deploy in
+namespace mode and no installation pins a direct Worker.
+
+The `wrangler` overlay reaches the deployment configuration, never the bundle. Preparation refuses
+an overlay key 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 a compatibility flag it reads (Node.js, `navigator`, fetch iterable
+typing, Python) beyond the adapter's own `nodejs_compat`.
+
 ## Material for a custom Worker entrypoint
 
 Workers with provider-specific routes or environment initialization can reuse the adapter's
@@ -91,6 +123,9 @@ await writeFile('src/build-material.gen.ts', generateBuildMaterialModule(build))
 
 The generated TypeScript module exports `loadBuildMaterial()`. Call it from the
 `load` callback of `generatedCloudflareWorkerEntry` alongside the application's Runtime.
+Such an entrypoint states its execution settings (`invocationTimeoutMs`, `maximumRequestBytes`,
+`tokenExchange`, `routeSubrequest`, `identityIssuer`) in its configuration, or reads them from its
+deployment bindings with `settings: deploymentSettings`; one Worker never takes both.
 It constructs the same verified, deduplicated material as the adapter's generated Service;
 allocation is deferred until the factory is called and the SDK deep-freezes it before use.
 The generated file needs only a type import from the SDK. Keep its compiler and runtime SDK

package/dist/build/artifact.js

@@ -4,11 +4,12 @@ import { join } from 'node:path';
 import { SIGNING_IDENTITY_BINDING } from '../identity/binding.js';
 import { workerDeployment } from '../release/index.js';
 import { generateWranglerConfig } from './codegen/wrangler.js';
-import { deploymentAddressing, resolveRouter, workerName } from './configuration.js';
+import { deploymentAddressing, deploymentVars, resolveRouter, workerName } from './configuration.js';
 import { frontendFiles } from './frontend/files.js';
 import { frontendRevision } from './frontend/revision.js';
 import { encodeWorkerArtifactManifest, inferMediaType, workerContentDigest, WORKER_MANIFEST_PATH, } from './worker/artifact.manifest.js';
-import { prepareExecution, RELEASE_ENTRY, RELEASE_SERVICE, runtimeVars, } from './worker/execution.prepare.js';
+import { prepareExecution, RELEASE_ENTRY } from './worker/execution.prepare.js';
+import { workerModules } from './worker/modules.js';
 import { admitWorkerRuntimeConfiguration } from './worker/runtime.js';
 export { materialize } from './materialize.js';
 const encoder = new TextEncoder();
@@ -29,6 +30,11 @@ async function prepare(params, context, direct) {
         const name = workerName(params, context.build.schema.compiled.root.origin, context.environment);
         const revision = context.build.schema.compiled.root.revision;
         const configuredIssuer = deploymentAddressing(params);
+        // The Environment enters only as the deployment's bindings, never the bundled bytes.
+        const vars = deploymentVars(params, {
+            ...(configuredIssuer === undefined ? {} : { configuredIssuer }),
+            ...(direct && configuredIssuer === undefined ? { providerAssignedWorker: name } : {}),
+        });
         // `frontend` stays the served file list every branch below already reads; `addressed` rides
         // alongside it into the Worker, where it decides which of those files a browser may retain.
         const { files: frontend, addressed } = await frontendFiles({
@@ -39,23 +45,25 @@ async function prepare(params, context, direct) {
             signal: context.signal,
         });
         const modules = await prepareExecution({
-            params,
             context,
             directory,
-            name,
-            direct,
-            configuredIssuer,
-            router,
             ...(frontend.length === 0 ? {} : { frontendRevision: frontendRevision(frontend) }),
             ...(addressed.length === 0 ? {} : { frontendAddressed: addressed }),
         });
+        const release = {
+            entrypoint: RELEASE_ENTRY,
+            modules: [
+                { path: RELEASE_ENTRY, kind: 'esm', content: modules.entry },
+                ...modules.modules,
+            ],
+        };
         const releaseConfig = generateWranglerConfig({
             workerName: name,
             main: `./${RELEASE_ENTRY}`,
             ...(params.route === undefined ? {} : { route: params.route }),
-            vars: runtimeVars(params, configuredIssuer),
+            vars,
             secretBindings: [SIGNING_IDENTITY_BINDING],
-            modules: { baseDir: './bundle', rules: [{ type: 'ESModule', globs: ['service.mjs'] }] },
+            modules: workerModules(release),
             ...(context.build.frontend?.source.kind === 'vite'
                 ? {
                     frontend: {
@@ -71,13 +79,7 @@ async function prepare(params, context, direct) {
         });
         const runtime = admitWorkerRuntimeConfiguration(releaseConfig);
         const deployment = workerDeployment({
-            release: {
-                entrypoint: RELEASE_ENTRY,
-                modules: [
-                    { path: RELEASE_ENTRY, kind: 'esm', content: modules.entry },
-                    { path: RELEASE_SERVICE, kind: 'esm', content: modules.service },
-                ],
-            },
+            release,
             runtime,
             bindings: {
                 vars: runtime.vars,
@@ -107,11 +109,12 @@ async function prepare(params, context, direct) {
             revision,
             deployment,
             release: {
-                entrypoint: RELEASE_ENTRY,
-                modules: [
-                    { path: RELEASE_ENTRY, kind: 'esm', digest: workerContentDigest(modules.entry) },
-                    { path: RELEASE_SERVICE, kind: 'esm', digest: workerContentDigest(modules.service) },
-                ],
+                entrypoint: release.entrypoint,
+                modules: release.modules.map(({ path, kind, content }) => ({
+                    path,
+                    kind,
+                    digest: workerContentDigest(content),
+                })),
             },
             runtime: {
                 compatibilityDate: runtime.compatibilityDate,
@@ -142,8 +145,7 @@ async function prepare(params, context, direct) {
                 }),
         });
         const files = [
-            { path: RELEASE_ENTRY, content: modules.entry },
-            { path: RELEASE_SERVICE, content: modules.service },
+            ...release.modules.map(({ path, content }) => ({ path, content })),
             { path: WORKER_MANIFEST_PATH, content: manifest },
             ...frontend.map((file) => ({
                 path: `frontend/${file.path}`,

package/dist/build/bundle/admit.d.ts

@@ -1 +1,3 @@
 export declare function admitWorkerBundle(path: string): Promise<void>;
+/** Admit the separately emitted engine's actual platform exports, including its compiled WASM. */
+export declare function admitDurableEngineBundle(path: string): Promise<void>;

package/dist/build/bundle/admit.js

@@ -1,5 +1,34 @@
+import * as nodeModule from 'node:module';
 import { pathToFileURL } from 'node:url';
+import { compiledWasmLoader, compiledWasmSource } from './compiled-wasm-loader.js';
+let compiledWasm = false;
+/**
+ * Import a WebAssembly module as Workers do for `CompiledWasm`: its default export is the compiled
+ * `WebAssembly.Module`, instantiated by the importing code. The CLI admits bundles under Bun; Node
+ * serves programmatic builds.
+ */
+function admitCompiledWasm() {
+    if (compiledWasm)
+        return;
+    if (process.versions.bun !== undefined) {
+        ;
+        Reflect.get(globalThis, 'Bun').plugin({
+            name: 'astrale-compiled-wasm',
+            setup(build) {
+                build.onLoad({ filter: /\.wasm$/ }, ({ path }) => ({
+                    loader: 'js',
+                    contents: compiledWasmSource(JSON.stringify(path)),
+                }));
+            },
+        });
+        compiledWasm = true;
+        return;
+    }
+    nodeModule.register(compiledWasmLoader);
+    compiledWasm = true;
+}
 export async function admitWorkerBundle(path) {
+    admitCompiledWasm();
     const loaded = (await import(`${pathToFileURL(path).href}?admit=${Date.now()}`));
     if (loaded.default === null ||
         typeof loaded.default !== 'object' ||
@@ -7,3 +36,11 @@ export async function admitWorkerBundle(path) {
         throw new TypeError('Generated Worker bundle does not export a Fetch handler.');
     }
 }
+/** Admit the separately emitted engine's actual platform exports, including its compiled WASM. */
+export async function admitDurableEngineBundle(path) {
+    admitCompiledWasm();
+    const engine = (await import(`${pathToFileURL(path).href}?admit=${Date.now()}`));
+    if (['createEndpointHandler', 'workflow', 'TerminalError', 'CancelledError'].some((key) => typeof engine[key] !== 'function')) {
+        throw new TypeError('Generated durable engine bundle does not export the platform Fetch entrypoint.');
+    }
+}

package/dist/build/bundle/compiled-wasm-loader.d.ts

@@ -0,0 +1,8 @@
+/** Workers expose CompiledWasm imports as modules, rather than instantiated exports. */
+export declare function compiledWasmSource(file: string): string;
+/**
+ * Async hooks run in a separate Node thread. A self-contained ESM hook admits both emitted JS and
+ * source builds under tsx without requiring that thread to resolve or transpile our source files.
+ * The emitted import source is shared with Bun.
+ */
+export declare const compiledWasmLoader: string;

package/dist/build/bundle/compiled-wasm-loader.js

@@ -0,0 +1,21 @@
+const SOURCE_PREFIX = "import { readFileSync } from 'node:fs'\nexport default new WebAssembly.Module(readFileSync(";
+const SOURCE_SUFFIX = '))\n';
+/** Workers expose CompiledWasm imports as modules, rather than instantiated exports. */
+export function compiledWasmSource(file) {
+    return `${SOURCE_PREFIX}${file}${SOURCE_SUFFIX}`;
+}
+/**
+ * Async hooks run in a separate Node thread. A self-contained ESM hook admits both emitted JS and
+ * source builds under tsx without requiring that thread to resolve or transpile our source files.
+ * The emitted import source is shared with Bun.
+ */
+export const compiledWasmLoader = `data:text/javascript,${encodeURIComponent(`
+export function load(url, context, nextLoad) {
+  if (!url.startsWith('file:') || !url.endsWith('.wasm')) return nextLoad(url, context);
+  return {
+    format: 'module',
+    shortCircuit: true,
+    source: ${JSON.stringify(SOURCE_PREFIX)} + 'new URL(' + JSON.stringify(url) + ')' + ${JSON.stringify(SOURCE_SUFFIX)},
+  };
+}
+`)}`;

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/index.d.ts

@@ -2,7 +2,7 @@ export { generateBuildMaterialModule } from './material.js';
 export { artifact, materialize, prepareWorkerArtifact } from './artifact.js';
 export { loadWorkerArtifact } from './worker/index.js';
 export type { WorkerArtifact } from './worker/index.js';
-export { resolveRouter, workerName } from './configuration.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,7 @@
 export { generateBuildMaterialModule } from './material.js';
 export { artifact, materialize, prepareWorkerArtifact } from './artifact.js';
 export { loadWorkerArtifact } from './worker/index.js';
-export { resolveRouter, workerName } from './configuration.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)
+  },`
+        : ''}
 })
 `;
 }