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

package/dist/prerenderer.js

@@ -0,0 +1,116 @@
+import { preview } from "vite";
+import { fileURLToPath } from "node:url";
+import { mkdir } from "node:fs/promises";
+import { cloudflare as cfVitePlugin } from "@cloudflare/vite-plugin";
+import { serializeRouteData, deserializeRouteData } from "astro/app/manifest";
+import {
+  STATIC_PATHS_ENDPOINT,
+  PRERENDER_ENDPOINT,
+  STATIC_IMAGES_ENDPOINT
+} from "./utils/prerender-constants.js";
+function createCloudflarePrerenderer({
+  root,
+  serverDir,
+  clientDir,
+  base,
+  trailingSlash,
+  cfPluginConfig,
+  hasCompileImageService
+}) {
+  let previewServer;
+  let serverUrl;
+  return {
+    name: "@astrojs/cloudflare:prerenderer",
+    async setup() {
+      await mkdir(clientDir, { recursive: true });
+      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, viteEnvironment: { name: "prerender" } })]
+      });
+      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;
+    },
+    collectStaticImages: hasCompileImageService ? async () => {
+      const response = await fetch(`${serverUrl}${STATIC_IMAGES_ENDPOINT}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" }
+      });
+      if (!response.ok) {
+        throw new Error(
+          `Failed to get static images from the Cloudflare prerender server (${response.status}: ${response.statusText}).`
+        );
+      }
+      const entries = await response.json();
+      const { default: sharpService } = await import("astro/assets/services/sharp");
+      globalThis.astroAsset ??= {};
+      globalThis.astroAsset.imageService = sharpService;
+      const staticImages = /* @__PURE__ */ new Map();
+      for (const entry of entries) {
+        const transforms = /* @__PURE__ */ new Map();
+        for (const t of entry.transforms) {
+          transforms.set(t.hash, { finalPath: t.finalPath, transform: t.transform });
+        }
+        staticImages.set(entry.originalPath, {
+          originalSrcPath: entry.originalSrcPath,
+          transforms
+        });
+      }
+      return staticImages;
+    } : void 0,
+    async teardown() {
+      if (previewServer) {
+        await previewServer.close();
+        previewServer = void 0;
+      }
+    }
+  };
+}
+export {
+  createCloudflarePrerenderer
+};

package/dist/utils/generate-routes-json.d.ts

@@ -1,9 +1,2 @@
-import type { AstroConfig, AstroIntegrationLogger, IntegrationResolvedRoute, RoutePart } from 'astro';
+import type { RoutePart } from 'astro';
 export declare function getParts(part: string): RoutePart[];
-export declare function createRoutesFile(_config: AstroConfig, logger: AstroIntegrationLogger, routes: IntegrationResolvedRoute[], pages: {
-    pathname: string;
-}[], redirects: IntegrationResolvedRoute['segments'][], includeExtends: {
-    pattern: string;
-}[] | undefined, excludeExtends: {
-    pattern: string;
-}[] | undefined): Promise<void>;

package/dist/utils/generate-routes-json.js

@@ -1,13 +1,3 @@
-import { existsSync } from "node:fs";
-import { writeFile } from "node:fs/promises";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import {
-  prependForwardSlash,
-  removeLeadingForwardSlash,
-  removeTrailingForwardSlash
-} from "@astrojs/internal-helpers/path";
-import { glob } from "tinyglobby";
 const ROUTE_DYNAMIC_SPLIT = /\[(.+?\(.+?\)|.+?)\]/;
 const ROUTE_SPREAD = /^\.{3}.+$/;
 function getParts(part) {
@@ -27,199 +17,6 @@ function getParts(part) {
   });
   return result;
 }
-async function writeRoutesFileToOutDir(_config, logger, include, exclude) {
-  try {
-    await writeFile(
-      new URL("./_routes.json", _config.outDir),
-      JSON.stringify(
-        {
-          version: 1,
-          include,
-          exclude
-        },
-        null,
-        2
-      ),
-      "utf-8"
-    );
-  } catch (_error) {
-    logger.error("There was an error writing the '_routes.json' file to the output directory.");
-  }
-}
-function segmentsToCfSyntax(segments, _config) {
-  const pathSegments = [];
-  if (removeLeadingForwardSlash(removeTrailingForwardSlash(_config.base)).length > 0) {
-    pathSegments.push(removeLeadingForwardSlash(removeTrailingForwardSlash(_config.base)));
-  }
-  for (const segment of segments.flat()) {
-    if (segment.dynamic) pathSegments.push("*");
-    else pathSegments.push(segment.content);
-  }
-  return pathSegments;
-}
-class TrieNode {
-  children = /* @__PURE__ */ new Map();
-  isEndOfPath = false;
-  hasWildcardChild = false;
-}
-class PathTrie {
-  root;
-  returnHasWildcard = false;
-  constructor() {
-    this.root = new TrieNode();
-  }
-  insert(thisPath) {
-    let node = this.root;
-    for (const segment of thisPath) {
-      if (segment === "*") {
-        node.hasWildcardChild = true;
-        break;
-      }
-      if (!node.children.has(segment)) {
-        node.children.set(segment, new TrieNode());
-      }
-      node = node.children.get(segment);
-    }
-    node.isEndOfPath = true;
-  }
-  /**
-   * Depth-first search (dfs), traverses the "graph"  segment by segment until the end or wildcard (*).
-   * It makes sure that all necessary paths are returned, but not paths with an existing wildcard prefix.
-   * e.g. if we have a path like /foo/* and /foo/bar, we only want to return /foo/*
-   */
-  dfs(node, thisPath, allPaths) {
-    if (node.hasWildcardChild) {
-      this.returnHasWildcard = true;
-      allPaths.push([...thisPath, "*"]);
-      return;
-    }
-    if (node.isEndOfPath) {
-      allPaths.push([...thisPath]);
-    }
-    for (const [segment, childNode] of node.children) {
-      this.dfs(childNode, [...thisPath, segment], allPaths);
-    }
-  }
-  /**
-   * The reduce function is used to remove unnecessary paths from the trie.
-   * It receives a trie node to compare with the current node.
-   */
-  reduce(compNode, node) {
-    if (node.hasWildcardChild || compNode.hasWildcardChild) return;
-    for (const [segment, childNode] of node.children) {
-      if (childNode.children.size === 0) continue;
-      const compChildNode = compNode.children.get(segment);
-      if (compChildNode === void 0) {
-        childNode.hasWildcardChild = true;
-        continue;
-      }
-      this.reduce(compChildNode, childNode);
-    }
-  }
-  reduceAllPaths(compTrie) {
-    this.reduce(compTrie.root, this.root);
-    return this;
-  }
-  getAllPaths() {
-    const allPaths = [];
-    this.dfs(this.root, [], allPaths);
-    return [allPaths, this.returnHasWildcard];
-  }
-}
-async function createRoutesFile(_config, logger, routes, pages, redirects, includeExtends, excludeExtends) {
-  const includePaths = [];
-  const excludePaths = [];
-  const assetsPath = segmentsToCfSyntax(
-    [
-      [{ content: _config.build.assets, dynamic: false, spread: false }],
-      [{ content: "", dynamic: true, spread: false }]
-    ],
-    _config
-  );
-  excludePaths.push(assetsPath);
-  for (const redirect of redirects) {
-    excludePaths.push(segmentsToCfSyntax(redirect, _config));
-  }
-  if (existsSync(fileURLToPath(_config.publicDir))) {
-    const staticFiles = await glob(`**/*`, {
-      cwd: fileURLToPath(_config.publicDir),
-      dot: true
-    });
-    for (const staticFile of staticFiles) {
-      if (["_headers", "_redirects", "_routes.json"].includes(staticFile)) continue;
-      const staticPath = staticFile;
-      const segments = removeLeadingForwardSlash(staticPath).split(path.sep).filter(Boolean).map((s) => {
-        return getParts(s);
-      });
-      excludePaths.push(segmentsToCfSyntax(segments, _config));
-    }
-  }
-  let hasPrerendered404 = false;
-  for (const route of routes) {
-    const convertedPath = segmentsToCfSyntax(route.segments, _config);
-    if (route.pathname === "/404" && route.isPrerendered === true) hasPrerendered404 = true;
-    switch (route.type) {
-      case "page":
-        if (route.isPrerendered === false) includePaths.push(convertedPath);
-        break;
-      case "endpoint":
-        if (route.isPrerendered === false) includePaths.push(convertedPath);
-        else excludePaths.push(convertedPath);
-        break;
-      case "redirect":
-        excludePaths.push(convertedPath);
-        break;
-      default:
-        includePaths.push(convertedPath);
-        break;
-    }
-  }
-  for (const page of pages) {
-    if (page.pathname === "404") hasPrerendered404 = true;
-    const pageSegments = removeLeadingForwardSlash(page.pathname).split(path.posix.sep).filter(Boolean).map((s) => {
-      return getParts(s);
-    });
-    excludePaths.push(segmentsToCfSyntax(pageSegments, _config));
-  }
-  const includeTrie = new PathTrie();
-  for (const includePath of includePaths) {
-    includeTrie.insert(includePath);
-  }
-  const excludeTrie = new PathTrie();
-  for (const excludePath of excludePaths) {
-    if (excludePath[0] === "*") continue;
-    excludeTrie.insert(excludePath);
-  }
-  const [deduplicatedIncludePaths, includedPathsHaveWildcard] = includeTrie.reduceAllPaths(excludeTrie).getAllPaths();
-  const [deduplicatedExcludePaths, _excludedPathsHaveWildcard] = excludeTrie.reduceAllPaths(includeTrie).getAllPaths();
-  const CLOUDFLARE_COMBINED_LIMIT = 100;
-  const AUTOMATIC_INCLUDE_RULES_COUNT = deduplicatedIncludePaths.length;
-  const EXTENDED_INCLUDE_RULES_COUNT = includeExtends?.length ?? 0;
-  const INCLUDE_RULES_COUNT = AUTOMATIC_INCLUDE_RULES_COUNT + EXTENDED_INCLUDE_RULES_COUNT;
-  const AUTOMATIC_EXCLUDE_RULES_COUNT = deduplicatedExcludePaths.length;
-  const EXTENDED_EXCLUDE_RULES_COUNT = excludeExtends?.length ?? 0;
-  const EXCLUDE_RULES_COUNT = AUTOMATIC_EXCLUDE_RULES_COUNT + EXTENDED_EXCLUDE_RULES_COUNT;
-  const OPTION2_TOTAL_COUNT = INCLUDE_RULES_COUNT + (includedPathsHaveWildcard ? EXCLUDE_RULES_COUNT : 0);
-  if (!hasPrerendered404 || OPTION2_TOTAL_COUNT > CLOUDFLARE_COMBINED_LIMIT) {
-    await writeRoutesFileToOutDir(
-      _config,
-      logger,
-      ["/*"].concat(includeExtends?.map((entry) => entry.pattern) ?? []),
-      deduplicatedExcludePaths.map((thisPath) => `${prependForwardSlash(thisPath.join("/"))}`).slice(
-        0,
-        CLOUDFLARE_COMBINED_LIMIT - EXTENDED_INCLUDE_RULES_COUNT - EXTENDED_EXCLUDE_RULES_COUNT - 1
-      ).concat(excludeExtends?.map((entry) => entry.pattern) ?? [])
-    );
-  } else {
-    await writeRoutesFileToOutDir(
-      _config,
-      logger,
-      deduplicatedIncludePaths.map((thisPath) => `${prependForwardSlash(thisPath.join("/"))}`).concat(includeExtends?.map((entry) => entry.pattern) ?? []),
-      includedPathsHaveWildcard ? deduplicatedExcludePaths.map((thisPath) => `${prependForwardSlash(thisPath.join("/"))}`).concat(excludeExtends?.map((entry) => entry.pattern) ?? []) : []
-    );
-  }
-}
 export {
-  createRoutesFile,
   getParts
 };

package/dist/utils/handler.d.ts

@@ -1,14 +1,9 @@
-import type { Response as CfResponse, ExecutionContext, ExportedHandlerFetchHandler } from '@cloudflare/workers-types';
-export type Env = {
-    [key: string]: unknown;
-    ASSETS: {
-        fetch: (req: Request | string) => Promise<CfResponse>;
-    };
-};
 export interface Runtime {
     cfContext: ExecutionContext;
 }
 declare global {
     var __ASTRO_IMAGES_BINDING_NAME: string;
 }
-export declare function handle(request: Parameters<ExportedHandlerFetchHandler>[0], env: Env, context: ExecutionContext): Promise<CfResponse>;
+type CfResponse = Awaited<ReturnType<Required<ExportedHandler<Env>>['fetch']>>;
+export declare function handle(request: Request, env: Env, context: ExecutionContext): Promise<CfResponse>;
+export {};

package/dist/utils/handler.js

@@ -1,26 +1,51 @@
 import { env as globalEnv } from "cloudflare:workers";
-import { sessionKVBindingName } from "virtual:astro-cloudflare:config";
+import {
+  sessionKVBindingName,
+  compileImageConfig,
+  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,
+  isStaticImagesRequest,
+  handleStaticImagesRequest
+} 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 (compileImageConfig) {
+      const { installAddStaticImage } = await import("./static-image-collection.js");
+      installAddStaticImage(compileImageConfig);
+    }
+    if (isStaticPathsRequest(request)) {
+      return handleStaticPathsRequest(app);
+    }
+    if (isPrerenderRequest(request)) {
+      return handlePrerenderRequest(app, request);
+    }
+    if (isStaticImagesRequest(request)) {
+      return handleStaticImagesRequest();
+    }
+  }
+  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;
   if (app.isDev()) {
-    const result = await app.devMatch(
-      app.getPathnameFromRequest(request)
-    );
+    const result = await app.devMatch(app.getPathnameFromRequest(request));
     if (result) {
       routeData = result.routeData;
     }
@@ -63,17 +88,14 @@ async function handle(request, env, context) {
       }
     }
   });
-  const response = await app.render(
-    request,
-    {
-      routeData,
-      locals,
-      prerenderedErrorPageFetch: async (url) => {
-        return env.ASSETS.fetch(url.replace(/\.html$/, ""));
-      },
-      clientAddress: request.headers.get("cf-connecting-ip") ?? void 0
-    }
-  );
+  const response = await app.render(request, {
+    routeData,
+    locals,
+    prerenderedErrorPageFetch: async (url) => {
+      return env.ASSETS.fetch(url.replace(/\.html$/, ""));
+    },
+    clientAddress: request.headers.get("cf-connecting-ip") ?? void 0
+  });
   if (app.setCookieHeaders) {
     for (const setCookieHeader of app.setCookieHeaders(response)) {
       response.headers.append("Set-Cookie", setCookieHeader);

package/dist/utils/image-binding-transform.d.ts

@@ -1,2 +1 @@
-import type { Fetcher, ImagesBinding } from '@cloudflare/workers-types';
-export declare function transform(rawUrl: string, images: ImagesBinding, assets: Fetcher): Promise<import("@cloudflare/workers-types").Response | Response>;
+export declare function transform(rawUrl: string, images: ImagesBinding, assets: Fetcher): Promise<Response>;

package/dist/utils/image-binding-transform.js

@@ -13,17 +13,25 @@ async function transform(rawUrl, images, assets) {
     return new Response(null, { status: 404 });
   }
   const input = images.input(content.body);
-  const format = url.searchParams.get("f");
-  if (!format || !["avif", "webp", "jpeg"].includes(format)) {
-    return new Response(`The "${format}" format is not supported`, { status: 400 });
+  const supportedFormats = {
+    jpeg: "image/jpeg",
+    jpg: "image/jpeg",
+    png: "image/png",
+    gif: "image/gif",
+    webp: "image/webp",
+    avif: "image/avif"
+  };
+  const outputFormat = supportedFormats[url.searchParams.get("f") ?? ""];
+  if (!outputFormat) {
+    return new Response(`Unsupported format: ${url.searchParams.get("f")}`, { status: 400 });
   }
   return (await input.transform({
-    width: url.searchParams.has("w") ? parseInt(url.searchParams.get("w")) : void 0,
-    height: url.searchParams.has("h") ? parseInt(url.searchParams.get("h")) : void 0,
+    width: url.searchParams.has("w") ? Number.parseInt(url.searchParams.get("w")) : void 0,
+    height: url.searchParams.has("h") ? Number.parseInt(url.searchParams.get("h")) : void 0,
     // `quality` is documented, but doesn't appear to work in manual testing...
     // quality: url.searchParams.get('q'),
     fit: url.searchParams.get("fit")
-  }).output({ format: `image/${format}` })).response();
+  }).output({ format: outputFormat })).response();
 }
 export {
   transform

package/dist/utils/image-config.d.ts

@@ -1,8 +1,19 @@
 import type { AstroConfig, AstroIntegrationLogger, HookParameters } from 'astro';
-export type ImageService = 'passthrough' | 'cloudflare' | 'cloudflare-binding' | 'compile' | 'custom';
-export declare function setImageConfig(service: ImageService, config: AstroConfig['image'], command: HookParameters<'astro:config:setup'>['command'], logger: AstroIntegrationLogger): {
+export type ImageServiceMode = 'passthrough' | 'cloudflare' | 'cloudflare-binding' | 'compile' | 'custom';
+export type ImageServiceConfig = ImageServiceMode | {
+    build: 'compile';
+    runtime?: 'passthrough' | 'cloudflare-binding';
+};
+/** Normalize string | compound config into separate build/runtime modes. */
+export declare function normalizeImageServiceConfig(config: ImageServiceConfig | undefined): {
+    buildService: ImageServiceMode;
+    runtimeService: ImageServiceMode;
+};
+export declare function setImageConfig(service: ImageServiceConfig | undefined, config: AstroConfig['image'], command: HookParameters<'astro:config:setup'>['command'], logger: AstroIntegrationLogger): {
     service: import("astro").ImageServiceConfig<Record<string, any>>;
     endpoint: {
+        entrypoint: string;
+    } | {
         route: string;
         entrypoint?: string | undefined;
     };
@@ -14,14 +25,16 @@ export declare function setImageConfig(service: ImageService, config: AstroConfi
         pathname?: string | undefined;
     }[];
     responsiveStyles: boolean;
-    layout?: "none" | "fixed" | "constrained" | "full-width" | undefined;
+    layout?: "fixed" | "none" | "constrained" | "full-width" | undefined;
     objectFit?: string | undefined;
     objectPosition?: string | undefined;
     breakpoints?: number[] | undefined;
 } | {
-    service: import("astro").ImageServiceConfig<Record<string, any>>;
+    service: {
+        entrypoint: string;
+    };
     endpoint: {
-        entrypoint: string | undefined;
+        entrypoint: string;
     };
     domains: string[];
     remotePatterns: {
@@ -31,7 +44,7 @@ export declare function setImageConfig(service: ImageService, config: AstroConfi
         pathname?: string | undefined;
     }[];
     responsiveStyles: boolean;
-    layout?: "none" | "fixed" | "constrained" | "full-width" | undefined;
+    layout?: "fixed" | "none" | "constrained" | "full-width" | undefined;
     objectFit?: string | undefined;
     objectPosition?: string | undefined;
     breakpoints?: number[] | undefined;

package/dist/utils/image-config.js

@@ -1,16 +1,37 @@
-import { passthroughImageService, sharpImageService } from "astro/config";
+import { passthroughImageService } from "astro/config";
+function normalizeImageServiceConfig(config) {
+  if (!config || typeof config === "string") {
+    const mode = config ?? "cloudflare-binding";
+    return {
+      buildService: mode,
+      runtimeService: mode === "compile" ? "passthrough" : mode
+    };
+  }
+  return {
+    buildService: "compile",
+    runtimeService: config.runtime ?? "passthrough"
+  };
+}
+const GENERIC_ENDPOINT = { entrypoint: "astro/assets/endpoint/generic" };
+const WORKERD_IMAGE_SERVICE = { entrypoint: "@astrojs/cloudflare/image-service-workerd" };
 function setImageConfig(service, config, command, logger) {
-  switch (service) {
+  const { buildService, runtimeService } = normalizeImageServiceConfig(service);
+  switch (buildService) {
     case "passthrough":
-      return { ...config, service: passthroughImageService() };
+      return {
+        ...config,
+        service: passthroughImageService(),
+        endpoint: command === "dev" ? GENERIC_ENDPOINT : config.endpoint
+      };
     case "cloudflare":
       return {
         ...config,
-        service: command === "dev" ? sharpImageService() : { entrypoint: "@astrojs/cloudflare/image-service" }
+        service: { entrypoint: "@astrojs/cloudflare/image-service" }
       };
     case "cloudflare-binding":
       return {
         ...config,
+        service: WORKERD_IMAGE_SERVICE,
         endpoint: {
           entrypoint: "@astrojs/cloudflare/image-transform-endpoint"
         }
@@ -18,10 +39,10 @@ function setImageConfig(service, config, command, logger) {
     case "compile":
       return {
         ...config,
-        service: sharpImageService(),
-        endpoint: {
-          entrypoint: command === "dev" ? void 0 : "@astrojs/cloudflare/image-endpoint"
-        }
+        service: WORKERD_IMAGE_SERVICE,
+        // Dev: IMAGES binding (via Cloudflare Vite plugin) for real transforms.
+        // Build: endpoint depends on runtime - `cloudflare-binding` uses IMAGES, `passthrough` uses generic.
+        endpoint: command === "dev" || runtimeService === "cloudflare-binding" ? { entrypoint: "@astrojs/cloudflare/image-transform-endpoint" } : GENERIC_ENDPOINT
       };
     case "custom":
       return { ...config };
@@ -36,5 +57,6 @@ function setImageConfig(service, config, command, logger) {
   }
 }
 export {
+  normalizeImageServiceConfig,
   setImageConfig
 };

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

@@ -0,0 +1,9 @@
+/**
+ * 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";
+/** Internal endpoint for fetching static images collected in workerd during `compile` builds */
+export declare const STATIC_IMAGES_ENDPOINT = "/__astro_static_images";

package/dist/utils/prerender-constants.js

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

package/dist/utils/prerender.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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>;
+export declare function isStaticImagesRequest(request: Request): boolean;
+/** Serializes the global staticImages map collected in workerd back to the Node-side build. */
+export declare function handleStaticImagesRequest(): Response;