@astrale-os/adapter-cloudflare 0.5.0-beta.155 → 0.5.0-beta.157

package/README.md

@@ -40,6 +40,25 @@ exact installed Release evidence, and opens
 the default View when the Application has a frontend. These are Project-tooling behaviors rather
 than Cloudflare adapter responsibilities.
 
+## Frontend files
+
+The Worker runs before Workers Static Assets on every request and owns frontend response headers
+and routing, for `cloudflare()` and `astrale()` deployments alike. Frontend preparation therefore
+refuses a built frontend whose root contains `_headers`, `_redirects`, or `.assetsignore`, in any
+letter case, as a file or a directory. Wrangler would apply them as asset configuration in a direct
+deployment, while a managed deployment would serve them as public files. The refusal happens while
+the artifact is prepared, before any provider change. Vite copies its public directory (`public/`
+by default) to that root: remove them there, or stop the plugin that emits them. The same names
+below the root, such as `docs/_headers`, remain ordinary files.
+
+The Worker is also the only server-side code, so preparation likewise refuses a root name starting
+with `_worker.js`, the name of a Cloudflare Pages worker script: a `_worker.js` file or directory,
+or a sibling such as `_worker.js.map`. Wrangler refuses to upload these as assets, since they may
+hold server-side code, so a direct deployment would fail at upload, while a managed deployment would
+publish them. Unlike the names above, the match is case-sensitive, as Wrangler's is: `_Worker.js`
+and a nested `docs/_worker.js` remain ordinary files. Remove such a file from the public directory,
+or rename it if it is a browser script.
+
 ## Provider-local staging
 
 Managed Cloudflare providers may stage immutable implementation candidates without exposing their

package/dist/build/frontend/files.js

@@ -2,6 +2,28 @@ import { frontend as frontendBuild } from '@astrale-os/sdk/deployment/build';
 import { readFile, readdir, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { buildViteFrontend } from './vite.js';
+/**
+ * Root names that Cloudflare Workers Static Assets reads as configuration rather than serving.
+ *
+ * Wrangler withholds them from a direct upload and applies them, while the managed upload through
+ * Services serves them as ordinary public files, so the same output would behave differently per
+ * adapter. The Worker runs first on every request and owns frontend response headers and routing for
+ * both, which leaves these files nothing to configure.
+ */
+const RESERVED_ROOT_NAMES = new Set([
+    '_headers',
+    '_redirects',
+    '.assetsignore',
+]);
+/**
+ * Name of a Cloudflare Pages worker script, the server-side code of a Pages project.
+ *
+ * Wrangler refuses to upload a root asset under this name, since that would publish the code, unless
+ * an `.assetsignore` exists, and the reserved names above already exclude one. A direct deployment
+ * would therefore fail at upload, while the managed upload through Services would publish the code.
+ * Neither adapter runs a Pages worker: the Worker is the only server-side code for both.
+ */
+const PAGES_WORKER_NAME = '_worker.js';
 export async function frontendFiles(input) {
     const frontend = input.frontend;
     if (frontend === undefined)
@@ -18,11 +40,50 @@ export async function frontendFiles(input) {
         signal: input.signal,
     });
     const files = frontendBuild.files(frontend, await readFiles(input.output));
+    refuseReservedNames(files);
+    refusePagesWorker(files);
     // A name the bundler reported but that never reached disk is not a served path; keeping only the
     // intersection means the evidence describes exactly what this deployment will answer with.
     const served = new Set(files.map((file) => file.path));
     return { files, addressed: built.addressed.filter((path) => served.has(path)) };
 }
+/**
+ * Refuse output that Cloudflare would read as asset configuration instead of serving it.
+ *
+ * Only the root is reserved: a nested `docs/_headers` stays an ordinary file. The match ignores case
+ * and covers directories, because Wrangler's upload filter withholds any root entry under these names
+ * regardless of case, and a case-insensitive filesystem hands it `_Headers` when it reads `_headers`.
+ */
+function refuseReservedNames(files) {
+    const reserved = new Set(files
+        .map((file) => file.path.split('/')[0])
+        .filter((name) => RESERVED_ROOT_NAMES.has(name.toLowerCase())));
+    if (reserved.size === 0)
+        return;
+    const names = [...reserved].join(', ');
+    throw new TypeError(`Frontend output contains reserved Cloudflare asset configuration name(s) at its root: ${names}. ` +
+        'A direct cloudflare() deployment would apply them as Workers Static Assets configuration, while a managed astrale() deployment would serve them as public files. ' +
+        'The Worker owns frontend response headers and routing for both adapters: remove them from the Vite public directory, or stop the build from emitting them.');
+}
+/**
+ * Refuse output that Wrangler would decline to upload as a Cloudflare Pages worker script.
+ *
+ * Wrangler tests the relative path with a plain `startsWith`, not through its case-insensitive upload
+ * filter, so the match here is a case-sensitive prefix of the root name too. It covers a `_worker.js`
+ * file or directory and siblings such as `_worker.js.map`, which Wrangler refuses alike, while both
+ * adapters serve `_Worker.js` or a nested `docs/_worker.js` as an ordinary file.
+ */
+function refusePagesWorker(files) {
+    const workers = new Set(files
+        .map((file) => file.path.split('/')[0])
+        .filter((name) => name.startsWith(PAGES_WORKER_NAME)));
+    if (workers.size === 0)
+        return;
+    const names = [...workers].join(', ');
+    throw new TypeError(`Frontend output contains Cloudflare Pages worker name(s) at its root: ${names}. ` +
+        `A direct cloudflare() deployment would fail because Wrangler refuses to upload a root name starting with ${PAGES_WORKER_NAME} as possible server-side code, while a managed astrale() deployment would serve them as public files. ` +
+        'The Worker is the only server-side code for both adapters: remove or rename them in the Vite public directory, or stop the build from emitting them.');
+}
 async function readFiles(root, current = '') {
     const entries = await readdir(join(root, current), { withFileTypes: true });
     const files = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/adapter-cloudflare",
-  "version": "0.5.0-beta.155",
+  "version": "0.5.0-beta.157",
   "description": "Deploy an Astrale application through Cloudflare Workers",
   "keywords": [
     "adapter",
@@ -53,7 +53,7 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@astrale-os/sdk": "0.6.0-beta.0",
+    "@astrale-os/sdk": "0.6.0-beta.2",
     "@noble/hashes": "2.3.0",
     "hono": "^4.6.20",
     "jose": "^6.1.3",