@astrale-os/adapter-cloudflare 0.5.0-beta.24 → 0.5.0-beta.26

package/dist/build/artifact.js

@@ -5,7 +5,7 @@ import { dirname, join, relative, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { SIGNING_IDENTITY_BINDING } from '../identity/binding.js';
 import { releaseNamespace, releaseWorkerName } from '../release/index.js';
-import { generateExecutionEntry } from './codegen/execution.js';
+import { generateExecutionEntry, generateExecutionService } from './codegen/execution.js';
 import { generateGatewayEntry } from './codegen/gateway.js';
 import { generateWranglerConfig } from './codegen/wrangler.js';
 import { deploymentAddressing, resolveRouter, workerName } from './configuration.js';
@@ -13,6 +13,9 @@ import { frontendFiles } from './frontend-v1.js';
 import { qualifyWorkerBundle } from './qualification.js';
 import { runWranglerBundle } from './wrangler-cli.js';
 const encoder = new TextEncoder();
+const SERVICE_MODULE = 'service.mjs';
+const RELEASE_ENTRY = 'bundle/index.mjs';
+const RELEASE_SERVICE = `bundle/${SERVICE_MODULE}`;
 /** Prepare one revision Service and its stateless gateway without provider mutation. */
 export async function artifact(params, context) {
     const stateDirectory = join(context.projectDir, '.astrale');
@@ -26,7 +29,7 @@ export async function artifact(params, context) {
     const namespace = releaseNamespace(name);
     const target = releaseWorkerName(revision);
     const configuredIssuer = deploymentAddressing(params);
-    const source = generateExecutionEntry({
+    const serviceSource = generateExecutionService({
         origin: context.build.schema.compiled.root.origin,
         runtimeSpecifier,
         material: material(context.build),
@@ -41,8 +44,40 @@ export async function artifact(params, context) {
                 },
             }),
     });
+    const serviceSourcePath = join(directory, 'service.gen.ts');
+    await writeFile(serviceSourcePath, serviceSource);
+    const serviceConfigPath = join(directory, 'wrangler.service.prepare.jsonc');
+    await writeFile(serviceConfigPath, generateWranglerConfig({
+        workerName: name,
+        main: './service.gen.ts',
+        vars: {
+            ...params.vars,
+            ...(configuredIssuer === undefined ? {} : { WORKER_URL: configuredIssuer }),
+        },
+        secretBindings: [SIGNING_IDENTITY_BINDING],
+        ...(router === undefined
+            ? {}
+            : { router: { binding: router.binding, service: router.service } }),
+        ...(params.wrangler === undefined ? {} : { wrangler: params.wrangler }),
+        selfBinding: false,
+    }));
+    const serviceOutput = join(directory, 'dist-service');
+    await rm(serviceOutput, { recursive: true, force: true });
+    const emittedService = await runWranglerBundle({
+        projectDir: context.projectDir,
+        configPath: serviceConfigPath,
+        outDir: serviceOutput,
+    });
+    await qualifyWorkerBundle({
+        metafilePath: emittedService.metafilePath,
+        inputRoot: dirname(serviceConfigPath),
+    });
+    await admitBundle(emittedService.bundlePath);
+    const serviceBundle = await readFile(emittedService.bundlePath);
+    await mkdir(dirname(join(directory, RELEASE_SERVICE)), { recursive: true });
+    await writeFile(join(directory, RELEASE_SERVICE), serviceBundle);
     const sourcePath = join(directory, 'worker.gen.ts');
-    await writeFile(sourcePath, source);
+    await writeFile(sourcePath, generateExecutionEntry(`./${RELEASE_SERVICE}`));
     const configPath = join(directory, 'wrangler.prepare.jsonc');
     await writeFile(configPath, generateWranglerConfig({
         workerName: name,
@@ -52,6 +87,7 @@ export async function artifact(params, context) {
             ...(configuredIssuer === undefined ? {} : { WORKER_URL: configuredIssuer }),
         },
         secretBindings: [SIGNING_IDENTITY_BINDING],
+        modules: { baseDir: '.', globs: [RELEASE_SERVICE] },
         ...(router === undefined
             ? {}
             : { router: { binding: router.binding, service: router.service } }),
@@ -100,12 +136,13 @@ export async function artifact(params, context) {
     const gatewayBundle = await readFile(gateway.bundlePath);
     const releaseConfig = generateWranglerConfig({
         workerName: target,
-        main: './bundle/index.mjs',
+        main: `./${RELEASE_ENTRY}`,
         vars: {
             ...params.vars,
             ...(configuredIssuer === undefined ? {} : { WORKER_URL: configuredIssuer }),
         },
         secretBindings: [SIGNING_IDENTITY_BINDING],
+        modules: { baseDir: '.', globs: [RELEASE_SERVICE] },
         ...(context.build.frontend?.source.kind === 'vite'
             ? {
                 frontend: {
@@ -131,7 +168,8 @@ export async function artifact(params, context) {
     const files = [
         { path: 'wrangler.release.jsonc', content: encoder.encode(releaseConfig) },
         { path: 'wrangler.gateway.jsonc', content: encoder.encode(gatewayConfig) },
-        { path: 'bundle/index.mjs', content: new Uint8Array(bundle) },
+        { path: RELEASE_ENTRY, content: new Uint8Array(bundle) },
+        { path: RELEASE_SERVICE, content: new Uint8Array(serviceBundle) },
         { path: 'gateway/index.mjs', content: new Uint8Array(gatewayBundle) },
         ...frontend.map((file) => ({
             path: `frontend/${file.path}`,
@@ -139,7 +177,7 @@ export async function artifact(params, context) {
         })),
     ];
     return Object.freeze({
-        entrypoint: 'bundle/index.mjs',
+        entrypoint: RELEASE_ENTRY,
         files: Object.freeze(files),
         addressing: configuredIssuer === undefined
             ? Object.freeze({ kind: 'provider-assigned', claim: name })

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

@@ -10,4 +10,6 @@ export interface ExecutionCodegenOptions {
         readonly minLabels: number;
     };
 }
-export declare function generateExecutionEntry(options: ExecutionCodegenOptions): string;
+export declare function generateExecutionService(options: ExecutionCodegenOptions): string;
+/** Generate the isolate-startup entry that realizes the heavy Service on first request. */
+export declare function generateExecutionEntry(serviceSpecifier: string): string;

package/dist/build/codegen/execution.js

@@ -1,4 +1,4 @@
-export function generateExecutionEntry(options) {
+export function generateExecutionService(options) {
     const router = options.router;
     const routerPredicate = router === undefined
         ? ''
@@ -22,18 +22,18 @@ import type { BuildMaterial } from '@astrale-os/sdk/deployment/build'
 import type { CloudflareAdapterBindings } from '@astrale-os/adapter-cloudflare/worker'
 
 import { cloudflareWorkerEntry } from '@astrale-os/adapter-cloudflare/worker'
-import runtime from ${JSON.stringify(options.runtimeSpecifier)}
 import { decodeSigningIdentity, runtimeBindings } from '@astrale-os/adapter-cloudflare/worker'
 
 type WorkerEnv = CloudflareEnv & CloudflareAdapterBindings & {
   readonly ASTRALE_SIGNING_IDENTITY: string
 }
 type RuntimeEnv = Omit<WorkerEnv, 'ASTRALE_SIGNING_IDENTITY'>
-const MATERIAL = ${JSON.stringify(options.material)} as const satisfies BuildMaterial
 ${routerPredicate}
 export default cloudflareWorkerEntry<WorkerEnv, RuntimeEnv>()({
-  runtime,
-  material: MATERIAL,
+  load: async () => ({
+    runtime: (await import(${JSON.stringify(options.runtimeSpecifier)})).default,
+    material: ${JSON.stringify(options.material)} as const satisfies BuildMaterial,
+  }),
   privateKey: (env) => decodeSigningIdentity(env.ASTRALE_SIGNING_IDENTITY),
   resolveEnvironment: runtimeBindings,
   resolveUrl: (env, requestOrigin) => env.WORKER_URL ?? env.IDENTITY_ISS ?? requestOrigin,
@@ -42,3 +42,31 @@ export default cloudflareWorkerEntry<WorkerEnv, RuntimeEnv>()({
 })
 `;
 }
+/** Generate the isolate-startup entry that realizes the heavy Service on first request. */
+export function generateExecutionEntry(serviceSpecifier) {
+    return `// AUTO-GENERATED by @astrale-os/adapter-cloudflare — do not edit.
+import type { CloudflareWorker } from '@astrale-os/adapter-cloudflare/worker'
+
+const SERVICE_SPECIFIER = ${JSON.stringify(serviceSpecifier)}
+let servicePromise: Promise<CloudflareWorker<CloudflareEnv>> | undefined
+
+export default {
+  async fetch(request: Request, environment: CloudflareEnv, context: ExecutionContext) {
+    return (await service()).fetch(request, environment, context)
+  },
+}
+
+function service(): Promise<CloudflareWorker<CloudflareEnv>> {
+  return (servicePromise ??= import(SERVICE_SPECIFIER).then((loaded: unknown) => {
+    if (loaded === null || typeof loaded !== 'object') invalid()
+    const worker = Reflect.get(loaded, 'default') as unknown
+    if (worker === null || typeof worker !== 'object' || typeof Reflect.get(worker, 'fetch') !== 'function') invalid()
+    return worker as CloudflareWorker<CloudflareEnv>
+  }))
+}
+
+function invalid(): never {
+  throw new TypeError('Cloudflare execution Service module is invalid.')
+}
+`;
+}

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

@@ -27,6 +27,11 @@ export interface WranglerCodegenOptions {
     vars?: Record<string, string>;
     /** Secret binding names required by generated Worker code. */
     secretBindings?: readonly string[];
+    /** JavaScript modules retained outside the startup entry and loaded on demand. */
+    modules?: {
+        readonly baseDir: string;
+        readonly globs: readonly string[];
+    };
     /** Add the SELF service binding (autobinding). */
     selfBinding: boolean;
     /** Bind the stable gateway to its private revision namespace. */

package/dist/build/codegen/wrangler.js

@@ -60,6 +60,17 @@ export function generateWranglerConfig(opts) {
     if (opts.secretBindings && opts.secretBindings.length > 0) {
         config.secrets = { required: [...opts.secretBindings] };
     }
+    if (opts.modules !== undefined) {
+        config.find_additional_modules = true;
+        config.base_dir = opts.modules.baseDir;
+        config.rules = [
+            {
+                type: 'ESModule',
+                globs: [...opts.modules.globs],
+                fallthrough: true,
+            },
+        ];
+    }
     if (opts.releases !== undefined) {
         config.dispatch_namespaces = [opts.releases];
     }
@@ -75,6 +86,8 @@ const ADAPTER_OWNED_KEYS = [
     'compatibility_date',
     'version_metadata',
     'secrets',
+    'find_additional_modules',
+    'base_dir',
 ];
 /**
  * Deep-merge the dev's raw wrangler overlay over the generated config, after

package/dist/build/wrangler-cli.d.ts

@@ -84,9 +84,9 @@ export interface WranglerDeploymentStatus {
 /** Admit Wrangler's current-deployment JSON before it becomes provider evidence. */
 export declare function admitWranglerDeploymentStatus(output: string): WranglerDeploymentStatus;
 /**
- * Build the single-module worker bundle WITHOUT deploying — `wrangler deploy
+ * Build the Worker entry module WITHOUT deploying — `wrangler deploy
  * --dry-run --outdir` (no Cloudflare auth required). Returns the path of the
- * bundled .js module (the managed adapter publishes its bytes).
+ * bundled entry .js module (the managed adapter publishes its bytes).
  */
 export declare function runWranglerBundle(args: {
     projectDir: string;

package/dist/build/wrangler-cli.js

@@ -400,9 +400,9 @@ async function stopChild(child) {
     });
 }
 /**
- * Build the single-module worker bundle WITHOUT deploying — `wrangler deploy
+ * Build the Worker entry module WITHOUT deploying — `wrangler deploy
  * --dry-run --outdir` (no Cloudflare auth required). Returns the path of the
- * bundled .js module (the managed adapter publishes its bytes).
+ * bundled entry .js module (the managed adapter publishes its bytes).
  */
 export async function runWranglerBundle(args) {
     await runWranglerTypes(args);

package/dist/worker/entry.d.ts

@@ -17,8 +17,8 @@ export interface CloudflareAdapterBindings {
     };
 }
 export interface CloudflareWorkerConfig<RuntimeValue extends Runtime, Bindings extends CloudflareAdapterBindings, Environment> {
-    readonly runtime: RuntimeValue;
-    readonly material: BuildMaterial;
+    /** Load the exact Runtime and Build once, after the isolate has accepted a request. */
+    readonly load: () => CloudflareWorkerSource<RuntimeValue> | Promise<CloudflareWorkerSource<RuntimeValue>>;
     readonly privateKey: JsonWebKey | ((bindings: Bindings) => JsonWebKey);
     readonly resolveEnvironment?: (bindings: Bindings) => Environment;
     readonly resolveUrl?: (bindings: Bindings, requestOrigin: string) => string;
@@ -27,6 +27,10 @@ export interface CloudflareWorkerConfig<RuntimeValue extends Runtime, Bindings e
     readonly routeSubrequest?: (url: URL, bindings: Bindings) => Fetcher | null | undefined;
     readonly invocationTimeoutMs?: number;
 }
+export interface CloudflareWorkerSource<RuntimeValue extends Runtime> {
+    readonly runtime: RuntimeValue;
+    readonly material: BuildMaterial;
+}
 export interface CloudflareWorker<Bindings> {
     fetch(request: Request, environment: Bindings, executionContext?: ExecutionContext): Response | Promise<Response>;
 }

package/dist/worker/entry.js

@@ -11,43 +11,47 @@ export function cloudflareWorkerEntry() {
         const realize = () => {
             if (realized !== undefined)
                 return realized;
-            const build = restoreBuild(config.material, config.runtime);
-            const application = serve({
-                runtime: config.runtime,
-                load(environment) {
-                    if (currentIssuer !== environment.issuer) {
-                        throw new TypeError('Cloudflare Worker request origin differs from its current Release.');
-                    }
-                    return assemble(build, addressing(environment.issuer));
-                },
-                initialize: (environment) => config.resolveEnvironment === undefined
-                    ? environment.bindings
-                    : config.resolveEnvironment(environment.bindings),
-                identity(environment) {
-                    return createIdentity({
-                        issuer: issuer.accept(environment.issuer),
-                        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.issuer).protocol === 'http:'
-                            ? { allowInsecureHttp: true }
-                            : {}),
-                    });
-                },
-                server: {
-                    health: { probe: { check: () => true } },
-                    limits: {
-                        maximumRequestBytes: 1024 * 1024,
-                        maximumPublicationBytes: 1024 * 1024,
-                        maximumBundleBytes: 8 * 1024 * 1024,
-                        maximumDeliveryBytes: 8 * 1024 * 1024,
-                        invocationTimeoutMs: config.invocationTimeoutMs ?? 30_000,
+            realized = Promise.resolve()
+                .then(config.load)
+                .then((source) => {
+                const build = restoreBuild(source.material, source.runtime);
+                const application = serve({
+                    runtime: source.runtime,
+                    load(environment) {
+                        if (currentIssuer !== environment.issuer) {
+                            throw new TypeError('Cloudflare Worker request origin differs from its current Release.');
+                        }
+                        return assemble(build, addressing(environment.issuer));
+                    },
+                    initialize: (environment) => config.resolveEnvironment === undefined
+                        ? environment.bindings
+                        : config.resolveEnvironment(environment.bindings),
+                    identity(environment) {
+                        return createIdentity({
+                            issuer: issuer.accept(environment.issuer),
+                            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.issuer).protocol === 'http:'
+                                ? { allowInsecureHttp: true }
+                                : {}),
+                        });
+                    },
+                    server: {
+                        health: { probe: { check: () => true } },
+                        limits: {
+                            maximumRequestBytes: 1024 * 1024,
+                            maximumPublicationBytes: 1024 * 1024,
+                            maximumBundleBytes: 8 * 1024 * 1024,
+                            maximumDeliveryBytes: 8 * 1024 * 1024,
+                            invocationTimeoutMs: config.invocationTimeoutMs ?? 30_000,
+                        },
                     },
-                },
+                });
+                return Object.freeze({ build, application });
             });
-            realized = Object.freeze({ build, application });
             return realized;
         };
         return Object.freeze({
@@ -69,7 +73,7 @@ export function cloudflareWorkerEntry() {
                     return new Response('Request origin differs from the current Release.', { status: 421 });
                 }
                 currentIssuer = issuer;
-                const { application, build } = realize();
+                const { application, build } = await realize();
                 const frontend = await frontendAsset(build.frontend, bindings, url, request);
                 if (frontend !== undefined)
                     return frontend;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/adapter-cloudflare",
-  "version": "0.5.0-beta.24",
+  "version": "0.5.0-beta.26",
   "description": "Deploy an Astrale application through Cloudflare Workers",
   "keywords": [
     "adapter",
@@ -45,7 +45,7 @@
     "hono": "^4.6.20",
     "jose": "^6.1.3",
     "wrangler": "4.123.0",
-    "@astrale-os/sdk": "^0.5.0-beta.21"
+    "@astrale-os/sdk": "^0.5.0-beta.23"
   },
   "devDependencies": {
     "@astrale-os/ox": ">=0.1.0 <1.0.0",