@astrale-os/adapter-cloudflare 0.5.0-beta.35 → 0.5.0-beta.37

package/dist/build/artifact.js

@@ -57,7 +57,7 @@ async function prepare(params, context, direct) {
         main: `./${RELEASE_ENTRY}`,
         vars: runtimeVars(params, configuredIssuer),
         secretBindings: [SIGNING_IDENTITY_BINDING],
-        modules: { baseDir: '.', globs: [RELEASE_SERVICE] },
+        modules: { baseDir: './bundle', globs: ['service.mjs'] },
         ...(context.build.frontend?.source.kind === 'vite'
             ? {
                 frontend: {
@@ -121,6 +121,7 @@ async function prepare(params, context, direct) {
                     }),
                     notFound: 'none',
                     runWorkerFirst: true,
+                    htmlHandling: 'none',
                 },
             }),
     });

package/dist/build/codegen/wrangler.js

@@ -31,6 +31,7 @@ export function generateWranglerConfig(opts) {
         config.assets = {
             directory: opts.frontend.directory,
             binding: 'ASSETS',
+            html_handling: 'none',
             run_worker_first: opts.frontend.dev
                 ? true
                 : [

package/dist/build/configuration/request-limit.d.ts

@@ -0,0 +1,2 @@
+import type { CloudflareParams } from '../../params.js';
+export declare function workerRequestLimit(value: CloudflareParams['maximumRequestBytes']): number | undefined;

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

@@ -0,0 +1,9 @@
+const MAXIMUM_REQUEST_BYTES = 16 * 1024 * 1024;
+export function workerRequestLimit(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isSafeInteger(value) || value <= 0 || value > MAXIMUM_REQUEST_BYTES) {
+        throw new TypeError('Cloudflare maximumRequestBytes must be a positive integer at most 16 MiB.');
+    }
+    return value;
+}

package/dist/build/configuration.d.ts

@@ -1,3 +1,4 @@
 export { deploymentAddressing } from './configuration/addressing.js';
+export { workerRequestLimit } from './configuration/request-limit.js';
 export { resolveRouter } from './configuration/router.js';
 export { workerName } from './configuration/worker-name.js';

package/dist/build/configuration.js

@@ -1,3 +1,4 @@
 export { deploymentAddressing } from './configuration/addressing.js';
+export { workerRequestLimit } from './configuration/request-limit.js';
 export { resolveRouter } from './configuration/router.js';
 export { workerName } from './configuration/worker-name.js';

package/dist/build/direct.js

@@ -1,30 +1,70 @@
+import { posix } from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
 import { releaseNamespace, releaseWorkerName } from '../release/index.js';
-import { workerName } from './configuration.js';
+import { generateWranglerConfig } from './codegen/wrangler.js';
+import { resolveRouter, workerName } from './configuration.js';
+import { frontendRoutes } from './frontend/routes.js';
 export function admitDirectPlacement(artifact, worker, parameters) {
     const name = workerName(parameters, worker.origin);
     const release = config(artifact, 'wrangler.release.jsonc');
     const gateway = config(artifact, 'wrangler.gateway.jsonc');
-    equal(release.name, releaseWorkerName(worker.revision));
-    equal(release.main, `./${worker.release.entrypoint}`);
+    const directory = posix.dirname(worker.release.entrypoint);
+    const router = resolveRouter(parameters.router);
+    const frontend = artifact.build.frontend;
+    const hasViteFrontend = frontend?.source.kind === 'vite';
+    equal(worker.assets !== undefined, hasViteFrontend);
+    if (worker.assets !== undefined) {
+        equal(worker.assets.notFound, 'none');
+        equal(worker.assets.runWorkerFirst, true);
+    }
+    equal(release, generated({
+        workerName: releaseWorkerName(worker.revision),
+        main: `./${worker.release.entrypoint}`,
+        vars: worker.bindings.vars,
+        secretBindings: worker.bindings.requiredSecrets,
+        modules: {
+            baseDir: `./${directory}`,
+            globs: moduleGlobs(worker, directory),
+        },
+        ...(hasViteFrontend
+            ? {
+                frontend: {
+                    directory: './frontend',
+                    routes: frontendRoutes(frontend),
+                    dev: false,
+                },
+            }
+            : {}),
+        ...(router === undefined
+            ? {}
+            : { router: { binding: router.binding, service: router.service } }),
+        ...(parameters.wrangler === undefined ? {} : { wrangler: parameters.wrangler }),
+        selfBinding: false,
+    }));
     equal(release.compatibility_date, worker.runtime.compatibilityDate);
     equal(release.compatibility_flags, worker.runtime.compatibilityFlags);
-    equal(release.vars ?? {}, worker.bindings.vars);
-    equal(release.services ?? [], worker.bindings.services.map((binding) => ({
-        binding: binding.name,
-        service: binding.service,
-    })));
-    equal(record(release.secrets).required ?? [], worker.bindings.requiredSecrets);
-    const rules = Array.isArray(release.rules) ? release.rules : [];
-    equal(rules.flatMap((rule) => {
-        const globs = record(rule).globs;
-        return Array.isArray(globs) ? globs : [];
-    }), worker.release.modules
+    equal(release.services ?? [], worker.bindings.services.map(serviceBinding));
+    equal(record(release.assets).html_handling, worker.assets?.htmlHandling);
+    equal(gateway, generated({
+        workerName: name,
+        main: `./${worker.gateway.entrypoint}`,
+        ...(parameters.route === undefined ? {} : { route: parameters.route }),
+        releases: { binding: 'RELEASES', namespace: releaseNamespace(name) },
+        selfBinding: false,
+    }));
+}
+function moduleGlobs(worker, directory) {
+    return worker.release.modules
         .filter((module) => module.path !== worker.release.entrypoint)
-        .map((module) => module.path));
-    equal(gateway.name, name);
-    equal(gateway.main, `./${worker.gateway.entrypoint}`);
-    equal(gateway.dispatch_namespaces, [{ binding: 'RELEASES', namespace: releaseNamespace(name) }]);
+        .map((module) => {
+        const relative = posix.relative(directory, module.path);
+        if (relative === '' || relative === '..' || relative.startsWith('../'))
+            mismatch();
+        return relative;
+    });
+}
+function generated(input) {
+    return JSON.parse(generateWranglerConfig(input));
 }
 function config(artifact, path) {
     const file = artifact.files.find((candidate) => candidate.path === path);
@@ -40,13 +80,18 @@ function config(artifact, path) {
         throw new TypeError(`Direct Cloudflare artifact ${path} is invalid.`, { cause });
     }
 }
+function serviceBinding(binding) {
+    return { binding: binding.name, service: binding.service };
+}
 function record(input) {
     return input !== null && typeof input === 'object' && !Array.isArray(input)
         ? input
         : {};
 }
 function equal(actual, expected) {
-    if (!isDeepStrictEqual(actual, expected)) {
-        throw new TypeError('Direct Cloudflare placement differs from its admitted Worker artifact.');
-    }
+    if (!isDeepStrictEqual(actual, expected))
+        mismatch();
+}
+function mismatch() {
+    throw new TypeError('Direct Cloudflare placement differs from its admitted Worker artifact.');
 }

package/dist/build/gateway/prepare.js

@@ -3,11 +3,12 @@ import { dirname, join } from 'node:path';
 import { admitWorkerBundle } from '../bundle/admit.js';
 import { generateWranglerConfig } from '../codegen/wrangler.js';
 import { qualifyWorkerBundle } from '../qualification.js';
+import { workerModuleSpecifier } from '../worker/specifier.js';
 import { runWranglerBundle } from '../wrangler-cli.js';
 import { generateGatewayEntry } from './source.js';
 export async function prepareGateway(input) {
     const gatewaySource = join(input.directory, 'gateway.gen.ts');
-    await writeFile(gatewaySource, generateGatewayEntry(input.revision));
+    await writeFile(gatewaySource, generateGatewayEntry(input.revision, workerModuleSpecifier()));
     const configPath = join(input.directory, 'wrangler.gateway.prepare.jsonc');
     await writeFile(configPath, generateWranglerConfig({
         workerName: input.name,

package/dist/build/gateway/source.d.ts

@@ -1 +1 @@
-export declare function generateGatewayEntry(revision: string): string;
+export declare function generateGatewayEntry(revision: string, workerSpecifier?: string): string;

package/dist/build/gateway/source.js

@@ -1,6 +1,6 @@
-export function generateGatewayEntry(revision) {
+export function generateGatewayEntry(revision, workerSpecifier = '@astrale-os/adapter-cloudflare/worker') {
     return `// AUTO-GENERATED by @astrale-os/adapter-cloudflare — do not edit.
-import { cloudflareGatewayEntry } from '@astrale-os/adapter-cloudflare/worker'
+import { cloudflareGatewayEntry } from ${JSON.stringify(workerSpecifier)}
 
 export default cloudflareGatewayEntry({ current: ${JSON.stringify(revision)} })
 `;

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

@@ -34,5 +34,6 @@ export interface WorkerArtifact {
         }[];
         readonly notFound: 'none' | '404-page' | 'single-page-application';
         readonly runWorkerFirst: boolean;
+        readonly htmlHandling?: 'none';
     };
 }

package/dist/build/worker/artifact.load.js

@@ -60,6 +60,9 @@ export function loadWorkerArtifact(artifact) {
                     files: Object.freeze(assets),
                     notFound: manifest.assets.notFound,
                     runWorkerFirst: manifest.assets.runWorkerFirst,
+                    ...(manifest.assets.htmlHandling === undefined
+                        ? {}
+                        : { htmlHandling: manifest.assets.htmlHandling }),
                 }),
             }),
     });
@@ -175,10 +178,11 @@ function admitServices(input) {
     return Object.freeze(services);
 }
 function admitAssets(input) {
-    const value = record(input, ['files', 'notFound', 'runWorkerFirst']);
+    const value = record(input, ['files', 'notFound', 'runWorkerFirst', 'htmlHandling']);
     if (!Array.isArray(value.files) ||
         !['none', '404-page', 'single-page-application'].includes(String(value.notFound)) ||
-        typeof value.runWorkerFirst !== 'boolean')
+        typeof value.runWorkerFirst !== 'boolean' ||
+        (value.htmlHandling !== undefined && value.htmlHandling !== 'none'))
         invalid();
     const paths = new Set();
     const files = value.files.map((input) => {
@@ -206,6 +210,7 @@ function admitAssets(input) {
         files: Object.freeze(files),
         notFound: value.notFound,
         runWorkerFirst: value.runWorkerFirst,
+        ...(value.htmlHandling === undefined ? {} : { htmlHandling: 'none' }),
     });
 }
 function record(input, allowed) {

package/dist/build/worker/artifact.manifest.d.ts

@@ -30,6 +30,7 @@ export interface WorkerArtifactManifestV1 {
         }[];
         readonly notFound: 'none' | '404-page' | 'single-page-application';
         readonly runWorkerFirst: boolean;
+        readonly htmlHandling?: 'none';
     };
 }
 interface ManifestExecutable {

package/dist/build/worker/artifact.manifest.js

@@ -34,6 +34,9 @@ export function encodeWorkerArtifactManifest(input) {
                         .sort((a, b) => comparePath(a.path, b.path))),
                     notFound: input.assets.notFound,
                     runWorkerFirst: input.assets.runWorkerFirst,
+                    ...(input.assets.htmlHandling === undefined
+                        ? {}
+                        : { htmlHandling: input.assets.htmlHandling }),
                 },
             }),
     };

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

@@ -1,2 +1,2 @@
 /** Generate the isolate-startup entry that realizes the heavy Service on first request. */
-export declare function generateExecutionEntry(serviceSpecifier: string): string;
+export declare function generateExecutionEntry(serviceSpecifier: string, workerSpecifier?: string): string;

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

@@ -1,7 +1,7 @@
 /** Generate the isolate-startup entry that realizes the heavy Service on first request. */
-export function generateExecutionEntry(serviceSpecifier) {
+export function generateExecutionEntry(serviceSpecifier, workerSpecifier = '@astrale-os/adapter-cloudflare/worker') {
     return `// AUTO-GENERATED by @astrale-os/adapter-cloudflare — do not edit.
-import type { CloudflareWorker } from '@astrale-os/adapter-cloudflare/worker'
+import type { CloudflareWorker } from ${JSON.stringify(workerSpecifier)}
 
 const SERVICE_SPECIFIER = ${JSON.stringify(serviceSpecifier)}
 let servicePromise: Promise<CloudflareWorker<CloudflareEnv>> | undefined

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

@@ -2,7 +2,9 @@ import type { BuildMaterial } from '@astrale-os/sdk/deployment/build';
 export interface ExecutionCodegenOptions {
     readonly origin: string;
     readonly runtimeSpecifier: string;
+    readonly workerSpecifier?: string;
     readonly material: BuildMaterial;
+    readonly maximumRequestBytes?: number;
     readonly providerAssignedWorker?: string;
     readonly router?: {
         readonly binding: string;

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

@@ -1,4 +1,5 @@
 export function generateExecutionService(options) {
+    const workerSpecifier = options.workerSpecifier ?? '@astrale-os/adapter-cloudflare/worker';
     const router = options.router;
     const routerPredicate = router === undefined
         ? ''
@@ -19,10 +20,10 @@ function isInstanceHost(host: string): boolean {
     return `// AUTO-GENERATED by @astrale-os/adapter-cloudflare — do not edit.
 // Domain origin: ${options.origin}
 import type { BuildMaterial } from '@astrale-os/sdk/deployment/build'
-import type { CloudflareAdapterBindings } from '@astrale-os/adapter-cloudflare/worker'
+import type { CloudflareAdapterBindings } from ${JSON.stringify(workerSpecifier)}
 
-import { cloudflareWorkerEntry } from '@astrale-os/adapter-cloudflare/worker'
-import { decodeSigningIdentity, runtimeBindings } from '@astrale-os/adapter-cloudflare/worker'
+import { cloudflareWorkerEntry } from ${JSON.stringify(workerSpecifier)}
+import { decodeSigningIdentity, runtimeBindings } from ${JSON.stringify(workerSpecifier)}
 
 type WorkerEnv = CloudflareEnv & CloudflareAdapterBindings & {
   readonly ASTRALE_SIGNING_IDENTITY: string
@@ -37,6 +38,7 @@ export default cloudflareWorkerEntry<WorkerEnv, RuntimeEnv>()({
   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.providerAssignedWorker === undefined ? '' : `providerAssignedWorker: ${JSON.stringify(options.providerAssignedWorker)},`}
   selfBinding: (env) => env.SELF,${routeSubrequest}
 })

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

@@ -5,17 +5,23 @@ import { SIGNING_IDENTITY_BINDING } from '../../identity/binding.js';
 import { admitWorkerBundle } from '../bundle/admit.js';
 import { generateExecutionEntry, generateExecutionService } from '../codegen/execution.js';
 import { generateWranglerConfig } from '../codegen/wrangler.js';
+import { workerRequestLimit } from '../configuration.js';
 import { qualifyWorkerBundle } from '../qualification.js';
 import { runWranglerBundle } from '../wrangler-cli.js';
+import { workerModuleSpecifier } from './specifier.js';
 export const RELEASE_ENTRY = 'bundle/index.mjs';
 export const RELEASE_SERVICE = 'bundle/service.mjs';
 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 serviceSource = generateExecutionService({
         origin: input.context.build.schema.compiled.root.origin,
         runtimeSpecifier,
+        workerSpecifier,
         material: material(input.context.build),
+        ...(maximumRequestBytes === undefined ? {} : { maximumRequestBytes }),
         ...(input.configuredIssuer === undefined && input.direct
             ? { providerAssignedWorker: input.name }
             : {}),
@@ -59,7 +65,7 @@ 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(`./${RELEASE_SERVICE}`));
+    await writeFile(sourcePath, generateExecutionEntry('./service.mjs', workerSpecifier));
     const configPath = join(input.directory, 'wrangler.prepare.jsonc');
     await writeFile(configPath, generateWranglerConfig({
         workerName: input.name,

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

@@ -0,0 +1 @@
+export declare function workerModuleSpecifier(): string;

package/dist/build/worker/specifier.js

@@ -0,0 +1,5 @@
+import { fileURLToPath } from 'node:url';
+const workerModule = import.meta.resolve('@astrale-os/adapter-cloudflare/worker');
+export function workerModuleSpecifier() {
+    return fileURLToPath(workerModule);
+}

package/dist/params.d.ts

@@ -50,6 +50,12 @@ export interface CloudflareParams {
     readonly remote?: boolean;
     /** Extra plain (non-secret) vars to inject as Worker vars. */
     readonly vars?: Record<string, string>;
+    /**
+     * Maximum encoded invocation request bytes retained by the Worker Server.
+     * Defaults to 1 MiB and is capped at 16 MiB. Increase only from measured
+     * application traffic; Publication and Bundle delivery have separate limits.
+     */
+    readonly maximumRequestBytes?: number;
     /**
      * Escape hatch: raw wrangler config deep-merged over the generated base. Use
      * it to declare extra bindings the adapter has no typed field for — KV, R2,

package/dist/worker/entry.d.ts

@@ -26,6 +26,7 @@ export interface CloudflareWorkerConfig<RuntimeValue extends Runtime, Bindings e
     readonly selfBinding?: (bindings: Bindings) => Fetcher | null | undefined;
     readonly routeSubrequest?: (url: URL, bindings: Bindings) => Fetcher | null | undefined;
     readonly invocationTimeoutMs?: number;
+    readonly maximumRequestBytes?: number;
 }
 export interface CloudflareWorkerSource<RuntimeValue extends Runtime> {
     readonly runtime: RuntimeValue;

package/dist/worker/entry.js

@@ -42,7 +42,7 @@ export function cloudflareWorkerEntry() {
                     server: {
                         health: { probe: { check: () => true } },
                         limits: {
-                            maximumRequestBytes: 1024 * 1024,
+                            maximumRequestBytes: config.maximumRequestBytes ?? 1024 * 1024,
                             maximumPublicationBytes: 1024 * 1024,
                             maximumBundleBytes: 8 * 1024 * 1024,
                             maximumDeliveryBytes: 8 * 1024 * 1024,
@@ -106,21 +106,22 @@ async function frontendAsset(frontend, environment, url, request) {
     if (development !== undefined && development.length > 0) {
         return fetch(new Request(new URL(`${url.pathname}${url.search}`, `${development}/`), request));
     }
-    const route = frontend.routes
-        .filter((candidate) => candidate.path === url.pathname ||
-        (frontend.source.kind === 'vite' &&
-            frontend.source.spa &&
-            (candidate.path === '/' || url.pathname.startsWith(`${candidate.path}/`))))
-        .sort((left, right) => right.path.length - left.path.length)[0];
-    if (route === undefined && !url.pathname.startsWith('/assets/'))
+    const assetPath = url.pathname.startsWith('/assets/');
+    const route = assetPath
+        ? undefined
+        : frontend.routes
+            .filter((candidate) => candidate.path === url.pathname ||
+            (frontend.source.kind === 'vite' &&
+                frontend.source.spa &&
+                (candidate.path === '/' || url.pathname.startsWith(`${candidate.path}/`))))
+            .sort((left, right) => right.path.length - left.path.length)[0];
+    if (route === undefined && !assetPath)
         return undefined;
     const assets = environment.ASSETS;
     if (assets === undefined)
         return undefined;
-    const response = await assets.fetch(request);
-    if (response.status !== 404 || route === undefined)
-        return response;
-    await response.body?.cancel();
+    if (route === undefined)
+        return assets.fetch(request);
     return assets.fetch(new Request(new URL(`/${route.document}${url.search}`, url.origin), request));
 }
 function reserved(path) {

package/dist/worker/gateway.js

@@ -22,5 +22,5 @@ export function cloudflareGatewayEntry(config) {
 }
 /** Admit only Cloudflare's documented missing-script failure at the provider boundary. */
 function isMissingWorker(cause) {
-    return cause instanceof Error && /^Worker not found(?:: [^\r\n]+)?$/iu.test(cause.message);
+    return cause instanceof Error && /^Worker not found(?:: [^\r\n]+|\.)?$/u.test(cause.message);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/adapter-cloudflare",
-  "version": "0.5.0-beta.35",
+  "version": "0.5.0-beta.37",
   "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.32"
+    "@astrale-os/sdk": "^0.5.0-beta.34"
   },
   "devDependencies": {
     "@astrale-os/ox": ">=0.1.0 <1.0.0",