@astrojs/cloudflare 7.2.0 → 7.3.1

package/README.md

@@ -25,77 +25,208 @@ npm install @astrojs/cloudflare
 
 2. Add the following to your `astro.config.mjs` file:
 
-```js ins={3, 6-7}
-// astro.config.mjs
-import { defineConfig } from 'astro/config';
-import cloudflare from '@astrojs/cloudflare';
-
-export default defineConfig({
-  output: 'server',
-  adapter: cloudflare(),
-});
+```diff lang="js"
+  // astro.config.mjs
+  import { defineConfig } from 'astro/config';
++ import cloudflare from '@astrojs/cloudflare';
+
+  export default defineConfig({
++   output: 'server',
++   adapter: cloudflare(),
+  });
 ```
 
 ## Options
 
-### Mode
+### `mode`
 
 `mode: "advanced" | "directory"`
 
 default `"advanced"`
 
-Cloudflare Pages has 2 different modes for deploying functions, `advanced` mode which picks up the `_worker.js` in `dist`, or a directory mode where pages will compile the worker out of a functions folder in the project root. For most projects the adapter default of `advanced` will be sufficient; the `dist` folder will contain your compiled project.
+This configuration option defines how your Astro project is deployed to Cloudflare Pages.
 
-#### `mode:directory`
+- `advanced` mode picks up the `_worker.js` file in the `dist` folder
+- `directory` mode picks up the files in the `functions` folder, by default only one `[[path]].js` file is generated
 
-Switching to directory mode allows you to use [pages plugins](https://developers.cloudflare.com/pages/platform/functions/plugins/) such as [Sentry](https://developers.cloudflare.com/pages/platform/functions/plugins/sentry/) or write custom code to enable logging.
+Switching to directory mode allows you to add additional files manually such as [Cloudflare Pages Plugins](https://developers.cloudflare.com/pages/platform/functions/plugins/), [Cloudflare Pages Middleware](https://developers.cloudflare.com/pages/platform/functions/middleware/) or custom functions using [Cloudflare Pages Functions Routing](https://developers.cloudflare.com/pages/platform/functions/routing/).
 
-```ts
+```js
 // astro.config.mjs
 export default defineConfig({
   adapter: cloudflare({ mode: 'directory' }),
 });
 ```
 
-In `directory` mode, the adapter will compile the client-side part of your app the same way as in `advanced` mode by default, but moves the worker script into a `functions` folder in the project root. In this case, the adapter will only ever place a `[[path]].js` in that folder, allowing you to add additional plugins and pages middleware which can be checked into version control.
+To compile a separate bundle for each page, set the `functionPerRoute` option in your Cloudflare adapter config. This option requires some manual maintenance of the `functions` folder. Files emitted by Astro will overwrite existing files with identical names in the `functions` folder, so you must choose unique file names for each file you manually add. Additionally, the adapter will never empty the `functions` folder of outdated files, so you must clean up the folder manually when you remove pages.
+
+```diff lang="js"
+  // astro.config.mjs
+  import {defineConfig} from "astro/config";
+  import cloudflare from '@astrojs/cloudflare';
+
+  export default defineConfig({
+    adapter: cloudflare({
+      mode: 'directory',
++     functionPerRoute: true
+    })
+  })
+```
+
+This adapter doesn't support the [`edgeMiddleware`](https://docs.astro.build/en/reference/adapter-reference/#edgemiddleware) option.
+
+### `routes.strategy`
+
+`routes.strategy: "auto" | "include" | "exclude"`
+
+default `"auto"`
+
+Determines how `routes.json` will be generated if no [custom `_routes.json`](#custom-_routesjson) is provided.
+
+There are three options available:
+
+- **`"auto"` (default):** Will automatically select the strategy that generates the fewest entries. This should almost always be sufficient, so choose this option unless you have a specific reason not to.
+
+- **`include`:** Pages and endpoints that are not pre-rendered are listed as `include` entries, telling Cloudflare to invoke these routes as functions. `exclude` entries are only used to resolve conflicts. Usually the best strategy when your website has mostly static pages and only a few dynamic pages or endpoints.
+
+  Example: For `src/pages/index.astro` (static), `src/pages/company.astro` (static), `src/pages/users/faq.astro` (static) and `/src/pages/users/[id].astro` (SSR) this will produce the following `_routes.json`:
+
+  ```json
+  {
+    "version": 1,
+    "include": [
+      "/_image", // Astro's image endpoint
+      "/users/*" // Dynamic route
+    ],
+    "exclude": [
+      // Static routes that needs to be exempted from the dynamic wildcard route above
+      "/users/faq/",
+      "/users/faq/index.html"
+    ]
+  }
+  ```
+
+- **`exclude`:** Pre-rendered pages are listed as `exclude` entries (telling Cloudflare to handle these routes as static assets). Usually the best strategy when your website has mostly dynamic pages or endpoints and only a few static pages.
+
+  Example: For the same pages as in the previous example this will produce the following `_routes.json`:
+
+  ```json
+  {
+    "version": 1,
+    "include": [
+      "/*" // Handle everything as function except the routes below
+    ],
+    "exclude": [
+      // All static assets
+      "/",
+      "/company/",
+      "/index.html",
+      "/users/faq/",
+      "/favicon.png",
+      "/company/index.html",
+      "/users/faq/index.html"
+    ]
+  }
+  ```
+
+### `routes.include`
+
+`routes.include: string[]`
+
+default `[]`
+
+If you want to use the automatic `_routes.json` generation, but want to include additional routes (e.g. when having custom functions in the `functions` folder), you can use the `routes.include` option to add additional routes to the `include` array.
+
+### `routes.exclude`
+
+`routes.exclude: string[]`
+
+default `[]`
+
+If you want to use the automatic `_routes.json` generation, but want to exclude additional routes, you can use the `routes.exclude` option to add additional routes to the `exclude` array.
+
+The following example automatically generates `_routes.json` while including and excluding additional routes. Note that that is only necessary if you have custom functions in the `functions` folder that are not handled by Astro.
+
+```diff lang="js"
+  // astro.config.mjs
+  export default defineConfig({
+    adapter: cloudflare({
+      mode: 'directory',
++     routes: {
++       strategy: 'include',
++       include: ['/users/*'], // handled by custom function: functions/users/[id].js
++       exclude: ['/users/faq'], // handled by static page: pages/users/faq.astro
++     },
+    }),
+  });
+```
+
+### `wasmModuleImports`
+
+`wasmModuleImports: boolean`
+
+default: `false`
 
-To instead compile a separate bundle for each page, set the `functionPerPath` option in your Cloudflare adapter config. This option requires some manual maintenance of the `functions` folder. Files emitted by Astro will overwrite existing `functions` files with identical names, so you must choose unique file names for each file you manually add. Additionally, the adapter will never empty the `functions` folder of outdated files, so you must clean up the folder manually when you remove pages.
+Whether or not to import `.wasm` files [directly as ES modules](https://github.com/WebAssembly/esm-integration/tree/main/proposals/esm-integration) using the `.wasm?module` import syntax.
 
-```diff
+Add `wasmModuleImports: true` to `astro.config.mjs` to enable this functionality in both the Cloudflare build and the Astro dev server. [Read more](#use-wasm-modules)
+
+```diff lang="js"
+// astro.config.mjs
 import {defineConfig} from "astro/config";
 import cloudflare from '@astrojs/cloudflare';
 
 export default defineConfig({
-     adapter: cloudflare({
-        mode: 'directory',
-+       functionPerRoute: true
-    })
+    adapter: cloudflare({
++      wasmModuleImports: true
+    }),
+    output: 'server'
 })
 ```
 
-Note that this adapter does not support using [Cloudflare Pages Middleware](https://developers.cloudflare.com/pages/platform/functions/middleware/). Astro will bundle the [Astro middleware](https://docs.astro.build/en/guides/middleware/) into each page.
+### `runtime`
 
-## Enabling Preview
+`runtime: "off" | "local" | "remote"`
 
-In order for preview to work you must install `wrangler`
+default `"off"`
 
-```sh
-pnpm install wrangler --save-dev
-```
+Determines whether and how the Cloudflare Runtime is added to `astro dev`.
+
+The Cloudflare Runtime includes [Cloudflare bindings](https://developers.cloudflare.com/pages/platform/functions/bindings), [environment variables](https://developers.cloudflare.com/pages/platform/functions/bindings/#environment-variables), and the [cf object](https://developers.cloudflare.com/workers/runtime-apis/request/#incomingrequestcfproperties). Read more about [accessing the Cloudflare Runtime](#access-to-the-cloudflare-runtime).
+
+- `local`: uses bindings mocking and locally static placeholdes
+- `remote`: uses remote bindings and a live fetched cf object
+- `off`: no access to the Cloudflare runtime using `astro dev`. You can alternatively use [Preview with Wrangler](#preview-with-wrangler)
 
-It's then possible to update the preview script in your `package.json` to `"preview": "wrangler pages dev ./dist"`. This will allow you to run your entire application locally with [Wrangler](https://github.com/cloudflare/wrangler2), which supports secrets, environment variables, KV namespaces, Durable Objects and [all other supported Cloudflare bindings](https://developers.cloudflare.com/pages/platform/functions/#adding-bindings).
+```diff lang="js"
+// astro.config.mjs
+import { defineConfig } from 'astro/config';
+import cloudflare from '@astrojs/cloudflare';
+
+export default defineConfig({
+  output: 'server',
+  adapter: cloudflare({
++   runtime: 'local',
+  }),
+});
+```
 
-## Access to the Cloudflare runtime
+## Cloudflare runtime
 
-You can access all the Cloudflare bindings and environment variables from Astro components and API routes through `Astro.locals`.
+Gives you access to [environment variables](https://developers.cloudflare.com/pages/platform/functions/bindings/#environment-variables).
 
-If you're inside an `.astro` file, you access the runtime using the `Astro.locals` global:
+You can access the runtime from Astro components through `Astro.locals` inside any .astro` file.
 
 ```astro
-const env = Astro.locals.runtime.env;
+---
+// src/pages/index.astro
+const runtime = Astro.locals.runtime;
+---
+
+<pre>{JSON.stringify(runtime.env)}</pre>
 ```
 
-From an endpoint:
+You can access the runtime from API endpoints through `context.locals`:
 
 ```js
 // src/pages/api/someFile.js
@@ -106,21 +237,24 @@ export function GET(context) {
 }
 ```
 
-Depending on your adapter mode (advanced = worker, directory = pages), the runtime object will look a little different due to differences in the Cloudflare API.
+### Typing
 
-If you're using the `advanced` runtime, you can type the `runtime` object as following:
+If you have configured `mode: advanced`, you can type the `runtime` object using `AdvancedRuntime`:
 
 ```ts
 // src/env.d.ts
 /// <reference types="astro/client" />
-import type { AdvancedRuntime } from '@astrojs/cloudflare';
 
+type KVNamespace = import('@cloudflare/workers-types/experimental').KVNamespace;
 type ENV = {
   SERVER_URL: string;
+  KV_BINDING: KVNamespace;
 };
 
+type Runtime = import('@astrojs/cloudflare').AdvancedRuntime<ENV>;
+
 declare namespace App {
-  interface Locals extends AdvancedRuntime<ENV> {
+  interface Locals extends Runtime {
     user: {
       name: string;
       surname: string;
@@ -129,19 +263,22 @@ declare namespace App {
 }
 ```
 
-If you're using the `directory` runtime, you can type the `runtime` object as following:
+If you have configured `mode: directory`, you can type the `runtime` object using `DirectoryRuntime`:
 
 ```ts
 // src/env.d.ts
 /// <reference types="astro/client" />
-import type { DirectoryRuntime } from '@astrojs/cloudflare';
 
+type KVNamespace = import('@cloudflare/workers-types/experimental').KVNamespace;
 type ENV = {
   SERVER_URL: string;
+  KV_BINDING: KVNamespace;
 };
 
+type Runtime = import('@astrojs/cloudflare').DirectoryRuntime<ENV>;
+
 declare namespace App {
-  interface Locals extends DirectoryRuntime<ENV> {
+  interface Locals extends Runtime {
     user: {
       name: string;
       surname: string;
@@ -150,57 +287,44 @@ declare namespace App {
 }
 ```
 
-### Environment Variables
+## Platform
 
-See Cloudflare's documentation for [working with environment variables](https://developers.cloudflare.com/pages/platform/functions/bindings/#environment-variables).
+### Headers
 
-```js
-// pages/[id].json.js
-
-export function GET({ params }) {
-  // Access environment variables per request inside a function
-  const serverUrl = import.meta.env.SERVER_URL;
-  const result = await fetch(serverUrl + "/user/" + params.id);
-  return {
-    body: await result.text(),
-  };
-}
-```
+You can attach [custom headers](https://developers.cloudflare.com/pages/platform/headers/) to your responses by adding a `_headers` file in your Astro project's `public/` folder. This file will be copied to your build output directory.
 
-### `cloudflare.runtime`
+### Redirects
 
-`runtime: "off" | "local" | "remote"`
-default `"off"`
+You can declare [custom redirects](https://developers.cloudflare.com/pages/platform/redirects/) using Cloudflare Pages. This allows you to redirect requests to a different URL. You can add a `_redirects` file in your Astro project's `public/` folder. This file will be copied to your build output directory.
 
-This optional flag enables the Astro dev server to populate environment variables and the Cloudflare Request Object, avoiding the need for Wrangler.
+### Routes
 
-- `local`: environment variables are available, but the request object is populated from a static placeholder value.
-- `remote`: environment variables and the live, fetched request object are available.
-- `off`: the Astro dev server will populate neither environment variables nor the request object. Use Wrangler to access Cloudflare bindings and environment variables.
+You can define which routes are invoking functions and which are static assets, using [Cloudflare routing](https://developers.cloudflare.com/pages/platform/functions/routing/#functions-invocation-routes) via a `_routes.json` file. This file is automatically generated by Astro.
 
-```js
-// astro.config.mjs
-import { defineConfig } from 'astro/config';
-import cloudflare from '@astrojs/cloudflare';
+#### Custom `_routes.json`
 
-export default defineConfig({
-  output: 'server',
-  adapter: cloudflare({
-    runtime: 'off' | 'local' | 'remote',
-  }),
-});
-```
+By default, `@astrojs/cloudflare` will generate a `_routes.json` file with `include` and `exclude` rules based on your applications's dynamic and static routes.
+This will enable Cloudflare to serve files and process static redirects without a function invocation. Creating a custom `_routes.json` will override this automatic optimization. See [Cloudflare's documentation on creating a custom `routes.json`](https://developers.cloudflare.com/pages/platform/functions/routing/#create-a-_routesjson-file) for more details.
+
+## Use Wasm modules
 
-## Headers, Redirects and function invocation routes
+The following is an example of importing a Wasm module that then responds to requests by adding the request's number parameters together.
 
-Cloudflare has support for adding custom [headers](https://developers.cloudflare.com/pages/platform/headers/), configuring static [redirects](https://developers.cloudflare.com/pages/platform/redirects/) and defining which routes should [invoke functions](https://developers.cloudflare.com/pages/platform/functions/routing/#function-invocation-routes). Cloudflare looks for `_headers`, `_redirects`, and `_routes.json` files in your build output directory to configure these features. This means they should be placed in your Astro project’s `public/` directory.
+```js
+// pages/add/[a]/[b].js
+import mod from '../util/add.wasm?module';
 
-### Custom `_routes.json`
+// instantiate ahead of time to share module
+const addModule: any = new WebAssembly.Instance(mod);
 
-By default, `@astrojs/cloudflare` will generate a `_routes.json` file with `include` and `exclude` rules based on your applications's dynamic and static routes.
-This will enable Cloudflare to serve files and process static redirects without a function invocation. Creating a custom `_routes.json` will override this automatic optimization and, if not configured manually, cause function invocations that will count against the request limits of your Cloudflare plan.
+export async function GET(context) {
+  const a = Number.parseInt(context.params.a);
+  const b = Number.parseInt(context.params.b);
+  return new Response(`${addModule.exports.add(a, b)}`);
+}
+```
 
-See [Cloudflare's documentation](https://developers.cloudflare.com/pages/platform/functions/routing/#create-a-_routesjson-file) for more details.
+While this example is trivial, Wasm can be used to accelerate computationally intensive operations which do not involve significant I/O such as embedding an image processing library.
 
 ## Node.js compatibility
 
@@ -225,33 +349,43 @@ export const prerender = false;
 import { Buffer } from 'node:buffer';
 ```
 
-Additionally, you'll need to enable the Compatibility Flag in Cloudflare. The configuration for this flag may vary based on where you deploy your Astro site.
+Additionally, you'll need to enable the Compatibility Flag in Cloudflare. The configuration for this flag may vary based on where you deploy your Astro site. For detailed guidance, please refer to the [Cloudflare documentation on enabling Node.js compatibility](https://developers.cloudflare.com/workers/runtime-apis/nodejs).
 
-For detailed guidance, please refer to the [Cloudflare documentation](https://developers.cloudflare.com/workers/runtime-apis/nodejs).
+## Preview with Wrangler
 
-## Troubleshooting
+To use [`wrangler`](https://developers.cloudflare.com/workers/wrangler/) to run your application locally, update the preview script:
 
-For help, check out the `#support` channel on [Discord](https://astro.build/chat). Our friendly Support Squad members are here to help!
+```json
+//package.json
+"preview": "wrangler pages dev ./dist"
+```
 
-You can also check our [Astro Integration Documentation][astro-integration] for more on integrations.
+[`wrangler`](https://developers.cloudflare.com/workers/wrangler/) gives you access to [Cloudflare bindings](https://developers.cloudflare.com/pages/platform/functions/bindings), [environment variables](https://developers.cloudflare.com/pages/platform/functions/bindings/#environment-variables), and the [cf object](https://developers.cloudflare.com/workers/runtime-apis/request/#incomingrequestcfproperties). Getting hot reloading or the astro dev server to work with Wrangler might require custom setup. See [community examples](https://github.com/withastro/roadmap/discussions/590).
 
 ### Meaningful error messages
 
-Currently, errors during running your application in Wrangler are not very useful, due to the minification of your code. For better debugging, you can add `vite.build.minify = false` setting to your `astro.config.js`
+Currently, errors during running your application in Wrangler are not very useful, due to the minification of your code. For better debugging, you can add `vite.build.minify = false` setting to your `astro.config.mjs`.
 
-```js
-export default defineConfig({
-  adapter: cloudflare(),
-  output: 'server',
+```diff lang="js"
+  // astro.config.mjs
+  export default defineConfig({
+    adapter: cloudflare(),
+    output: 'server',
 
-  vite: {
-    build: {
-      minify: false,
-    },
-  },
-});
++   vite: {
++     build: {
++       minify: false,
++     },
++   },
+  });
 ```
 
+## Troubleshooting
+
+For help, check out the `#support` channel on [Discord](https://astro.build/chat). Our friendly Support Squad members are here to help!
+
+You can also check our [Astro Integration Documentation][astro-integration] for more on integrations.
+
 ## Contributing
 
 This package is maintained by Astro's Core team. You're welcome to submit an issue or PR!

package/dist/{server.advanced.js → entrypoints/server.advanced.js}

@@ -1,5 +1,5 @@
 import { App } from "astro/app";
-import { getProcessEnvProxy, isNode } from "./util.js";
+import { getProcessEnvProxy, isNode } from "../util.js";
 if (!isNode) {
   process.env = getProcessEnvProxy();
 }

package/dist/{server.directory.d.ts → entrypoints/server.directory.d.ts}

@@ -9,6 +9,6 @@ export interface DirectoryRuntime<T extends object = object> {
     };
 }
 export declare function createExports(manifest: SSRManifest): {
-    onRequest: (context: EventContext<unknown, string, unknown>) => Promise<import("@cloudflare/workers-types").Response | Response>;
+    onRequest: (context: EventContext<unknown, string, unknown>) => Promise<Response | import("@cloudflare/workers-types").Response>;
     manifest: SSRManifest;
 };

package/dist/{server.directory.js → entrypoints/server.directory.js}

@@ -1,5 +1,5 @@
 import { App } from "astro/app";
-import { getProcessEnvProxy, isNode } from "./util.js";
+import { getProcessEnvProxy, isNode } from "../util.js";
 if (!isNode) {
   process.env = getProcessEnvProxy();
 }

package/dist/getAdapter.d.ts

@@ -0,0 +1,5 @@
+import type { AstroAdapter } from 'astro';
+export declare function getAdapter({ isModeDirectory, functionPerRoute, }: {
+    isModeDirectory: boolean;
+    functionPerRoute: boolean;
+}): AstroAdapter;

package/dist/getAdapter.js

@@ -0,0 +1,36 @@
+function getAdapter({
+  isModeDirectory,
+  functionPerRoute
+}) {
+  const astroFeatures = {
+    hybridOutput: "stable",
+    staticOutput: "unsupported",
+    serverOutput: "stable",
+    assets: {
+      supportKind: "stable",
+      isSharpCompatible: false,
+      isSquooshCompatible: false
+    }
+  };
+  if (isModeDirectory) {
+    return {
+      name: "@astrojs/cloudflare",
+      serverEntrypoint: "@astrojs/cloudflare/entrypoints/server.directory.js",
+      exports: ["onRequest", "manifest"],
+      adapterFeatures: {
+        functionPerRoute,
+        edgeMiddleware: false
+      },
+      supportedAstroFeatures: astroFeatures
+    };
+  }
+  return {
+    name: "@astrojs/cloudflare",
+    serverEntrypoint: "@astrojs/cloudflare/entrypoints/server.advanced.js",
+    exports: ["default"],
+    supportedAstroFeatures: astroFeatures
+  };
+}
+export {
+  getAdapter
+};

package/dist/index.d.ts

@@ -1,18 +1,28 @@
-import type { AstroAdapter, AstroIntegration } from 'astro';
-export type { AdvancedRuntime } from './server.advanced.js';
-export type { DirectoryRuntime } from './server.directory.js';
+import type { AstroIntegration } from 'astro';
+export type { AdvancedRuntime } from './entrypoints/server.advanced.js';
+export type { DirectoryRuntime } from './entrypoints/server.directory.js';
 type Options = {
     mode?: 'directory' | 'advanced';
     functionPerRoute?: boolean;
+    /** Configure automatic `routes.json` generation */
+    routes?: {
+        /** Strategy for generating `include` and `exclude` patterns
+         * - `auto`: Will use the strategy that generates the least amount of entries.
+         * - `include`: For each page or endpoint in your application that is not prerendered, an entry in the `include` array will be generated. For each page that is prerendered and whoose path is matched by an `include` entry, an entry in the `exclude` array will be generated.
+         * - `exclude`: One `"/*"` entry in the `include` array will be generated. For each page that is prerendered, an entry in the `exclude` array will be generated.
+         * */
+        strategy?: 'auto' | 'include' | 'exclude';
+        /** Additional `include` patterns */
+        include?: string[];
+        /** Additional `exclude` patterns */
+        exclude?: string[];
+    };
     /**
      * 'off': current behaviour (wrangler is needed)
      * 'local': use a static req.cf object, and env vars defined in wrangler.toml & .dev.vars (astro dev is enough)
      * 'remote': use a dynamic real-live req.cf object, and env vars defined in wrangler.toml & .dev.vars (astro dev is enough)
      */
     runtime?: 'off' | 'local' | 'remote';
+    wasmModuleImports?: boolean;
 };
-export declare function getAdapter({ isModeDirectory, functionPerRoute, }: {
-    isModeDirectory: boolean;
-    functionPerRoute: boolean;
-}): AstroAdapter;
 export default function createIntegration(args?: Options): AstroIntegration;

package/dist/index.js

@@ -6,10 +6,16 @@ import { AstroError } from "astro/errors";
 import esbuild from "esbuild";
 import * as fs from "node:fs";
 import * as os from "node:os";
-import { sep } from "node:path";
+import { dirname, relative, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import glob from "tiny-glob";
-import { getEnvVars } from "./parser.js";
+import { getAdapter } from "./getAdapter.js";
+import { deduplicatePatterns } from "./utils/deduplicatePatterns.js";
+import { getCFObject } from "./utils/getCFObject.js";
+import { getEnvVars } from "./utils/parser.js";
+import { prependForwardSlash } from "./utils/prependForwardSlash.js";
+import { rewriteWasmImportPath } from "./utils/rewriteWasmImportPath.js";
+import { wasmModuleLoader } from "./utils/wasm-module-loader.js";
 class StorageFactory {
   storages = /* @__PURE__ */ new Map();
   storage(namespace) {
@@ -20,119 +26,11 @@ class StorageFactory {
     return storage;
   }
 }
-function getAdapter({
-  isModeDirectory,
-  functionPerRoute
-}) {
-  return isModeDirectory ? {
-    name: "@astrojs/cloudflare",
-    serverEntrypoint: "@astrojs/cloudflare/server.directory.js",
-    exports: ["onRequest", "manifest"],
-    adapterFeatures: {
-      functionPerRoute,
-      edgeMiddleware: false
-    },
-    supportedAstroFeatures: {
-      hybridOutput: "stable",
-      staticOutput: "unsupported",
-      serverOutput: "stable",
-      assets: {
-        supportKind: "stable",
-        isSharpCompatible: false,
-        isSquooshCompatible: false
-      }
-    }
-  } : {
-    name: "@astrojs/cloudflare",
-    serverEntrypoint: "@astrojs/cloudflare/server.advanced.js",
-    exports: ["default"],
-    supportedAstroFeatures: {
-      hybridOutput: "stable",
-      staticOutput: "unsupported",
-      serverOutput: "stable",
-      assets: {
-        supportKind: "stable",
-        isSharpCompatible: false,
-        isSquooshCompatible: false
-      }
-    }
-  };
-}
-async function getCFObject(runtimeMode) {
-  const CF_ENDPOINT = "https://workers.cloudflare.com/cf.json";
-  const CF_FALLBACK = {
-    asOrganization: "",
-    asn: 395747,
-    colo: "DFW",
-    city: "Austin",
-    region: "Texas",
-    regionCode: "TX",
-    metroCode: "635",
-    postalCode: "78701",
-    country: "US",
-    continent: "NA",
-    timezone: "America/Chicago",
-    latitude: "30.27130",
-    longitude: "-97.74260",
-    clientTcpRtt: 0,
-    httpProtocol: "HTTP/1.1",
-    requestPriority: "weight=192;exclusive=0",
-    tlsCipher: "AEAD-AES128-GCM-SHA256",
-    tlsVersion: "TLSv1.3",
-    tlsClientAuth: {
-      certPresented: "0",
-      certVerified: "NONE",
-      certRevoked: "0",
-      certIssuerDN: "",
-      certSubjectDN: "",
-      certIssuerDNRFC2253: "",
-      certSubjectDNRFC2253: "",
-      certIssuerDNLegacy: "",
-      certSubjectDNLegacy: "",
-      certSerial: "",
-      certIssuerSerial: "",
-      certSKI: "",
-      certIssuerSKI: "",
-      certFingerprintSHA1: "",
-      certFingerprintSHA256: "",
-      certNotBefore: "",
-      certNotAfter: ""
-    },
-    edgeRequestKeepAliveStatus: 0,
-    hostMetadata: void 0,
-    clientTrustScore: 99,
-    botManagement: {
-      corporateProxy: false,
-      verifiedBot: false,
-      ja3Hash: "25b4882c2bcb50cd6b469ff28c596742",
-      staticResource: false,
-      detectionIds: [],
-      score: 99
-    }
-  };
-  if (runtimeMode === "local") {
-    return CF_FALLBACK;
-  } else if (runtimeMode === "remote") {
-    try {
-      const res = await fetch(CF_ENDPOINT);
-      const cfText = await res.text();
-      const storedCf = JSON.parse(cfText);
-      return storedCf;
-    } catch (e) {
-      return CF_FALLBACK;
-    }
-  }
-}
-const SHIM = `globalThis.process = {
-	argv: [],
-	env: {},
-};`;
-const SERVER_BUILD_FOLDER = "/$server_build/";
-const potentialFunctionRouteTypes = ["endpoint", "page"];
 function createIntegration(args) {
   let _config;
   let _buildConfig;
   let _entryPoints = /* @__PURE__ */ new Map();
+  const SERVER_BUILD_FOLDER = "/$server_build/";
   const isModeDirectory = args?.mode === "directory";
   const functionPerRoute = args?.functionPerRoute ?? false;
   const runtimeMode = args?.runtime ?? "off";
@@ -146,6 +44,15 @@ function createIntegration(args) {
             server: new URL(`.${SERVER_BUILD_FOLDER}`, config.outDir),
             serverEntry: "_worker.mjs",
             redirects: false
+          },
+          vite: {
+            // load .wasm files as WebAssembly modules
+            plugins: [
+              wasmModuleLoader({
+                disabled: !args?.wasmModuleImports,
+                assetsDirectory: config.build.assets
+              })
+            ]
           }
         });
       },
@@ -153,12 +60,12 @@ function createIntegration(args) {
         setAdapter(getAdapter({ isModeDirectory, functionPerRoute }));
         _config = config;
         _buildConfig = config.build;
-        if (config.output === "static") {
+        if (_config.output === "static") {
           throw new AstroError(
             '[@astrojs/cloudflare] `output: "server"` or `output: "hybrid"` is required to use this adapter. Otherwise, this adapter is not necessary to deploy a static site to Cloudflare.'
           );
         }
-        if (config.base === SERVER_BUILD_FOLDER) {
+        if (_config.base === SERVER_BUILD_FOLDER) {
           throw new AstroError(
             '[@astrojs/cloudflare] `base: "${SERVER_BUILD_FOLDER}"` is not allowed. Please change your `base` config to something else.'
           );
@@ -229,6 +136,7 @@ function createIntegration(args) {
       },
       "astro:build:done": async ({ pages, routes, dir }) => {
         const functionsUrl = new URL("functions/", _config.root);
+        const assetsUrl = new URL(_buildConfig.assets, _buildConfig.client);
         if (isModeDirectory) {
           await fs.promises.mkdir(functionsUrl, { recursive: true });
         }
@@ -237,35 +145,59 @@ function createIntegration(args) {
           const entryPaths = entryPointsURL.map((entry) => fileURLToPath(entry));
           const outputUrl = new URL("$astro", _buildConfig.server);
           const outputDir = fileURLToPath(outputUrl);
-          await esbuild.build({
-            target: "es2020",
-            platform: "browser",
-            conditions: ["workerd", "worker", "browser"],
-            external: [
-              "node:assert",
-              "node:async_hooks",
-              "node:buffer",
-              "node:diagnostics_channel",
-              "node:events",
-              "node:path",
-              "node:process",
-              "node:stream",
-              "node:string_decoder",
-              "node:util"
-            ],
-            entryPoints: entryPaths,
-            outdir: outputDir,
-            allowOverwrite: true,
-            format: "esm",
-            bundle: true,
-            minify: _config.vite?.build?.minify !== false,
-            banner: {
-              js: SHIM
-            },
-            logOverride: {
-              "ignored-bare-import": "silent"
-            }
-          });
+          const entryPathsGroupedByDepth = !args.wasmModuleImports ? [entryPaths] : entryPaths.reduce((sum, thisPath) => {
+            const depthFromRoot = thisPath.split(sep).length;
+            sum.set(depthFromRoot, (sum.get(depthFromRoot) || []).concat(thisPath));
+            return sum;
+          }, /* @__PURE__ */ new Map()).values();
+          for (const pathsGroup of entryPathsGroupedByDepth) {
+            const pagesDirname = relative(fileURLToPath(_buildConfig.server), pathsGroup[0]).split(
+              sep
+            )[0];
+            const absolutePagesDirname = fileURLToPath(new URL(pagesDirname, _buildConfig.server));
+            const urlWithinFunctions = new URL(
+              relative(absolutePagesDirname, pathsGroup[0]),
+              functionsUrl
+            );
+            const relativePathToAssets = relative(
+              dirname(fileURLToPath(urlWithinFunctions)),
+              fileURLToPath(assetsUrl)
+            );
+            await esbuild.build({
+              target: "es2020",
+              platform: "browser",
+              conditions: ["workerd", "worker", "browser"],
+              external: [
+                "node:assert",
+                "node:async_hooks",
+                "node:buffer",
+                "node:diagnostics_channel",
+                "node:events",
+                "node:path",
+                "node:process",
+                "node:stream",
+                "node:string_decoder",
+                "node:util"
+              ],
+              entryPoints: pathsGroup,
+              outbase: absolutePagesDirname,
+              outdir: outputDir,
+              allowOverwrite: true,
+              format: "esm",
+              bundle: true,
+              minify: _config.vite?.build?.minify !== false,
+              banner: {
+                js: `globalThis.process = {
+									argv: [],
+									env: {},
+								};`
+              },
+              logOverride: {
+                "ignored-bare-import": "silent"
+              },
+              plugins: !args?.wasmModuleImports ? [] : [rewriteWasmImportPath({ relativePathToAssets })]
+            });
+          }
           const outputFiles = await glob(`**/*`, {
             cwd: outputDir,
             filesOnly: true
@@ -318,11 +250,19 @@ function createIntegration(args) {
             bundle: true,
             minify: _config.vite?.build?.minify !== false,
             banner: {
-              js: SHIM
+              js: `globalThis.process = {
+								argv: [],
+								env: {},
+							};`
             },
             logOverride: {
               "ignored-bare-import": "silent"
-            }
+            },
+            plugins: !args?.wasmModuleImports ? [] : [
+              rewriteWasmImportPath({
+                relativePathToAssets: isModeDirectory ? relative(fileURLToPath(functionsUrl), fileURLToPath(assetsUrl)) : relative(fileURLToPath(_buildConfig.client), fileURLToPath(assetsUrl))
+              })
+            ]
           });
           await fs.promises.rename(buildPath, finalBuildUrl);
           if (isModeDirectory) {
@@ -344,8 +284,12 @@ function createIntegration(args) {
             }
           }
         }
+        if (!isModeDirectory) {
+          cloudflareSpecialFiles.push("_worker.js");
+        }
         const routesExists = await fs.promises.stat(new URL("./_routes.json", _config.outDir)).then((stat) => stat.isFile()).catch(() => false);
         if (!routesExists) {
+          const potentialFunctionRouteTypes = ["endpoint", "page"];
           const functionEndpoints = routes.filter((route) => potentialFunctionRouteTypes.includes(route.type) && !route.prerender).map((route) => {
             const includePattern = "/" + route.segments.flat().map((segment) => segment.dynamic ? "*" : segment.content).join("/");
             const regexp = new RegExp(
@@ -358,7 +302,8 @@ function createIntegration(args) {
           });
           const staticPathList = (await glob(`${fileURLToPath(_buildConfig.client)}/**/*`, {
             cwd: fileURLToPath(_config.outDir),
-            filesOnly: true
+            filesOnly: true,
+            dot: true
           })).filter((file) => cloudflareSpecialFiles.indexOf(file) < 0).map((file) => `/${file.replace(/\\/g, "/")}`);
           for (let page of pages) {
             let pagePath = prependForwardSlash(page.pathname);
@@ -399,29 +344,34 @@ function createIntegration(args) {
             );
           }
           staticPathList.push(...routes.filter((r) => r.type === "redirect").map((r) => r.route));
-          let include = deduplicatePatterns(
-            functionEndpoints.map((endpoint) => endpoint.includePattern)
-          );
-          let exclude = deduplicatePatterns(
-            staticPathList.filter(
-              (file) => functionEndpoints.some((endpoint) => endpoint.regexp.test(file))
+          const strategy = args?.routes?.strategy ?? "auto";
+          const includeStrategy = strategy === "exclude" ? void 0 : {
+            include: deduplicatePatterns(
+              functionEndpoints.map((endpoint) => endpoint.includePattern).concat(args?.routes?.include ?? [])
+            ),
+            exclude: deduplicatePatterns(
+              staticPathList.filter(
+                (file) => functionEndpoints.some((endpoint) => endpoint.regexp.test(file))
+              ).concat(args?.routes?.exclude ?? [])
             )
-          );
-          if (include.length === 0) {
-            include = ["/"];
-            exclude = ["/"];
-          }
-          if (include.length + exclude.length > staticPathList.length) {
-            include = ["/*"];
-            exclude = deduplicatePatterns(staticPathList);
+          };
+          if (includeStrategy?.include.length === 0) {
+            includeStrategy.include = ["/"];
+            includeStrategy.exclude = ["/"];
           }
+          const excludeStrategy = strategy === "include" ? void 0 : {
+            include: ["/*"],
+            exclude: deduplicatePatterns(staticPathList.concat(args?.routes?.exclude ?? []))
+          };
+          const includeStrategyLength = includeStrategy ? includeStrategy.include.length + includeStrategy.exclude.length : Infinity;
+          const excludeStrategyLength = excludeStrategy ? excludeStrategy.include.length + excludeStrategy.exclude.length : Infinity;
+          const winningStrategy = includeStrategyLength <= excludeStrategyLength ? includeStrategy : excludeStrategy;
           await fs.promises.writeFile(
             new URL("./_routes.json", _config.outDir),
             JSON.stringify(
               {
                 version: 1,
-                include,
-                exclude
+                ...winningStrategy
               },
               null,
               2
@@ -432,22 +382,6 @@ function createIntegration(args) {
     }
   };
 }
-function prependForwardSlash(path) {
-  return path[0] === "/" ? path : "/" + path;
-}
-function deduplicatePatterns(patterns) {
-  const openPatterns = [];
-  return [...new Set(patterns)].sort((a, b) => a.length - b.length).filter((pattern) => {
-    if (openPatterns.some((p) => p.test(pattern))) {
-      return false;
-    }
-    if (pattern.endsWith("*")) {
-      openPatterns.push(new RegExp(`^${pattern.replace(/(\*\/)*\*$/g, ".*")}`));
-    }
-    return true;
-  });
-}
 export {
-  createIntegration as default,
-  getAdapter
+  createIntegration as default
 };

package/dist/utils/deduplicatePatterns.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Remove duplicates and redundant patterns from an `include` or `exclude` list.
+ * Otherwise Cloudflare will throw an error on deployment. Plus, it saves more entries.
+ * E.g. `['/foo/*', '/foo/*', '/foo/bar'] => ['/foo/*']`
+ * @param patterns a list of `include` or `exclude` patterns
+ * @returns a deduplicated list of patterns
+ */
+export declare function deduplicatePatterns(patterns: string[]): string[];

package/dist/utils/deduplicatePatterns.js

@@ -0,0 +1,15 @@
+function deduplicatePatterns(patterns) {
+  const openPatterns = [];
+  return [...new Set(patterns)].sort((a, b) => a.length - b.length).filter((pattern) => {
+    if (openPatterns.some((p) => p.test(pattern))) {
+      return false;
+    }
+    if (pattern.endsWith("*")) {
+      openPatterns.push(new RegExp(`^${pattern.replace(/(\*\/)*\*$/g, ".*")}`));
+    }
+    return true;
+  });
+}
+export {
+  deduplicatePatterns
+};

package/dist/utils/getCFObject.d.ts

@@ -0,0 +1,2 @@
+import type { IncomingRequestCfProperties } from '@cloudflare/workers-types/experimental';
+export declare function getCFObject(runtimeMode: string): Promise<IncomingRequestCfProperties | void>;

package/dist/utils/getCFObject.js

@@ -0,0 +1,68 @@
+async function getCFObject(runtimeMode) {
+  const CF_ENDPOINT = "https://workers.cloudflare.com/cf.json";
+  const CF_FALLBACK = {
+    asOrganization: "",
+    asn: 395747,
+    colo: "DFW",
+    city: "Austin",
+    region: "Texas",
+    regionCode: "TX",
+    metroCode: "635",
+    postalCode: "78701",
+    country: "US",
+    continent: "NA",
+    timezone: "America/Chicago",
+    latitude: "30.27130",
+    longitude: "-97.74260",
+    clientTcpRtt: 0,
+    httpProtocol: "HTTP/1.1",
+    requestPriority: "weight=192;exclusive=0",
+    tlsCipher: "AEAD-AES128-GCM-SHA256",
+    tlsVersion: "TLSv1.3",
+    tlsClientAuth: {
+      certPresented: "0",
+      certVerified: "NONE",
+      certRevoked: "0",
+      certIssuerDN: "",
+      certSubjectDN: "",
+      certIssuerDNRFC2253: "",
+      certSubjectDNRFC2253: "",
+      certIssuerDNLegacy: "",
+      certSubjectDNLegacy: "",
+      certSerial: "",
+      certIssuerSerial: "",
+      certSKI: "",
+      certIssuerSKI: "",
+      certFingerprintSHA1: "",
+      certFingerprintSHA256: "",
+      certNotBefore: "",
+      certNotAfter: ""
+    },
+    edgeRequestKeepAliveStatus: 0,
+    hostMetadata: void 0,
+    clientTrustScore: 99,
+    botManagement: {
+      corporateProxy: false,
+      verifiedBot: false,
+      ja3Hash: "25b4882c2bcb50cd6b469ff28c596742",
+      staticResource: false,
+      detectionIds: [],
+      score: 99
+    }
+  };
+  if (runtimeMode === "local") {
+    return CF_FALLBACK;
+  } else if (runtimeMode === "remote") {
+    try {
+      const res = await fetch(CF_ENDPOINT);
+      const cfText = await res.text();
+      const storedCf = JSON.parse(cfText);
+      return storedCf;
+    } catch (e) {
+      return CF_FALLBACK;
+    }
+  }
+}
+export {
+  getCFObject
+};

package/dist/utils/prependForwardSlash.d.ts

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

package/dist/utils/prependForwardSlash.js

@@ -0,0 +1,6 @@
+function prependForwardSlash(path) {
+  return path[0] === "/" ? path : "/" + path;
+}
+export {
+  prependForwardSlash
+};

package/dist/utils/rewriteWasmImportPath.d.ts

@@ -0,0 +1,8 @@
+import esbuild from 'esbuild';
+/**
+ *
+ * @param relativePathToAssets - relative path from the final location for the current esbuild output bundle, to the assets directory.
+ */
+export declare function rewriteWasmImportPath({ relativePathToAssets, }: {
+    relativePathToAssets: string;
+}): esbuild.Plugin;

package/dist/utils/rewriteWasmImportPath.js

@@ -0,0 +1,25 @@
+import esbuild from "esbuild";
+import { basename } from "node:path";
+function rewriteWasmImportPath({
+  relativePathToAssets
+}) {
+  return {
+    name: "wasm-loader",
+    setup(build) {
+      build.onResolve({ filter: /.*\.wasm.mjs$/ }, (args) => {
+        const updatedPath = [
+          relativePathToAssets.replaceAll("\\", "/"),
+          basename(args.path).replace(/\.mjs$/, "")
+        ].join("/");
+        return {
+          path: updatedPath,
+          external: true
+          // mark it as external in the bundle
+        };
+      });
+    }
+  };
+}
+export {
+  rewriteWasmImportPath
+};

package/dist/utils/wasm-module-loader.d.ts

@@ -0,0 +1,14 @@
+import { type Plugin } from 'vite';
+/**
+ * Loads '*.wasm?module' imports as WebAssembly modules, which is the only way to load WASM in cloudflare workers.
+ * Current proposal for WASM modules: https://github.com/WebAssembly/esm-integration/tree/main/proposals/esm-integration
+ * Cloudflare worker WASM from javascript support: https://developers.cloudflare.com/workers/runtime-apis/webassembly/javascript/
+ * @param disabled - if true throws a helpful error message if wasm is encountered and wasm imports are not enabled,
+ * 								otherwise it will error obscurely in the esbuild and vite builds
+ * @param assetsDirectory - the folder name for the assets directory in the build directory. Usually '_astro'
+ * @returns Vite plugin to load WASM tagged with '?module' as a WASM modules
+ */
+export declare function wasmModuleLoader({ disabled, assetsDirectory, }: {
+    disabled: boolean;
+    assetsDirectory: string;
+}): Plugin;

package/dist/utils/wasm-module-loader.js

@@ -0,0 +1,88 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import {} from "vite";
+function wasmModuleLoader({
+  disabled,
+  assetsDirectory
+}) {
+  const postfix = ".wasm?module";
+  let isDev = false;
+  return {
+    name: "vite:wasm-module-loader",
+    enforce: "pre",
+    configResolved(config) {
+      isDev = config.command === "serve";
+    },
+    config(_, __) {
+      return {
+        assetsInclude: ["**/*.wasm?module"],
+        build: { rollupOptions: { external: /^__WASM_ASSET__.+\.wasm\.mjs$/i } }
+      };
+    },
+    load(id, _) {
+      if (!id.endsWith(postfix)) {
+        return;
+      }
+      if (disabled) {
+        throw new Error(
+          `WASM module's cannot be loaded unless you add \`wasmModuleImports: true\` to your astro config.`
+        );
+      }
+      const filePath = id.slice(0, -1 * "?module".length);
+      const data = fs.readFileSync(filePath);
+      const base64 = data.toString("base64");
+      const base64Module = `
+const wasmModule = new WebAssembly.Module(Uint8Array.from(atob("${base64}"), c => c.charCodeAt(0)));
+export default wasmModule
+`;
+      if (isDev) {
+        return base64Module;
+      } else {
+        let hash = hashString(base64);
+        const assetName = path.basename(filePath).split(".")[0] + "." + hash + ".wasm";
+        this.emitFile({
+          type: "asset",
+          // put it explicitly in the _astro assets directory with `fileName` rather than `name` so that
+          // vite doesn't give it a random id in its name. We need to be able to easily rewrite from
+          // the .mjs loader and the actual wasm asset later in the ESbuild for the worker
+          fileName: path.join(assetsDirectory, assetName),
+          source: fs.readFileSync(filePath)
+        });
+        const chunkId = this.emitFile({
+          type: "prebuilt-chunk",
+          fileName: assetName + ".mjs",
+          code: base64Module
+        });
+        return `
+import wasmModule from "__WASM_ASSET__${chunkId}.wasm.mjs";
+export default wasmModule;
+	`;
+      }
+    },
+    // output original wasm file relative to the chunk
+    renderChunk(code, chunk, _) {
+      if (isDev)
+        return;
+      if (!/__WASM_ASSET__/g.test(code))
+        return;
+      const final = code.replaceAll(/__WASM_ASSET__([a-z\d]+).wasm.mjs/g, (s, assetId) => {
+        const fileName = this.getFileName(assetId);
+        const relativePath = path.relative(path.dirname(chunk.fileName), fileName).replaceAll("\\", "/");
+        return `./${relativePath}`;
+      });
+      return { code: final };
+    }
+  };
+}
+function hashString(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash &= hash;
+  }
+  return new Uint32Array([hash])[0].toString(36);
+}
+export {
+  wasmModuleLoader
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@astrojs/cloudflare",
   "description": "Deploy your site to Cloudflare Workers/Pages",
-  "version": "7.2.0",
+  "version": "7.3.1",
   "type": "module",
   "types": "./dist/index.d.ts",
   "author": "withastro",
@@ -19,17 +19,12 @@
   "homepage": "https://docs.astro.build/en/guides/integrations-guide/cloudflare/",
   "exports": {
     ".": "./dist/index.js",
-    "./runtime": {
-      "types": "./runtime.d.ts",
-      "default": "./dist/runtime.js"
-    },
-    "./server.advanced.js": "./dist/server.advanced.js",
-    "./server.directory.js": "./dist/server.directory.js",
+    "./entrypoints/server.advanced.js": "./dist/entrypoints/server.advanced.js",
+    "./entrypoints/server.directory.js": "./dist/entrypoints/server.directory.js",
     "./package.json": "./package.json"
   },
   "files": [
-    "dist",
-    "runtime.d.ts"
+    "dist"
   ],
   "dependencies": {
     "@cloudflare/workers-types": "^4.20230821.0",
@@ -41,19 +36,19 @@
     "esbuild": "^0.19.2",
     "find-up": "^6.3.0",
     "tiny-glob": "^0.2.9",
+    "vite": "^4.4.9",
     "@astrojs/underscore-redirects": "0.3.0"
   },
   "peerDependencies": {
-    "astro": "^3.1.2"
+    "astro": "^3.2.0"
   },
   "devDependencies": {
     "@types/iarna__toml": "^2.0.2",
     "chai": "^4.3.7",
     "cheerio": "1.0.0-rc.12",
-    "kill-port": "^2.0.1",
     "mocha": "^10.2.0",
     "wrangler": "^3.5.1",
-    "astro": "3.1.2",
+    "astro": "3.2.0",
     "astro-scripts": "0.0.14"
   },
   "scripts": {