@astrale-os/adapter-cloudflare 0.5.0-beta.158 → 0.5.0-beta.159

package/README.md

@@ -22,8 +22,11 @@ HTTP traffic. Exact-version probes verify Publication, Bundle, and serving ident
 serving the Publication also initializes the Application Runtime. After promotion, normal requests
 must prove that exact version again. A failed candidate remains at 0% and can be replaced on retry.
 Bundled View routes must also serve the prepared browser-file generation before readiness passes.
-This covers frontend-only changes without changing the Schema or reinstalling the Domain. HTML
-and transient asset misses are not cached; ordinary successful asset responses keep their cache policy.
+This covers frontend-only changes without changing the Schema or reinstalling the Domain. HTML is
+revalidated on every use and transient asset misses are not cached; ordinary successful asset
+responses keep their cache policy. Frontend files are answered by the Worker's small startup module
+without loading the execution Service, which each such file starts loading in the background for the
+calls the View makes next.
 The first deployment uses ordinary Worker provisioning because no previous version exists to retain.
 An existing traffic-split rollout must be resolved before this single-version workflow can continue.
 
@@ -92,3 +95,8 @@ It constructs the same verified, deduplicated material as the adapter's generate
 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
 versions aligned, and regenerate it when either the Application or that SDK version changes.
+
+Such an entrypoint can keep the same fast frontend path by answering from
+`cloudflareFrontDoor()` (`@astrale-os/adapter-cloudflare/worker/front`, which reaches no SDK
+runtime module) before importing its Service, and calling that Service's `prepare()` through
+`waitUntil` when the front door served a frontend file.

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

@@ -1,2 +1,11 @@
+import type { BuildMaterial } from '@astrale-os/sdk/deployment/build';
+export interface ExecutionEntryOptions {
+    readonly workerSpecifier?: string;
+    readonly frontSpecifier?: string;
+    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, workerSpecifier?: string): string;
+export declare function generateExecutionEntry(serviceSpecifier: string, options?: ExecutionEntryOptions): string;

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

@@ -1,13 +1,46 @@
 /** Generate the isolate-startup entry that realizes the heavy Service on first request. */
-export function generateExecutionEntry(serviceSpecifier, workerSpecifier = '@astrale-os/adapter-cloudflare/worker') {
+export function generateExecutionEntry(serviceSpecifier, options = {}) {
+    const workerSpecifier = options.workerSpecifier ?? '@astrale-os/adapter-cloudflare/worker';
+    const frontSpecifier = options.frontSpecifier ?? '@astrale-os/adapter-cloudflare/worker/front';
+    const configuration = [
+        options.frontend === undefined
+            ? ''
+            : `  frontend: ${JSON.stringify(options.frontend)} as const satisfies NonNullable<BuildMaterial['frontend']>,\n`,
+        options.frontendRevision === undefined
+            ? ''
+            : `  frontendRevision: ${JSON.stringify(options.frontendRevision)},\n`,
+        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'
 import type { CloudflareWorker } from ${JSON.stringify(workerSpecifier)}
+import type { CloudflareAdapterBindings } from ${JSON.stringify(frontSpecifier)}
+
+import { cloudflareFrontDoor } from ${JSON.stringify(frontSpecifier)}
+
+type WorkerEnv = CloudflareEnv & CloudflareAdapterBindings
 
 const SERVICE_SPECIFIER = ${JSON.stringify(serviceSpecifier)}
 let servicePromise: Promise<CloudflareWorker<CloudflareEnv>> | undefined
 
+// Admission and public frontend files answer from startup, so a View's document never waits for
+// the execution Service to load. Each such file starts that load for the calls the View makes next.
+const frontDoor = cloudflareFrontDoor<WorkerEnv>({
+${configuration}})
+
 export default {
-  async fetch(request: Request, environment: CloudflareEnv, context: ExecutionContext) {
+  async fetch(request: Request, environment: WorkerEnv, context: ExecutionContext) {
+    const admission = await frontDoor.admit(request, environment)
+    if (admission.kind === 'refused') return admission.response
+    if (admission.kind === 'frontend') {
+      context.waitUntil(prepare())
+      return admission.response
+    }
     return (await service()).fetch(request, environment, context)
   },
 }
@@ -21,6 +54,13 @@ function service(): Promise<CloudflareWorker<CloudflareEnv>> {
   }))
 }
 
+function prepare(): Promise<void> {
+  // A failure stays memoized by the Service and resurfaces on the request that needs it.
+  return service().then((worker) => worker.prepare?.()).then(ignore, ignore)
+}
+
+function ignore(): void {}
+
 function invalid(): never {
   throw new TypeError('Cloudflare execution Service module is invalid.')
 }

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

@@ -1,3 +1,4 @@
+import { generatedMaterial } from '@astrale-os/sdk/deployment/build';
 import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { dirname, join, relative, resolve } from 'node:path';
 import { SIGNING_IDENTITY_BINDING } from '../../identity/binding.js';
@@ -7,7 +8,7 @@ import { generateExecutionEntry, generateExecutionService } from '../codegen/exe
 import { generateWranglerConfig } from '../codegen/wrangler.js';
 import { workerInvocationTimeout, workerRequestLimit } from '../configuration.js';
 import { qualifyWorkerBundle } from '../qualification.js';
-import { workerModuleSpecifier } from './specifier.js';
+import { frontModuleSpecifier, workerModuleSpecifier } from './specifier.js';
 export const RELEASE_ENTRY = 'bundle/index.mjs';
 export const RELEASE_SERVICE = 'bundle/service.mjs';
 export async function prepareExecution(input) {
@@ -77,7 +78,19 @@ export async function prepareExecution(input) {
     await mkdir(dirname(join(input.directory, RELEASE_SERVICE)), { recursive: true });
     await writeFile(join(input.directory, RELEASE_SERVICE), service);
     const sourcePath = join(input.directory, 'worker.gen.ts');
-    await writeFile(sourcePath, generateExecutionEntry('./service.mjs', workerSpecifier));
+    const frontend = generatedMaterial(input.context.build).material.frontend;
+    await writeFile(sourcePath, generateExecutionEntry('./service.mjs', {
+        workerSpecifier,
+        frontSpecifier: frontModuleSpecifier(),
+        ...(frontend === undefined ? {} : { frontend }),
+        ...(input.frontendRevision === undefined ? {} : { frontendRevision: input.frontendRevision }),
+        ...(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,

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

@@ -1 +1,3 @@
 export declare function workerModuleSpecifier(): string;
+/** The isolate-startup module, which must stay free of the execution Service's dependencies. */
+export declare function frontModuleSpecifier(): string;

package/dist/build/worker/specifier.js

@@ -1,5 +1,10 @@
 import { fileURLToPath } from 'node:url';
 const workerModule = import.meta.resolve('@astrale-os/adapter-cloudflare/worker');
+const frontModule = import.meta.resolve('@astrale-os/adapter-cloudflare/worker/front');
 export function workerModuleSpecifier() {
     return fileURLToPath(workerModule);
 }
+/** The isolate-startup module, which must stay free of the execution Service's dependencies. */
+export function frontModuleSpecifier() {
+    return fileURLToPath(frontModule);
+}

package/dist/worker/entry.d.ts

@@ -2,33 +2,14 @@ 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 { Runtime } from '@astrale-os/sdk/runtime';
-export interface Fetcher {
-    fetch(request: Request): Response | Promise<Response>;
-}
-export interface CloudflareAdapterBindings {
-    readonly ASTRALE_SIGNING_IDENTITY?: string;
-    readonly ASTRALE_VERSION_METADATA?: {
-        readonly id: string;
-    };
-    readonly WORKER_URL?: string;
-    readonly IDENTITY_ISS?: string;
-    readonly ASSETS?: Fetcher;
-    readonly SELF?: Fetcher;
-}
-export interface CloudflareWorkerConfig<RuntimeValue extends Runtime, Bindings extends CloudflareAdapterBindings, Environment, Material = BuildMaterial> {
-    /** Generated frontend evidence available without restoring the execution Build. */
-    readonly frontend?: BuildMaterial['frontend'];
-    /** Generated browser-file identity used only for deployment propagation checks. */
-    readonly frontendRevision?: string;
-    /** Served frontend paths the bundler content-addressed; absent means none may be retained. */
-    readonly frontendAddressed?: readonly string[];
+import type { CloudflareAdapterBindings, CloudflareFrontDoorConfig, Fetcher } from './front.js';
+export type { CloudflareAdapterBindings, Fetcher } from './front.js';
+export interface CloudflareWorkerConfig<RuntimeValue extends Runtime, Bindings extends CloudflareAdapterBindings, Environment, Material = BuildMaterial> extends CloudflareFrontDoorConfig<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 resolveUrl?: (bindings: Bindings, requestOrigin: string) => string;
     readonly identityIssuer?: string;
-    readonly providerAssignedWorker?: string;
     readonly selfBinding?: (bindings: Bindings) => Fetcher | null | undefined;
     readonly routeSubrequest?: (url: URL, bindings: Bindings) => Fetcher | null | undefined;
     readonly invocationTimeoutMs?: number;
@@ -41,6 +22,8 @@ export interface CloudflareWorkerSource<RuntimeValue extends Runtime, Material =
 }
 export interface CloudflareWorker<Bindings> {
     fetch(request: Request, environment: Bindings, executionContext?: ExecutionContext): Response | Promise<Response>;
+    /** Realize execution ahead of the request that needs it; failures resurface on that request. */
+    prepare?(): Promise<void>;
 }
 /** Compose one Service implementation behind its provider-owned stable address. */
 export declare function cloudflareWorkerEntry<Bindings extends CloudflareAdapterBindings, Environment = Bindings>(): <RuntimeValue extends Runtime>(config: CloudflareWorkerConfig<RuntimeValue, Bindings, Environment, BuildMaterial>) => CloudflareWorker<Bindings>;

package/dist/worker/entry.js

@@ -3,6 +3,7 @@ import { restoreBuild, restoreGeneratedBuild } from '@astrale-os/sdk/deployment/
 import { addressing, assemble } 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';
 /** Compose one Service implementation behind its provider-owned stable address. */
 export function cloudflareWorkerEntry() {
@@ -14,7 +15,7 @@ export function generatedCloudflareWorkerEntry() {
 }
 function createCloudflareWorkerEntry(restore) {
     return function (config) {
-        let currentPublicUrl;
+        const frontDoor = cloudflareFrontDoor(config);
         let realized;
         const realize = () => {
             if (realized !== undefined)
@@ -26,7 +27,7 @@ function createCloudflareWorkerEntry(restore) {
                 const application = serve({
                     runtime: source.runtime,
                     load(environment) {
-                        if (currentPublicUrl !== environment.publicUrl) {
+                        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, {
@@ -69,28 +70,10 @@ function createCloudflareWorkerEntry(restore) {
         };
         return Object.freeze({
             async fetch(request, bindings, context) {
-                const url = new URL(request.url);
-                const publicUrl = canonicalServingUrl(bindings.WORKER_URL ??
-                    bindings.IDENTITY_ISS ??
-                    config.resolveUrl?.(bindings, requestOrigin(url, request)) ??
-                    requestOrigin(url, request));
-                if (config.providerAssignedWorker !== undefined &&
-                    bindings.WORKER_URL === undefined &&
-                    bindings.IDENTITY_ISS === undefined &&
-                    !matchesWorkersDevClaim(publicUrl, config.providerAssignedWorker)) {
-                    return new Response('Request origin differs from provider-assigned Addressing.', {
-                        status: 421,
-                    });
-                }
-                if (currentPublicUrl !== undefined && currentPublicUrl !== publicUrl) {
-                    return new Response('Request origin differs from the current Release.', { status: 421 });
-                }
-                currentPublicUrl = publicUrl;
-                if (config.frontend !== undefined) {
-                    const frontend = await frontendAsset(config.frontend, bindings.ASSETS, url, request, config.frontendRevision, config.frontendAddressed);
-                    if (frontend !== undefined)
-                        return withProviderVersion(frontend, bindings);
-                }
+                const admission = await frontDoor.admit(request, bindings);
+                if (admission.kind !== 'execution')
+                    return admission.response;
+                const { url, publicUrl } = admission;
                 const { application, build } = await realize();
                 if (config.frontend === undefined) {
                     const frontend = await frontendAsset(build.frontend, bindings.ASSETS, url, request, config.frontendRevision, config.frontendAddressed);
@@ -100,16 +83,12 @@ function createCloudflareWorkerEntry(restore) {
                 const response = await application.fetch(request, Object.freeze({ bindings, publicUrl }), context);
                 return withProviderVersion(response, bindings);
             },
+            async prepare() {
+                await realize();
+            },
         });
     };
 }
-function withProviderVersion(response, bindings) {
-    if (bindings.ASTRALE_VERSION_METADATA === undefined)
-        return response;
-    const versioned = new Response(response.body, response);
-    versioned.headers.set('X-Astrale-Worker-Version', bindings.ASTRALE_VERSION_METADATA.id);
-    return versioned;
-}
 function routedFetch(application, environment, config) {
     return async (input, init) => {
         const { request, rejectRedirect } = prepareCloudflareRequest(input, init);
@@ -124,36 +103,3 @@ function routedFetch(application, environment, config) {
         return dispatchCloudflareRequest(request, rejectRedirect, (selected) => route === null || route === undefined ? fetch(selected) : route.fetch(selected));
     };
 }
-function requestOrigin(url, request) {
-    if (url.protocol !== 'http:')
-        return url.origin;
-    const forwarded = request.headers.get('x-forwarded-proto')?.split(',')[0]?.trim().toLowerCase();
-    return forwarded === 'https' ? `https://${url.host}` : url.origin;
-}
-function canonicalServingUrl(input) {
-    let url;
-    try {
-        url = new URL(input);
-    }
-    catch (cause) {
-        throw new TypeError('Cloudflare Worker serving URL is invalid.', { cause });
-    }
-    if ((url.protocol !== 'https:' && url.protocol !== 'http:') ||
-        url.username !== '' ||
-        url.password !== '' ||
-        url.pathname !== '/' ||
-        url.search !== '' ||
-        url.hash !== '') {
-        throw new TypeError('Cloudflare Worker serving URL must be one HTTP(S) origin.');
-    }
-    return url.origin;
-}
-function matchesWorkersDevClaim(issuer, expectedWorker) {
-    const url = new URL(issuer);
-    const labels = url.hostname.split('.');
-    return (url.protocol === 'https:' &&
-        labels.length >= 4 &&
-        labels[0] === expectedWorker &&
-        labels.at(-2) === 'workers' &&
-        labels.at(-1) === 'dev');
-}

package/dist/worker/front.d.ts

@@ -0,0 +1,49 @@
+import type { BuildMaterial } from '@astrale-os/sdk/deployment/build/material';
+export interface Fetcher {
+    fetch(request: Request): Response | Promise<Response>;
+}
+export interface CloudflareAdapterBindings {
+    readonly ASTRALE_SIGNING_IDENTITY?: string;
+    readonly ASTRALE_VERSION_METADATA?: {
+        readonly id: string;
+    };
+    readonly WORKER_URL?: string;
+    readonly IDENTITY_ISS?: string;
+    readonly ASSETS?: Fetcher;
+    readonly SELF?: Fetcher;
+}
+export interface CloudflareFrontDoorConfig<Bindings extends CloudflareAdapterBindings> {
+    /** Generated frontend evidence available without restoring the execution Build. */
+    readonly frontend?: BuildMaterial['frontend'];
+    /** Generated browser-file identity used only for deployment propagation checks. */
+    readonly frontendRevision?: string;
+    /** Served frontend paths the bundler content-addressed; absent means none may be retained. */
+    readonly frontendAddressed?: readonly string[];
+    readonly resolveUrl?: (bindings: Bindings, requestOrigin: string) => string;
+    readonly providerAssignedWorker?: string;
+}
+export type CloudflareFrontDoorAdmission = 
+/** The request is not for this isolate's serving origin. */
+{
+    readonly kind: 'refused';
+    readonly response: Response;
+}
+/** A public frontend file answered the request without the execution Service. */
+ | {
+    readonly kind: 'frontend';
+    readonly response: Response;
+}
+/** The request needs the execution Service, under this isolate's one serving origin. */
+ | {
+    readonly kind: 'execution';
+    readonly url: URL;
+    readonly publicUrl: string;
+};
+export interface CloudflareFrontDoor<Bindings extends CloudflareAdapterBindings> {
+    admit(request: Request, bindings: Bindings): Promise<CloudflareFrontDoorAdmission>;
+    /** The serving origin this isolate pinned on its first admitted request. */
+    current(): string | undefined;
+}
+/** Admit requests to one serving origin and answer public frontend files, per isolate. */
+export declare function cloudflareFrontDoor<Bindings extends CloudflareAdapterBindings>(config: CloudflareFrontDoorConfig<Bindings>): CloudflareFrontDoor<Bindings>;
+export declare function withProviderVersion(response: Response, bindings: CloudflareAdapterBindings): Response;

package/dist/worker/front.js

@@ -0,0 +1,75 @@
+import { frontendAsset } from './frontend.js';
+/** Admit requests to one serving origin and answer public frontend files, per isolate. */
+export function cloudflareFrontDoor(config) {
+    let currentPublicUrl;
+    return Object.freeze({
+        async admit(request, bindings) {
+            const url = new URL(request.url);
+            const publicUrl = canonicalServingUrl(bindings.WORKER_URL ??
+                bindings.IDENTITY_ISS ??
+                config.resolveUrl?.(bindings, requestOrigin(url, request)) ??
+                requestOrigin(url, request));
+            if (config.providerAssignedWorker !== undefined &&
+                bindings.WORKER_URL === undefined &&
+                bindings.IDENTITY_ISS === undefined &&
+                !matchesWorkersDevClaim(publicUrl, config.providerAssignedWorker)) {
+                return refused('Request origin differs from provider-assigned Addressing.');
+            }
+            if (currentPublicUrl !== undefined && currentPublicUrl !== publicUrl) {
+                return refused('Request origin differs from the current Release.');
+            }
+            currentPublicUrl = publicUrl;
+            if (config.frontend !== undefined) {
+                const frontend = await frontendAsset(config.frontend, bindings.ASSETS, url, request, config.frontendRevision, config.frontendAddressed);
+                if (frontend !== undefined) {
+                    return { kind: 'frontend', response: withProviderVersion(frontend, bindings) };
+                }
+            }
+            return { kind: 'execution', url, publicUrl };
+        },
+        current: () => currentPublicUrl,
+    });
+}
+export function withProviderVersion(response, bindings) {
+    if (bindings.ASTRALE_VERSION_METADATA === undefined)
+        return response;
+    const versioned = new Response(response.body, response);
+    versioned.headers.set('X-Astrale-Worker-Version', bindings.ASTRALE_VERSION_METADATA.id);
+    return versioned;
+}
+function refused(message) {
+    return { kind: 'refused', response: new Response(message, { status: 421 }) };
+}
+function requestOrigin(url, request) {
+    if (url.protocol !== 'http:')
+        return url.origin;
+    const forwarded = request.headers.get('x-forwarded-proto')?.split(',')[0]?.trim().toLowerCase();
+    return forwarded === 'https' ? `https://${url.host}` : url.origin;
+}
+function canonicalServingUrl(input) {
+    let url;
+    try {
+        url = new URL(input);
+    }
+    catch (cause) {
+        throw new TypeError('Cloudflare Worker serving URL is invalid.', { cause });
+    }
+    if ((url.protocol !== 'https:' && url.protocol !== 'http:') ||
+        url.username !== '' ||
+        url.password !== '' ||
+        url.pathname !== '/' ||
+        url.search !== '' ||
+        url.hash !== '') {
+        throw new TypeError('Cloudflare Worker serving URL must be one HTTP(S) origin.');
+    }
+    return url.origin;
+}
+function matchesWorkersDevClaim(issuer, expectedWorker) {
+    const url = new URL(issuer);
+    const labels = url.hostname.split('.');
+    return (url.protocol === 'https:' &&
+        labels.length >= 4 &&
+        labels[0] === expectedWorker &&
+        labels.at(-2) === 'workers' &&
+        labels.at(-1) === 'dev');
+}

package/dist/worker/frontend.d.ts

@@ -1,4 +1,4 @@
 import type { BuildMaterial } from '@astrale-os/sdk/deployment/build/material';
-import type { Fetcher } from './entry.js';
+import type { Fetcher } from './front.js';
 /** Serve public frontend files without realizing the Application's execution Runtime. */
 export declare function frontendAsset(frontend: BuildMaterial['frontend'], assets: Fetcher | undefined, url: URL, request: Request, revision?: string, addressed?: readonly string[]): Promise<Response | undefined>;

package/dist/worker/frontend.js

@@ -41,7 +41,11 @@ export async function frontendAsset(frontend, assets, url, request, revision, ad
 function retainable(url, addressed) {
     if (addressed === undefined || addressed.length === 0)
         return false;
-    return addressed.includes(decodeURIComponent(url.pathname).replace(/^\//u, ''));
+    const path = decodeURIComponent(url.pathname).replace(/^\//u, '');
+    // A document's 304 carries no media type to recognise it by, so its name has to.
+    if (/\.html?$/iu.test(path))
+        return false;
+    return addressed.includes(path);
 }
 function publicAsset(response, revision, addressed) {
     // Plain Views have an opaque sandbox origin. Their modules, CSS and fonts still need
@@ -55,11 +59,15 @@ function publicAsset(response, revision, addressed) {
     // would tell that browser to discard what it was just told to keep, so the next visit downloads
     // the file again and every revalidation costs a full transfer: worse than never caching at all.
     const validated = response.status === 304;
-    // Documents select hashed assets. Do not retain stale documents or transient asset misses.
-    if ((!response.ok && !validated) ||
-        response.headers.get('Content-Type')?.split(';')[0] === 'text/html') {
+    // Do not retain transient asset misses.
+    if (!response.ok && !validated) {
         readable.headers.set('Cache-Control', 'no-store');
     }
+    else if (response.headers.get('Content-Type')?.split(';')[0] === 'text/html') {
+        // Documents select hashed assets that a later Release removes, so a document is never used
+        // without asking first. Keeping it still lets that question be answered by a bodiless 304.
+        readable.headers.set('Cache-Control', 'no-cache');
+    }
     else if (addressed) {
         // The bytes behind this name can never change, so a revalidation could only ever confirm what
         // the name already states. `immutable` is deliberately absent: it would also suppress the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/adapter-cloudflare",
-  "version": "0.5.0-beta.158",
+  "version": "0.5.0-beta.159",
   "description": "Deploy an Astrale application through Cloudflare Workers",
   "keywords": [
     "adapter",
@@ -43,6 +43,10 @@
       "types": "./dist/worker/index.d.ts",
       "import": "./dist/worker/index.js"
     },
+    "./worker/front": {
+      "types": "./dist/worker/front.d.ts",
+      "import": "./dist/worker/front.js"
+    },
     "./release": {
       "types": "./dist/release/index.d.ts",
       "import": "./dist/release/index.js"
@@ -53,7 +57,7 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@astrale-os/sdk": "0.6.0-beta.3",
+    "@astrale-os/sdk": "0.6.0-beta.4",
     "@noble/hashes": "2.3.0",
     "hono": "^4.6.20",
     "jose": "^6.1.3",