@astrojs/cloudflare 13.0.0-beta.4 → 13.0.0-beta.6

package/dist/entrypoints/preview.js

@@ -83,7 +83,7 @@ function serverStart({
   host,
   base
 }) {
-  const version = "13.0.0-beta.4";
+  const version = "13.0.0-beta.6";
   const localPrefix = `${colors.dim("\u2503")} Local    `;
   const networkPrefix = `${colors.dim("\u2503")} Network  `;
   const emptyPrefix = " ".repeat(11);

package/dist/index.d.ts

@@ -28,14 +28,6 @@ export type Options = {
             }[];
         };
     };
-    /**
-     * Allow bundling cloudflare worker specific file types as importable modules. Defaults to true.
-     * When enabled, allows imports of '.wasm', '.bin', and '.txt' file types
-     *
-     * See https://developers.cloudflare.com/pages/functions/module-support/
-     * for reference on how these file types are exported
-     */
-    cloudflareModules?: boolean;
     /**
      * By default, Astro will be configured to use Cloudflare KV to store session data. The KV namespace
      * will be automatically provisioned when you deploy.
@@ -56,25 +48,5 @@ export type Options = {
      * See https://developers.cloudflare.com/images/transform-images/bindings/ for more details.
      */
     imagesBindingName?: string;
-    /**
-     * This configuration option allows you to specify a custom entryPoint for your Cloudflare Worker.
-     * The entry point is the file that will be executed when your Worker is invoked.
-     * By default, this is set to `@astrojs/cloudflare/entrypoints/server.js` and `['default']`.
-     * @docs https://docs.astro.build/en/guides/integrations-guide/cloudflare/#workerEntryPoint
-     */
-    workerEntryPoint?: {
-        /**
-         * The path to the entry file. This should be a relative path from the root of your Astro project.
-         * @example`'src/worker.ts'`
-         * @docs https://docs.astro.build/en/guides/integrations-guide/cloudflare/#workerentrypointpath
-         */
-        path: string | URL;
-        /**
-         * Additional named exports to use for the entry file. Astro always includes the default export (`['default']`). If you need to have other top level named exports use this option.
-         * @example ['MyDurableObject', 'namedExport']
-         * @docs https://docs.astro.build/en/guides/integrations-guide/cloudflare/#workerentrypointnamedexports
-         */
-        namedExports?: string[];
-    };
 };
 export default function createIntegration(args?: Options): AstroIntegration;

package/dist/index.js

@@ -1,12 +1,9 @@
 import { createReadStream, existsSync, readFileSync } from "node:fs";
 import { appendFile, stat } from "node:fs/promises";
-import { createRequire } from "node:module";
 import { createInterface } from "node:readline/promises";
-import { pathToFileURL } from "node:url";
 import { removeLeadingForwardSlash } from "@astrojs/internal-helpers/path";
 import { createRedirectsFromAstroRoutes, printAsRedirects } from "@astrojs/underscore-redirects";
 import { cloudflare as cfVitePlugin } from "@cloudflare/vite-plugin";
-import { cloudflareModuleLoader } from "./utils/cloudflare-module-loader.js";
 import { createRoutesFile, getParts } from "./utils/generate-routes-json.js";
 import { setImageConfig } from "./utils/image-config.js";
 import { createConfigPlugin } from "./vite-plugin-config.js";
@@ -15,14 +12,12 @@ import {
   DEFAULT_SESSION_KV_BINDING_NAME,
   DEFAULT_IMAGES_BINDING_NAME
 } from "./wrangler.js";
-import { parse } from "dotenv";
+import { parseEnv } from "node:util";
 import { sessionDrivers } from "astro/config";
+import { createCloudflarePrerenderer } from "./prerenderer.js";
 function createIntegration(args) {
   let _config;
   let finalBuildOutput;
-  const cloudflareModulePlugin = cloudflareModuleLoader(
-    args?.cloudflareModules ?? true
-  );
   let _routes;
   const sessionKVBindingName = args?.sessionKVBindingName ?? DEFAULT_SESSION_KV_BINDING_NAME;
   const imagesBindingName = args?.imagesBindingName ?? DEFAULT_IMAGES_BINDING_NAME;
@@ -53,7 +48,18 @@ function createIntegration(args) {
           config: cloudflareConfigCustomizer({
             sessionKVBindingName: args?.sessionKVBindingName,
             imagesBindingName: args?.imageService === "cloudflare-binding" ? args?.imagesBindingName : false
-          })
+          }),
+          experimental: {
+            prerenderWorker: {
+              config(_, { entryWorkerConfig }) {
+                return {
+                  ...entryWorkerConfig,
+                  // This is the Vite environment name used for prerendering
+                  name: "prerender"
+                };
+              }
+            }
+          }
         };
         updateConfig({
           build: {
@@ -66,9 +72,6 @@ function createIntegration(args) {
           vite: {
             plugins: [
               cfVitePlugin(cfPluginConfig),
-              // https://developers.cloudflare.com/pages/functions/module-support/
-              // Allows imports of '.wasm', '.bin', and '.txt' file types
-              cloudflareModulePlugin,
               {
                 name: "@astrojs/cloudflare:cf-imports",
                 enforce: "pre",
@@ -84,8 +87,10 @@ function createIntegration(args) {
               {
                 name: "@astrojs/cloudflare:environment",
                 configEnvironment(environmentName, _options) {
-                  const isServerEnvironment = ["ssr", "prerender"].includes(environmentName);
-                  if (isServerEnvironment && _options.optimizeDeps?.noDiscovery === false) {
+                  const isServerEnvironment = ["astro", "ssr", "prerender"].includes(
+                    environmentName
+                  );
+                  if (isServerEnvironment && !_options.optimizeDeps?.noDiscovery) {
                     return {
                       optimizeDeps: {
                         include: [
@@ -162,19 +167,8 @@ function createIntegration(args) {
           filename: "cloudflare.d.ts",
           content: '/// <reference types="@astrojs/cloudflare/types.d.ts" />'
         });
-        let customWorkerEntryPoint;
-        if (args?.workerEntryPoint && typeof args.workerEntryPoint.path === "string") {
-          const require2 = createRequire(config.root);
-          try {
-            customWorkerEntryPoint = pathToFileURL(require2.resolve(args.workerEntryPoint.path));
-          } catch {
-            customWorkerEntryPoint = new URL(args.workerEntryPoint.path, config.root);
-          }
-        }
         setAdapter({
           name: "@astrojs/cloudflare",
-          serverEntrypoint: customWorkerEntryPoint ?? "@astrojs/cloudflare/entrypoints/server.js",
-          exports: [.../* @__PURE__ */ new Set(["default", ...args?.workerEntryPoint?.namedExports ?? []])],
           adapterFeatures: {
             edgeMiddleware: false,
             buildOutput: "server"
@@ -188,10 +182,9 @@ function createIntegration(args) {
             i18nDomains: "experimental",
             sharpImageService: {
               support: "limited",
-              message: 'Cloudflare does not support sharp at runtime. However, you can configure `imageService: "compile"` to optimize images with sharp on prerendered pages during build time.',
-              // For explicitly set image services, we suppress the warning about sharp not being supported at runtime,
-              // inferring the user is aware of the limitations.
-              suppress: args?.imageService ? "all" : "default"
+              message: "When using a custom image service, ensure it is compatible with the Cloudflare Workers runtime.",
+              // Only 'custom' could potentially use sharp at runtime.
+              suppress: args?.imageService === "custom" ? "default" : "all"
             },
             envGetSecret: "stable"
           }
@@ -200,7 +193,7 @@ function createIntegration(args) {
         if (existsSync(devVarsPath)) {
           try {
             const data = readFileSync(devVarsPath, "utf-8");
-            const parsed = parse(data);
+            const parsed = parseEnv(data);
             Object.assign(process.env, parsed);
           } catch {
             logger.error(
@@ -209,6 +202,17 @@ function createIntegration(args) {
           }
         }
       },
+      "astro:build:start": ({ setPrerenderer }) => {
+        setPrerenderer(
+          createCloudflarePrerenderer({
+            root: _config.root,
+            serverDir: _config.build.server,
+            clientDir: _config.build.client,
+            base: _config.base,
+            trailingSlash: _config.trailingSlash
+          })
+        );
+      },
       "astro:build:setup": ({ vite, target }) => {
         if (target === "server") {
           vite.resolve ||= {};
@@ -297,6 +301,7 @@ function createIntegration(args) {
             logger.error("Failed to write _redirects file");
           }
         }
+        delete process.env.CLOUDFLARE_VITE_BUILD;
       }
     }
   };

package/dist/prerender-types.d.ts

@@ -0,0 +1,22 @@
+import type { SerializedRouteData } from 'astro/app/manifest';
+/**
+ * A pathname with its serialized route data, used for prerendering over HTTP.
+ */
+interface SerializedPathWithRoute {
+    pathname: string;
+    route: SerializedRouteData;
+}
+/**
+ * Response from the /__astro_static_paths endpoint.
+ */
+export interface StaticPathsResponse {
+    paths: SerializedPathWithRoute[];
+}
+/**
+ * Request body for the /__astro_prerender endpoint.
+ */
+export interface PrerenderRequest {
+    url: string;
+    routeData: SerializedRouteData;
+}
+export {};

package/dist/prerenderer.d.ts

@@ -0,0 +1,14 @@
+import type { AstroConfig, AstroPrerenderer } from 'astro';
+interface CloudflarePrerendererOptions {
+    root: AstroConfig['root'];
+    serverDir: AstroConfig['build']['server'];
+    clientDir: AstroConfig['build']['client'];
+    base: AstroConfig['base'];
+    trailingSlash: AstroConfig['trailingSlash'];
+}
+/**
+ * Creates a prerenderer that uses Cloudflare's workerd runtime via a preview server.
+ * This allows prerendering to happen in the same runtime that will serve the pages.
+ */
+export declare function createCloudflarePrerenderer({ root, serverDir, clientDir, base, trailingSlash, }: CloudflarePrerendererOptions): AstroPrerenderer;
+export {};

package/dist/prerenderer.js

@@ -0,0 +1,88 @@
+import { preview } from "vite";
+import { fileURLToPath } from "node:url";
+import { mkdir } from "node:fs/promises";
+import { cloudflare as cfVitePlugin } from "@cloudflare/vite-plugin";
+import { cloudflareConfigCustomizer } from "./wrangler.js";
+import { serializeRouteData, deserializeRouteData } from "astro/app/manifest";
+import { STATIC_PATHS_ENDPOINT, PRERENDER_ENDPOINT } from "./utils/prerender-constants.js";
+function createCloudflarePrerenderer({
+  root,
+  serverDir,
+  clientDir,
+  base,
+  trailingSlash
+}) {
+  let previewServer;
+  let serverUrl;
+  return {
+    name: "@astrojs/cloudflare:prerenderer",
+    async setup() {
+      await mkdir(clientDir, { recursive: true });
+      const cfPluginConfig = {
+        viteEnvironment: { name: "prerender" },
+        config: cloudflareConfigCustomizer()
+      };
+      previewServer = await preview({
+        configFile: false,
+        base,
+        appType: "mpa",
+        build: {
+          outDir: fileURLToPath(serverDir)
+        },
+        root: fileURLToPath(root),
+        preview: {
+          host: "localhost",
+          port: 0,
+          // Let the OS pick a free port
+          open: false
+        },
+        plugins: [cfVitePlugin(cfPluginConfig)]
+      });
+      const address = previewServer.httpServer.address();
+      if (address && typeof address === "object") {
+        serverUrl = `http://localhost:${address.port}`;
+      } else {
+        throw new Error(
+          "Failed to start the Cloudflare prerender server. The preview server did not return a valid address. This is likely a bug in @astrojs/cloudflare. Please file an issue at https://github.com/withastro/astro/issues"
+        );
+      }
+    },
+    async getStaticPaths() {
+      const response = await fetch(`${serverUrl}${STATIC_PATHS_ENDPOINT}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" }
+      });
+      if (!response.ok) {
+        throw new Error(
+          `Failed to get static paths from the Cloudflare prerender server (${response.status}: ${response.statusText}). This is likely a bug in @astrojs/cloudflare. Please file an issue at https://github.com/withastro/astro/issues`
+        );
+      }
+      const data = await response.json();
+      return data.paths.map(({ pathname, route }) => ({
+        pathname,
+        route: deserializeRouteData(route)
+      }));
+    },
+    async render(request, { routeData }) {
+      const body = {
+        url: request.url,
+        routeData: serializeRouteData(routeData, trailingSlash)
+      };
+      const response = await fetch(`${serverUrl}${PRERENDER_ENDPOINT}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      return response;
+    },
+    async teardown() {
+      if (previewServer) {
+        await previewServer.close();
+        previewServer = void 0;
+      }
+    }
+  };
+}
+export {
+  createCloudflarePrerenderer
+};

package/dist/utils/handler.js

@@ -1,19 +1,33 @@
 import { env as globalEnv } from "cloudflare:workers";
-import { sessionKVBindingName } from "virtual:astro-cloudflare:config";
+import { sessionKVBindingName, isPrerender } from "virtual:astro-cloudflare:config";
 import { createApp } from "astro/app/entrypoint";
 import { setGetEnv } from "astro/env/setup";
 import { createGetEnv } from "../utils/env.js";
+import {
+  isStaticPathsRequest,
+  isPrerenderRequest,
+  handleStaticPathsRequest,
+  handlePrerenderRequest
+} from "./prerender.js";
 setGetEnv(createGetEnv(globalEnv));
+const app = createApp();
 async function handle(request, env, context) {
-  const app = createApp(import.meta.env.DEV);
-  const { pathname } = new URL(request.url);
+  if (isPrerender) {
+    if (isStaticPathsRequest(request)) {
+      return handleStaticPathsRequest(app);
+    }
+    if (isPrerenderRequest(request)) {
+      return handlePrerenderRequest(app, request);
+    }
+  }
+  const { pathname: requestPathname } = new URL(request.url);
   if (env[sessionKVBindingName]) {
     const sessionConfigOptions = app.manifest.sessionConfig?.options ?? {};
     Object.assign(sessionConfigOptions, {
       binding: env[sessionKVBindingName]
     });
   }
-  if (app.manifest.assets.has(pathname)) {
+  if (app.manifest.assets.has(requestPathname)) {
     return env.ASSETS.fetch(request.url.replace(/\.html$/, ""));
   }
   let routeData = void 0;

package/dist/utils/prerender-constants.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Constants for prerender endpoints used by Cloudflare adapter
+ */
+/** Internal endpoint for fetching all static paths during prerendering */
+export declare const STATIC_PATHS_ENDPOINT = "/__astro_static_paths";
+/** Internal endpoint for rendering a specific page during prerendering */
+export declare const PRERENDER_ENDPOINT = "/__astro_prerender";

package/dist/utils/prerender-constants.js

@@ -0,0 +1,6 @@
+const STATIC_PATHS_ENDPOINT = "/__astro_static_paths";
+const PRERENDER_ENDPOINT = "/__astro_prerender";
+export {
+  PRERENDER_ENDPOINT,
+  STATIC_PATHS_ENDPOINT
+};

package/dist/utils/prerender.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Prerender utilities for Cloudflare adapter
+ *
+ * During the build process, Astro prerenders pages by making requests to internal endpoints
+ * served by the Cloudflare worker running in workerd. These endpoints are:
+ *
+ * - `/__astro_static_paths`: Returns all static paths that need to be prerendered.
+ *   The prerenderer calls this to discover which routes/pages need to be generated.
+ *
+ * - `/__astro_prerender`: Renders a specific page given its URL and route data.
+ *   The prerenderer calls this for each path to generate the static HTML.
+ *
+ * These endpoints are only active during the prerender build phase and are not
+ * available in production or development.
+ */
+import type { BaseApp } from 'astro/app';
+/**
+ * Checks if the request is for the static paths prerender endpoint.
+ * This endpoint returns all paths that need to be prerendered.
+ */
+export declare function isStaticPathsRequest(request: Request): boolean;
+/**
+ * Checks if the request is for the prerender endpoint.
+ * This endpoint renders a specific page during the prerender phase.
+ */
+export declare function isPrerenderRequest(request: Request): boolean;
+/**
+ * Handles the static paths request, returning all paths that need prerendering.
+ */
+export declare function handleStaticPathsRequest(app: BaseApp): Promise<Response>;
+/**
+ * Handles a prerender request, rendering the specified page.
+ */
+export declare function handlePrerenderRequest(app: BaseApp, request: Request): Promise<Response>;

package/dist/utils/prerender.js

@@ -0,0 +1,43 @@
+import { serializeRouteData, deserializeRouteData } from "astro/app/manifest";
+import { StaticPaths } from "astro:static-paths";
+import { STATIC_PATHS_ENDPOINT, PRERENDER_ENDPOINT } from "./prerender-constants.js";
+function isStaticPathsRequest(request) {
+  const { pathname } = new URL(request.url);
+  return pathname === STATIC_PATHS_ENDPOINT && request.method === "POST";
+}
+function isPrerenderRequest(request) {
+  const { pathname } = new URL(request.url);
+  return pathname === PRERENDER_ENDPOINT && request.method === "POST";
+}
+async function handleStaticPathsRequest(app) {
+  const staticPaths = new StaticPaths(app);
+  const paths = await staticPaths.getAll();
+  const response = {
+    paths: paths.map(({ pathname, route }) => ({
+      pathname,
+      route: serializeRouteData(route, app.manifest.trailingSlash)
+    }))
+  };
+  return new Response(JSON.stringify(response), {
+    headers: { "Content-Type": "application/json" }
+  });
+}
+async function handlePrerenderRequest(app, request) {
+  const headers = new Headers();
+  for (const [key, value] of request.headers.entries()) {
+    headers.append(key, value);
+  }
+  const body = await request.json();
+  const routeData = deserializeRouteData(body.routeData);
+  const prerenderRequest = new Request(body.url, {
+    method: "GET",
+    headers
+  });
+  return app.render(prerenderRequest, { routeData });
+}
+export {
+  handlePrerenderRequest,
+  handleStaticPathsRequest,
+  isPrerenderRequest,
+  isStaticPathsRequest
+};

package/dist/vite-plugin-config.d.ts

@@ -1,6 +1,6 @@
 import type { PluginOption } from 'vite';
-interface CloudflareConfig {
+export interface Config {
     sessionKVBindingName: string;
+    isPrerender: boolean;
 }
-export declare function createConfigPlugin(config: CloudflareConfig): PluginOption;
-export {};
+export declare function createConfigPlugin(config: Omit<Config, 'isPrerender'>): PluginOption;

package/dist/vite-plugin-config.js

@@ -2,7 +2,7 @@ const VIRTUAL_CONFIG_ID = "virtual:astro-cloudflare:config";
 const RESOLVED_VIRTUAL_CONFIG_ID = "\0" + VIRTUAL_CONFIG_ID;
 function createConfigPlugin(config) {
   return {
-    name: "vite:astro-cloudflare-config",
+    name: VIRTUAL_CONFIG_ID,
     resolveId: {
       filter: {
         id: new RegExp(`^${VIRTUAL_CONFIG_ID}$`)
@@ -16,7 +16,10 @@ function createConfigPlugin(config) {
         id: new RegExp(`^${RESOLVED_VIRTUAL_CONFIG_ID}$`)
       },
       handler() {
-        return `export const sessionKVBindingName = ${JSON.stringify(config.sessionKVBindingName)};`;
+        return [
+          ...Object.entries(config).map(([k, v]) => `export const ${k} = ${JSON.stringify(v)};`),
+          `export const isPrerender = ${this.environment?.name === "prerender"};`
+        ].join("\n");
       }
     }
   };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@astrojs/cloudflare",
   "description": "Deploy your site to Cloudflare Workers/Pages",
-  "version": "13.0.0-beta.4",
+  "version": "13.0.0-beta.6",
   "type": "module",
   "types": "./dist/index.d.ts",
   "author": "withastro",
@@ -35,12 +35,11 @@
     "types.d.ts"
   ],
   "dependencies": {
-    "@cloudflare/vite-plugin": "^1.22.1",
-    "dotenv": "^17.2.3",
+    "@cloudflare/vite-plugin": "^1.23.0",
     "piccolore": "^0.1.3",
     "tinyglobby": "^0.2.15",
     "vite": "^7.3.1",
-    "@astrojs/internal-helpers": "0.8.0-beta.0",
+    "@astrojs/internal-helpers": "0.8.0-beta.1",
     "@astrojs/underscore-redirects": "1.0.0"
   },
   "peerDependencies": {
@@ -48,11 +47,11 @@
     "wrangler": "^4.61.1"
   },
   "devDependencies": {
-    "@cloudflare/workers-types": "^4.20260124.0",
-    "cheerio": "1.1.2",
+    "@cloudflare/workers-types": "^4.20260131.0",
+    "@types/node": "^25.2.2",
+    "cheerio": "1.2.0",
     "devalue": "^5.6.2",
-    "rollup": "^4.55.1",
-    "astro": "6.0.0-beta.7",
+    "astro": "6.0.0-beta.10",
     "astro-scripts": "0.0.14"
   },
   "publishConfig": {

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

@@ -1,16 +0,0 @@
-import type { PluginOption } from 'vite';
-/**
- * Enables support for various non-standard extensions in module imports that cloudflare workers supports.
- *
- * See https://developers.cloudflare.com/pages/functions/module-support/ for reference
- *
- * This adds supports for imports in the following formats:
- * - .wasm
- * - .wasm?module
- * - .bin
- * - .txt
- *
- * @param enabled - if true, will load all cloudflare pages supported types
- * @returns Vite plugin with additional extension method to hook into astro build
- */
-export declare function cloudflareModuleLoader(enabled: boolean): PluginOption;

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

@@ -1,152 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-function cloudflareModuleLoader(enabled) {
-  const adaptersByExtension = enabled ? { ...defaultAdapters } : {};
-  const extensions = Object.keys(adaptersByExtension);
-  let isDev = false;
-  const MAGIC_STRING = "__CLOUDFLARE_ASSET__";
-  const replacements = [];
-  return {
-    name: "vite:cf-module-loader",
-    enforce: "pre",
-    applyToEnvironment(environment) {
-      return environment.name === "ssr" || environment.name === "client";
-    },
-    configResolved(config) {
-      isDev = config.command === "serve";
-    },
-    config(_, __) {
-      return {
-        assetsInclude: extensions.map((x) => `**/*${x}`),
-        build: {
-          rollupOptions: {
-            // mark the wasm files as external so that they are not bundled and instead are loaded from the files
-            external: extensions.map(
-              (x) => new RegExp(`^${MAGIC_STRING}.+${escapeRegExp(x)}$`, "i")
-            )
-          }
-        }
-      };
-    },
-    load: {
-      filter: {
-        // Escape the dot in the regex
-        id: new RegExp(`.(${extensions.map((ext) => ext.slice(1)).join("|")})$`)
-      },
-      async handler(id, _) {
-        const maybeExtension = extensions.find((x) => id.endsWith(x));
-        const moduleType = adaptersByExtension[maybeExtension];
-        if (!enabled) {
-          throw new Error(
-            `Cloudflare module loading is experimental. The ${maybeExtension} module cannot be loaded unless you add \`cloudflareModules: true\` to your astro config.`
-          );
-        }
-        const moduleLoader = renderers[moduleType];
-        const filePath = id.replace(/\?\w+$/, "");
-        const extension = maybeExtension.replace(/\?\w+$/, "");
-        const data = await fs.readFile(filePath);
-        const base64 = data.toString("base64");
-        const inlineModule = moduleLoader(data);
-        if (isDev) {
-          return inlineModule;
-        }
-        const hash = hashString(base64);
-        const assetName = `${path.basename(filePath).split(".")[0]}.${hash}${extension}`;
-        this.emitFile({
-          type: "asset",
-          // emit the data explicitly as an asset with `fileName` rather than `name` so that
-          // vite doesn't give it a random hash-id in its name--We need to be able to easily rewrite from
-          // the loader and the actual asset later in the build for the worker
-          fileName: assetName,
-          source: data
-        });
-        const chunkId = this.emitFile({
-          type: "prebuilt-chunk",
-          fileName: assetName,
-          code: inlineModule
-        });
-        return `import module from "${MAGIC_STRING}${chunkId}${extension}";export default module;`;
-      }
-    },
-    // output original wasm file relative to the chunk now that chunking has been achieved
-    renderChunk(code, chunk, _) {
-      if (isDev) return;
-      if (!code.includes(MAGIC_STRING)) return;
-      let replaced = code;
-      for (const ext of extensions) {
-        const extension = ext.replace(/\?\w+$/, "");
-        replaced = replaced.replaceAll(
-          new RegExp(`${MAGIC_STRING}([^\\s]+?)${escapeRegExp(extension)}`, "g"),
-          (_s, assetId) => {
-            const fileName = this.getFileName(assetId);
-            const relativePath = path.relative(path.dirname(chunk.fileName), fileName).replaceAll("\\", "/");
-            replacements.push({
-              chunkName: chunk.name,
-              cloudflareImport: relativePath,
-              nodejsImport: relativePath
-            });
-            return `./${relativePath}`;
-          }
-        );
-      }
-      return { code: replaced };
-    },
-    generateBundle(_, bundle) {
-      const replacementsByChunkName = /* @__PURE__ */ new Map();
-      for (const replacement of replacements) {
-        const repls = replacementsByChunkName.get(replacement.chunkName) || [];
-        if (!repls.length) {
-          replacementsByChunkName.set(replacement.chunkName, repls);
-        }
-        repls.push(replacement);
-      }
-      for (const chunk of Object.values(bundle)) {
-        const repls = chunk.name && replacementsByChunkName.get(chunk.name);
-        for (const replacement of repls || []) {
-          if (!replacement.fileName) {
-            replacement.fileName = [];
-          }
-          replacement.fileName.push(chunk.fileName);
-        }
-      }
-    }
-  };
-}
-const renderers = {
-  CompiledWasm(fileContents) {
-    const base64 = fileContents.toString("base64");
-    return `const wasmModule = new WebAssembly.Module(Uint8Array.from(atob("${base64}"), c => c.charCodeAt(0)));export default wasmModule;`;
-  },
-  Data(fileContents) {
-    const base64 = fileContents.toString("base64");
-    return `const binModule = Uint8Array.from(atob("${base64}"), c => c.charCodeAt(0)).buffer;export default binModule;`;
-  },
-  Text(fileContents) {
-    const escaped = JSON.stringify(fileContents.toString("utf-8"));
-    return `const stringModule = ${escaped};export default stringModule;`;
-  }
-};
-const defaultAdapters = {
-  // 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
-  ".wasm?module": "CompiledWasm",
-  // treats the module as a WASM module
-  ".wasm": "CompiledWasm",
-  ".bin": "Data",
-  ".txt": "Text"
-};
-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);
-}
-function escapeRegExp(string) {
-  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-export {
-  cloudflareModuleLoader
-};