@astrojs/cloudflare 13.0.0-beta.1 → 13.0.0-beta.10

package/dist/utils/prerender.js

@@ -0,0 +1,76 @@
+import { serializeRouteData, deserializeRouteData } from "astro/app/manifest";
+import { StaticPaths } from "astro:static-paths";
+import {
+  STATIC_PATHS_ENDPOINT,
+  PRERENDER_ENDPOINT,
+  STATIC_IMAGES_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 });
+}
+function isStaticImagesRequest(request) {
+  const { pathname } = new URL(request.url);
+  return pathname === STATIC_IMAGES_ENDPOINT && request.method === "POST";
+}
+function handleStaticImagesRequest() {
+  const staticImages = globalThis.astroAsset?.staticImages;
+  if (!staticImages || staticImages.size === 0) {
+    return new Response("[]", {
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  const entries = [];
+  for (const [originalPath, { originalSrcPath, transforms }] of staticImages) {
+    const serializedTransforms = [];
+    for (const [hash, { finalPath, transform }] of transforms) {
+      serializedTransforms.push({
+        hash,
+        finalPath,
+        transform
+      });
+    }
+    entries.push({ originalPath, originalSrcPath, transforms: serializedTransforms });
+  }
+  return new Response(JSON.stringify(entries), {
+    headers: { "Content-Type": "application/json" }
+  });
+}
+export {
+  handlePrerenderRequest,
+  handleStaticImagesRequest,
+  handleStaticPathsRequest,
+  isPrerenderRequest,
+  isStaticImagesRequest,
+  isStaticPathsRequest
+};

package/dist/utils/static-image-collection.d.ts

@@ -0,0 +1,7 @@
+import type { CompileImageConfig } from '../vite-plugin-config.js';
+/**
+ * Installs `globalThis.astroAsset.addStaticImage` for use inside workerd
+ * during prerendering. This mirrors the logic in astro's vite-plugin-assets.ts
+ * but uses only workerd-safe APIs (no node: imports).
+ */
+export declare function installAddStaticImage(config: CompileImageConfig): void;

package/dist/utils/static-image-collection.js

@@ -0,0 +1,51 @@
+import { joinPaths, prependForwardSlash, removeBase } from "@astrojs/internal-helpers/path";
+import { hashTransform, propsToFilename } from "astro/assets";
+import { isESMImportedImage } from "astro/assets/utils";
+function installAddStaticImage(config) {
+  if (globalThis.astroAsset?.addStaticImage) return;
+  if (!globalThis.astroAsset) {
+    globalThis.astroAsset = { referencedImages: /* @__PURE__ */ new Set() };
+  }
+  globalThis.astroAsset.addStaticImage = (options, hashProperties, _originalFSPath) => {
+    if (!globalThis.astroAsset.staticImages) {
+      globalThis.astroAsset.staticImages = /* @__PURE__ */ new Map();
+    }
+    const ESMImportedImageSrc = isESMImportedImage(options.src) ? options.src.src : options.src;
+    const finalOriginalPath = removeBase(
+      removeBase(ESMImportedImageSrc, config.base),
+      config.assetsPrefix ?? ""
+    );
+    const hash = hashTransform(options, config.imageServiceEntrypoint, hashProperties);
+    let finalFilePath;
+    let transformsForPath = globalThis.astroAsset.staticImages.get(finalOriginalPath);
+    const transformForHash = transformsForPath?.transforms.get(hash);
+    if (transformsForPath && transformForHash) {
+      finalFilePath = transformForHash.finalPath;
+    } else {
+      finalFilePath = prependForwardSlash(
+        joinPaths(
+          isESMImportedImage(options.src) ? "" : config.buildAssets,
+          prependForwardSlash(propsToFilename(finalOriginalPath, options, hash))
+        )
+      );
+      if (!transformsForPath) {
+        globalThis.astroAsset.staticImages.set(finalOriginalPath, {
+          originalSrcPath: _originalFSPath,
+          transforms: /* @__PURE__ */ new Map()
+        });
+        transformsForPath = globalThis.astroAsset.staticImages.get(finalOriginalPath);
+      }
+      transformsForPath.transforms.set(hash, {
+        finalPath: finalFilePath,
+        transform: options
+      });
+    }
+    if (config.assetsPrefix) {
+      return encodeURI(joinPaths(config.assetsPrefix, finalFilePath));
+    }
+    return encodeURI(prependForwardSlash(joinPaths(config.base, finalFilePath)));
+  };
+}
+export {
+  installAddStaticImage
+};

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

@@ -1,6 +1,13 @@
 import type { PluginOption } from 'vite';
-interface CloudflareConfig {
+export interface CompileImageConfig {
+    base: string;
+    assetsPrefix: string | undefined;
+    imageServiceEntrypoint: string;
+    buildAssets: string;
+}
+export interface Config {
     sessionKVBindingName: string;
+    compileImageConfig: CompileImageConfig | null;
+    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/dist/wrangler.d.ts

@@ -3,12 +3,12 @@ export declare const DEFAULT_SESSION_KV_BINDING_NAME = "SESSION";
 export declare const DEFAULT_IMAGES_BINDING_NAME = "IMAGES";
 export declare const DEFAULT_ASSETS_BINDING_NAME = "ASSETS";
 interface CloudflareConfigOptions {
-    sessionKVBindingName?: string;
-    imagesBindingName?: string | false;
+    sessionKVBindingName: string | undefined;
+    imagesBindingName: string | false | undefined;
 }
 /**
  * Returns a config customizer that sets up the Astro Cloudflare defaults.
  * Sets the main entrypoint and adds bindings for auto-provisioning.
  */
-export declare function cloudflareConfigCustomizer(options?: CloudflareConfigOptions): PluginConfig['config'];
+export declare function cloudflareConfigCustomizer(options: CloudflareConfigOptions): PluginConfig['config'];
 export {};

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@astrojs/cloudflare",
-  "description": "Deploy your site to Cloudflare Workers/Pages",
-  "version": "13.0.0-beta.1",
+  "description": "Deploy your site to Cloudflare Workers",
+  "version": "13.0.0-beta.10",
   "type": "module",
   "types": "./dist/index.d.ts",
   "author": "withastro",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/withastro/astro.git",
+    "url": "git+https://github.com/withastro/astro.git",
     "directory": "packages/integrations/cloudflare"
   },
   "keywords": [
@@ -19,12 +19,13 @@
   "homepage": "https://docs.astro.build/en/guides/integrations-guide/cloudflare/",
   "exports": {
     ".": "./dist/index.js",
+    "./info": "./dist/info.js",
     "./entrypoints/server": "./dist/entrypoints/server.js",
     "./entrypoints/preview": "./dist/entrypoints/preview.js",
     "./entrypoints/server.js": "./dist/entrypoints/server.js",
-    "./image-service": "./dist/entrypoints/image-service.js",
-    "./image-endpoint": "./dist/entrypoints/image-endpoint.js",
+    "./image-service": "./dist/entrypoints/image-service-external.js",
     "./image-transform-endpoint": "./dist/entrypoints/image-transform-endpoint.js",
+    "./image-service-workerd": "./dist/entrypoints/image-service-workerd.js",
     "./handler": "./dist/utils/handler.js",
     "./types.d.ts": "./types.d.ts",
     "./package.json": "./package.json"
@@ -34,24 +35,23 @@
     "types.d.ts"
   ],
   "dependencies": {
-    "@cloudflare/vite-plugin": "^1.17.0",
-    "@cloudflare/workers-types": "^4.20260116.0",
-    "dotenv": "^17.2.3",
+    "@cloudflare/vite-plugin": "^1.25.2",
     "piccolore": "^0.1.3",
     "tinyglobby": "^0.2.15",
-    "vite": "^7.1.12",
-    "@astrojs/internal-helpers": "0.7.5",
+    "vite": "^7.3.1",
+    "@astrojs/internal-helpers": "0.8.0-beta.1",
     "@astrojs/underscore-redirects": "1.0.0"
   },
   "peerDependencies": {
     "astro": "^6.0.0-alpha.0",
-    "wrangler": "^4.53.0"
+    "wrangler": "^4.61.1"
   },
   "devDependencies": {
-    "cheerio": "1.1.2",
-    "devalue": "^5.6.2",
-    "rollup": "^4.55.1",
-    "astro": "6.0.0-beta.2",
+    "@cloudflare/workers-types": "^4.20260228.0",
+    "@types/node": "^25.2.2",
+    "cheerio": "1.2.0",
+    "devalue": "^5.6.3",
+    "astro": "6.0.0-beta.16",
     "astro-scripts": "0.0.14"
   },
   "publishConfig": {
@@ -59,8 +59,8 @@
   },
   "scripts": {
     "dev": "astro-scripts dev \"src/**/*.ts\"",
-    "build": "astro-scripts build \"src/**/*.ts\" && tsc",
+    "build": "astro-scripts build \"src/**/*.ts\" --clean-dts && tsc",
     "build:ci": "astro-scripts build \"src/**/*.ts\"",
-    "test": "astro-scripts test \"test/**/*.test.js\""
+    "test": "astro-scripts test --force-exit \"test/**/*.test.js\""
   }
 }

package/types.d.ts

@@ -1,20 +1,5 @@
-/**
- * Cloudflare Worker Request types
- * Extends the global Request object with Cloudflare-specific properties
- */
+type Runtime = import('./dist/index.d.ts').Runtime;
 
-import type { IncomingRequestCfProperties } from '@cloudflare/workers-types';
-
-declare global {
-	interface Request {
-		/**
-		 * Cloudflare-specific properties available on incoming requests
-		 * Contains metadata about the request such as:
-		 * - Geographic information (country, colo, timezone)
-		 * - TLS/Security details (cipher, protocol version)
-		 * - Bot Management scores
-		 * - Client information (ASN, TCP metrics)
-		 */
-		readonly cf?: IncomingRequestCfProperties;
-	}
+declare namespace App {
+	interface Locals extends Runtime {}
 }

package/dist/entrypoints/image-endpoint.d.ts

@@ -1,3 +0,0 @@
-import type { APIRoute } from 'astro';
-export declare const prerender = false;
-export declare const GET: APIRoute;

package/dist/entrypoints/image-endpoint.js

@@ -1,29 +0,0 @@
-import { imageConfig } from "astro:assets";
-import { isRemotePath } from "@astrojs/internal-helpers/path";
-import { isRemoteAllowed } from "@astrojs/internal-helpers/remote";
-const prerender = false;
-const GET = (ctx) => {
-  const href = ctx.url.searchParams.get("href");
-  if (!href) {
-    return new Response("Missing 'href' query parameter", {
-      status: 400,
-      statusText: "Missing 'href' query parameter"
-    });
-  }
-  if (isRemotePath(href)) {
-    if (isRemoteAllowed(href, imageConfig) === false) {
-      return new Response("Forbidden", { status: 403 });
-    } else {
-      return Response.redirect(href, 302);
-    }
-  }
-  const proxied = new URL(href, ctx.url.origin);
-  if (proxied.origin !== ctx.url.origin) {
-    return new Response("Forbidden", { status: 403 });
-  }
-  return fetch(proxied);
-};
-export {
-  GET,
-  prerender
-};

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
-};