astro 7.1.5 → 7.2.0

package/dist/core/build/generate.js

@@ -1,12 +1,14 @@
 import nodeFs from "node:fs";
 import os from "node:os";
+import { fileURLToPath } from "node:url";
 import PLimit from "p-limit";
 import PQueue from "p-queue";
 import colors from "piccolore";
 import {
   generateImagesForPath,
   getStaticImageList,
-  prepareAssetsGenerationEnv
+  prepareAssetsGenerationEnv,
+  restoreStaticImages
 } from "../../assets/build/generate.js";
 import {
   appendForwardSlash,
@@ -18,6 +20,7 @@ import {
   trimSlashes
 } from "../../core/path.js";
 import { runHookBuildGenerated, toIntegrationResolvedRoute } from "../../integrations/hooks.js";
+import { hashCryptoKey } from "../encryption.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
 import { getRedirectLocationOrThrow } from "../redirects/index.js";
 import { createRequest } from "../request.js";
@@ -27,6 +30,14 @@ import { matchRoute } from "../routing/match.js";
 import { getOutputFilename } from "../output-filename.js";
 import { getOutFile, getOutFolder } from "./common.js";
 import { createDefaultPrerenderer } from "./default-prerenderer.js";
+import {
+  beginContentEntryCollection,
+  endContentEntryCollection
+} from "./incremental-content-collector.js";
+import { beginImageCollection, endImageCollection } from "./incremental-image-collector.js";
+import { IncrementalBuildCache } from "./incremental.js";
+import { computeConfigHash } from "./config-hash/index.js";
+import { computeLockfileHash } from "./lockfile/index.js";
 import { hasPrerenderedPages } from "./internal.js";
 import { getTimeStat, shouldAppendForwardSlash } from "./util.js";
 async function generatePages(options, internals, prerenderOutputDir) {
@@ -64,12 +75,38 @@ async function generatePages(options, internals, prerenderOutputDir) {
 ${colors.bgGreen(colors.black(` ${verb} static routes `))}`);
   const routeToHeaders = /* @__PURE__ */ new Map();
   let staticImageList = getStaticImageList();
+  let cache = null;
+  if (options.settings.config.experimental.incrementalBuild) {
+    if (options.settings.config.build.concurrency > 1) {
+      logger.warn(
+        "build",
+        "The incremental build cache is disabled because `build.concurrency` is greater than 1."
+      );
+    } else {
+      const [configHash, lockfileHash, keyDigest] = await Promise.all([
+        computeConfigHash(options.settings.config),
+        computeLockfileHash(fileURLToPath(options.settings.config.root)),
+        options.key.then(hashCryptoKey)
+      ]);
+      cache = IncrementalBuildCache.load(
+        options.settings,
+        configHash,
+        lockfileHash,
+        keyDigest,
+        internals.contentEntryRenderHashes ?? /* @__PURE__ */ new Map(),
+        options.force
+      );
+    }
+  }
   try {
     const pathsWithRoutes = await prerenderer.getStaticPaths();
     const hasI18nDomains = ssr && options.settings.config.i18n?.domains && Object.keys(options.settings.config.i18n.domains).length > 0;
     const { config } = options.settings;
     const builtPaths = /* @__PURE__ */ new Set();
-    const filteredPaths = pathsWithRoutes.filter(({ pathname, route }) => {
+    const filteredPaths = [];
+    const fallbackPaths = [];
+    for (const pathWithRoute of pathsWithRoutes) {
+      const { pathname, route } = pathWithRoute;
       if (hasI18nDomains && route.prerender) {
         throw new AstroError({
           ...AstroErrorData.NoPrerenderedRoutesWithDomains,
@@ -79,79 +116,108 @@ ${colors.bgGreen(colors.black(` ${verb} static routes `))}`);
       const normalized = removeTrailingForwardSlash(pathname);
       if (!builtPaths.has(normalized)) {
         builtPaths.add(normalized);
-        return true;
-      }
-      const matchedRoute = matchRoute(decodeURI(pathname), options.routesList);
-      if (!matchedRoute) {
-        return false;
-      }
-      if (matchedRoute === route) {
-        return true;
-      }
-      if (config.prerenderConflictBehavior === "error") {
-        throw new AstroError({
-          ...AstroErrorData.PrerenderRouteConflict,
-          message: AstroErrorData.PrerenderRouteConflict.message(
-            matchedRoute.route,
-            route.route,
-            normalized
-          ),
-          hint: AstroErrorData.PrerenderRouteConflict.hint(matchedRoute.route, route.route)
-        });
-      } else if (config.prerenderConflictBehavior === "warn") {
-        const msg = AstroErrorData.PrerenderRouteConflict.message(
-          matchedRoute.route,
-          route.route,
-          normalized
-        );
-        logger.warn("build", msg);
+      } else {
+        const matchedRoute = matchRoute(decodeURI(pathname), options.routesList);
+        if (!matchedRoute) {
+          continue;
+        }
+        if (matchedRoute !== route) {
+          if (config.prerenderConflictBehavior === "error") {
+            throw new AstroError({
+              ...AstroErrorData.PrerenderRouteConflict,
+              message: AstroErrorData.PrerenderRouteConflict.message(
+                matchedRoute.route,
+                route.route,
+                normalized
+              ),
+              hint: AstroErrorData.PrerenderRouteConflict.hint(matchedRoute.route, route.route)
+            });
+          } else if (config.prerenderConflictBehavior === "warn") {
+            const msg = AstroErrorData.PrerenderRouteConflict.message(
+              matchedRoute.route,
+              route.route,
+              normalized
+            );
+            logger.warn("build", msg);
+          }
+          continue;
+        }
       }
-      return false;
-    });
+      const paths = route.type === "fallback" ? fallbackPaths : filteredPaths;
+      paths.push(pathWithRoute);
+    }
+    const generationPhases = [filteredPaths, fallbackPaths];
     if (config.build.concurrency > 1) {
       const limit = PLimit(config.build.concurrency);
       const BATCH_SIZE = 1e5;
-      for (let i = 0; i < filteredPaths.length; i += BATCH_SIZE) {
-        const batch = filteredPaths.slice(i, i + BATCH_SIZE);
-        const promises = [];
-        for (const { pathname, route } of batch) {
-          promises.push(
-            limit(
+      for (const paths of generationPhases) {
+        for (let i = 0; i < paths.length; i += BATCH_SIZE) {
+          const promises = paths.slice(i, i + BATCH_SIZE).map(
+            ({ pathname, route, cacheKey }) => limit(
               () => generatePathWithPrerenderer(
                 prerenderer,
                 pathname,
                 route,
                 options,
+                internals,
                 routeToHeaders,
-                logger
+                logger,
+                cache,
+                cacheKey
               )
             )
           );
+          await Promise.all(promises);
         }
-        await Promise.all(promises);
       }
     } else {
-      for (const { pathname, route } of filteredPaths) {
-        await generatePathWithPrerenderer(
-          prerenderer,
-          pathname,
-          route,
-          options,
-          routeToHeaders,
-          logger
-        );
+      for (const paths of generationPhases) {
+        for (const { pathname, route, cacheKey } of paths) {
+          await generatePathWithPrerenderer(
+            prerenderer,
+            pathname,
+            route,
+            options,
+            internals,
+            routeToHeaders,
+            logger,
+            cache,
+            cacheKey
+          );
+        }
       }
     }
-    for (const { route: generatedRoute } of filteredPaths) {
-      if (generatedRoute.distURL && generatedRoute.distURL.length > 0) {
-        for (const pageData of Object.values(options.allPages)) {
-          if (pageData.route.route === generatedRoute.route && pageData.route.component === generatedRoute.component) {
-            pageData.route.distURL = generatedRoute.distURL;
-            break;
+    for (const paths of generationPhases) {
+      for (const { route: generatedRoute } of paths) {
+        if (generatedRoute.distURL && generatedRoute.distURL.length > 0) {
+          for (const pageData of Object.values(options.allPages)) {
+            if (pageData.route.route === generatedRoute.route && pageData.route.component === generatedRoute.component) {
+              pageData.route.distURL = generatedRoute.distURL;
+              break;
+            }
           }
         }
       }
     }
+    if (cache) {
+      const orphans = cache.findOrphanedFiles();
+      let pruned = 0;
+      for (const orphanFile of orphans) {
+        try {
+          await cache.deleteOutputFile(options.settings, orphanFile);
+          pruned++;
+        } catch (err) {
+          logger.warn(
+            "build",
+            `Could not prune stale incremental cache file ${orphanFile}: ${err}`
+          );
+        }
+      }
+      if (pruned > 0) {
+        logger.info("build", `Pruned ${pruned} stale file(s) from the incremental cache.`);
+      }
+      cache.writeManifest(options.settings);
+    }
     staticImageList = getStaticImageList();
     if (prerenderer.collectStaticImages) {
       const adapterImages = await prerenderer.collectStaticImages();
@@ -199,6 +265,9 @@ ${colors.bgGreen(colors.black(` ${verb} static routes `))}`);
   });
 }
 const THRESHOLD_SLOW_RENDER_TIME_MS = 500;
+function normalizePrerenderResult(result) {
+  return result instanceof Response ? { response: result } : result;
+}
 async function renderPath({
   prerenderer,
   pathname,
@@ -232,7 +301,8 @@ async function renderPath({
     options.origin,
     config.build.format,
     config.trailingSlash,
-    route.type
+    route.type,
+    route.isIndex
   );
   const request = createRequest({
     url,
@@ -242,8 +312,13 @@ async function renderPath({
     routePattern: route.component
   });
   let response;
+  let metadata;
   try {
-    response = await prerenderer.render(request, { routeData: route });
+    const rendered = normalizePrerenderResult(
+      await prerenderer.render(request, { routeData: route })
+    );
+    response = rendered.response;
+    metadata = rendered.metadata;
   } catch (err) {
     logger.error("build", `Caught error rendering ${pathname}: ${err}`);
     if (err && !AstroError.is(err) && !err.id && typeof err === "object") {
@@ -292,16 +367,65 @@ async function renderPath({
     routeToHeaders.set(pathname, { headers: responseHeaders, route: integrationRoute });
   }
   if (checkPublicConflict(outFile, route, options.settings, logger)) return null;
-  return { body, outFile, outFolder };
+  return { body, outFile, outFolder, metadata };
 }
-async function generatePathWithPrerenderer(prerenderer, pathname, route, options, routeToHeaders, logger) {
+async function generatePathWithPrerenderer(prerenderer, pathname, route, options, internals, routeToHeaders, logger, cache, cacheKey) {
   const timeStart = performance.now();
   const { config } = options.settings;
   const filePath = getOutputFilename(config.build.format, pathname, route);
+  const encodedPath = encodeURI(pathname);
+  const outFolder = getOutFolder(options.settings, encodedPath, route);
+  const outFile = getOutFile(config.build.format, outFolder, encodedPath, route);
+  const relativeOutFile = outFile.href.slice(config.outDir.href.length);
+  const dependencyHash = internals.pageDependencyHashes?.get(route.component) ?? "";
+  const hasServerIsland = internals.serverIslandPageComponents?.has(route.component) ?? false;
+  if (cacheKey !== void 0 && cache?.canSkip(route.component, pathname, dependencyHash, cacheKey, hasServerIsland)) {
+    const existsInDist = nodeFs.existsSync(outFile);
+    const restored = !existsInDist && await cache.restoreOutputFile(options.settings, relativeOutFile, outFile);
+    if (existsInDist || restored) {
+      const restoredImages = cache.previousStaticImages(route.component, pathname);
+      if (restoredImages) restoreStaticImages(restoredImages);
+      const restoredHeaders = cache.previousHeaders(route.component, pathname);
+      if (restoredHeaders && options.settings.adapter?.adapterFeatures?.staticHeaders) {
+        routeToHeaders.set(pathname, {
+          headers: new Headers(restoredHeaders),
+          route: toIntegrationResolvedRoute(route, config.trailingSlash)
+        });
+      }
+      cache.record(
+        route.component,
+        dependencyHash,
+        pathname,
+        cacheKey,
+        relativeOutFile,
+        cache.previousContentEntryKeys(route.component, pathname),
+        restoredImages,
+        restoredHeaders
+      );
+      if (route.type === "page") {
+        addPageName(pathname, options);
+      }
+      if (route.distURL) {
+        route.distURL.push(outFile);
+      } else {
+        route.distURL = [outFile];
+      }
+      logger.info(null, `  ${colors.green("\u251C\u2500")} ${colors.dim(filePath)}`, false);
+      logger.info(
+        "SKIP_FORMAT",
+        restored ? ` ${colors.green("(restored)")}` : ` ${colors.green("(cached)")}`
+      );
+      return;
+    }
+  }
   logger.info(null, `  ${colors.blue("\u251C\u2500")} ${colors.dim(filePath)}`, false);
   if (route.type === "page") {
     addPageName(pathname, options);
   }
+  if (cache) {
+    beginContentEntryCollection();
+    beginImageCollection();
+  }
   const result = await renderPath({
     prerenderer,
     pathname,
@@ -310,12 +434,30 @@ async function generatePathWithPrerenderer(prerenderer, pathname, route, options
     routeToHeaders,
     logger
   });
+  const collectedContentEntryKeys = cache ? endContentEntryCollection() : void 0;
+  const collectedStaticImages = cache ? endImageCollection() : void 0;
+  const contentEntryKeys = result?.metadata?.contentEntryKeys ?? collectedContentEntryKeys;
+  const staticImages = result?.metadata?.staticImages ?? collectedStaticImages;
+  const headers = cache ? [...routeToHeaders.get(pathname)?.headers ?? []] : void 0;
   if (!result) {
     logRenderTime(logger, timeStart, true);
     return;
   }
   await nodeFs.promises.mkdir(result.outFolder, { recursive: true });
   await nodeFs.promises.writeFile(result.outFile, result.body);
+  if (cache && cacheKey !== void 0) {
+    await cache.writeOutputFile(options.settings, relativeOutFile, result.body);
+    cache.record(
+      route.component,
+      dependencyHash,
+      pathname,
+      cacheKey,
+      relativeOutFile,
+      contentEntryKeys,
+      staticImages,
+      headers
+    );
+  }
   logRenderTime(logger, timeStart, false);
 }
 function logRenderTime(logger, timeStart, notCreated) {
@@ -331,11 +473,11 @@ function addPageName(pathname, opts) {
   const pageName = shouldAppendForwardSlash(trailingSlash, buildFormat) ? pathname.replace(/\/?$/, "/").replace(/^\//, "") : pathname.replace(/^\//, "");
   opts.pageNames.push(pageName);
 }
-function getUrlForPath(pathname, base, origin, format, trailingSlash, routeType) {
+function getUrlForPath(pathname, base, origin, format, trailingSlash, routeType, isIndex) {
   let ending;
-  switch (format) {
-    case "directory":
-    case "preserve": {
+  const effectiveFormat = format === "preserve" ? isIndex ? "directory" : "file" : format;
+  switch (effectiveFormat) {
+    case "directory": {
       ending = trailingSlash === "never" ? "" : "/";
       break;
     }
@@ -347,7 +489,7 @@ function getUrlForPath(pathname, base, origin, format, trailingSlash, routeType)
   }
   let buildPathname;
   if (pathname === "/" || pathname === "") {
-    if (format === "file") {
+    if (effectiveFormat === "file") {
       buildPathname = joinPaths(base, "index.html");
     } else {
       buildPathname = collapseDuplicateTrailingSlashes(base + ending, trailingSlash !== "never");

package/dist/core/build/incremental-content-collector.d.ts

@@ -0,0 +1,10 @@
+/** Start collecting the content entries rendered on the current path. */
+export declare function beginContentEntryCollection(): void;
+/** Record that a content entry was rendered, keyed by its root-relative `filePath`. */
+export declare function recordContentEntryRender(filePath: string | undefined): void;
+/**
+ * Finish collection and return the rendered entries, or `undefined` when no
+ * collection was active (so callers can distinguish "nothing rendered" from
+ * "not tracked").
+ */
+export declare function endContentEntryCollection(): string[] | undefined;

package/dist/core/build/incremental-content-collector.js

@@ -0,0 +1,33 @@
+const COLLECTOR_KEY = /* @__PURE__ */ Symbol.for("astro:incremental-content-entries");
+function collector() {
+  const host = globalThis;
+  let value = host[COLLECTOR_KEY];
+  if (!value) {
+    value = { current: void 0 };
+    Object.defineProperty(host, COLLECTOR_KEY, {
+      value,
+      configurable: false,
+      writable: false,
+      enumerable: false
+    });
+  }
+  return value;
+}
+function beginContentEntryCollection() {
+  collector().current = /* @__PURE__ */ new Set();
+}
+function recordContentEntryRender(filePath) {
+  if (!filePath) return;
+  collector().current?.add(filePath);
+}
+function endContentEntryCollection() {
+  const c = collector();
+  const entries = c.current;
+  c.current = void 0;
+  return entries ? [...entries] : void 0;
+}
+export {
+  beginContentEntryCollection,
+  endContentEntryCollection,
+  recordContentEntryRender
+};

package/dist/core/build/incremental-image-collector.d.ts

@@ -0,0 +1,11 @@
+import type { SerializedStaticImage } from '../../assets/types.js';
+/** Start collecting the image transforms resolved on the current path. */
+export declare function beginImageCollection(): void;
+/** Record an image transform resolved while rendering the current path. */
+export declare function recordStaticImage(image: SerializedStaticImage): void;
+/**
+ * Finish collection and return the collected transforms, or `undefined` when no
+ * collection was active (so callers can distinguish "no images" from
+ * "not tracked").
+ */
+export declare function endImageCollection(): SerializedStaticImage[] | undefined;

package/dist/core/build/incremental-image-collector.js

@@ -0,0 +1,32 @@
+const COLLECTOR_KEY = /* @__PURE__ */ Symbol.for("astro:incremental-static-images");
+function collector() {
+  const host = globalThis;
+  let value = host[COLLECTOR_KEY];
+  if (!value) {
+    value = { current: void 0 };
+    Object.defineProperty(host, COLLECTOR_KEY, {
+      value,
+      configurable: false,
+      writable: false,
+      enumerable: false
+    });
+  }
+  return value;
+}
+function beginImageCollection() {
+  collector().current = [];
+}
+function recordStaticImage(image) {
+  collector().current?.push(image);
+}
+function endImageCollection() {
+  const c = collector();
+  const images = c.current;
+  c.current = void 0;
+  return images;
+}
+export {
+  beginImageCollection,
+  endImageCollection,
+  recordStaticImage
+};

package/dist/core/build/incremental-metadata.d.ts

@@ -0,0 +1,9 @@
+export declare const ASTRO_INCREMENTAL_META_KEY = "astroIncremental";
+export declare function createContentDataIncrementalMetadata(): {
+    astroIncremental: {
+        kind: string;
+    };
+};
+export declare function isContentDataIncrementalModule(info: {
+    meta?: Record<string, any>;
+} | null | undefined): boolean;

package/dist/core/build/incremental-metadata.js

@@ -0,0 +1,17 @@
+const ASTRO_INCREMENTAL_META_KEY = "astroIncremental";
+function createContentDataIncrementalMetadata() {
+  return {
+    [ASTRO_INCREMENTAL_META_KEY]: {
+      kind: "content-data"
+    }
+  };
+}
+function isContentDataIncrementalModule(info) {
+  const metadata = info?.meta?.[ASTRO_INCREMENTAL_META_KEY];
+  return metadata?.kind === "content-data";
+}
+export {
+  ASTRO_INCREMENTAL_META_KEY,
+  createContentDataIncrementalMetadata,
+  isContentDataIncrementalModule
+};

package/dist/core/build/incremental.d.ts

@@ -0,0 +1,123 @@
+import type { SerializedStaticImage } from '../../assets/types.js';
+import type { AstroSettings } from '../../types/astro.js';
+export interface IncrementalPathEntry {
+    cacheKey: string;
+    outputFile: string;
+    /**
+     * Render-graph hashes of the content entries this path rendered, keyed by the
+     * entry's root-relative `filePath`. A change to any of these invalidates the
+     * path even when its template and data are unchanged, since content entries
+     * render behind `content-data` bridges the per-route hash cannot cross.
+     */
+    contentHashes?: Record<string, string>;
+    /**
+     * Optimized-image transforms this path resolved while rendering. Registered
+     * transforms are drained into the output after generation, but `dist/` is
+     * emptied each build, so a skipped path replays these into the global list to
+     * keep the images its restored HTML references from 404ing.
+     */
+    staticImages?: SerializedStaticImage[];
+    /**
+     * Response header name/value pairs a `staticHeaders` adapter collected for this
+     * path (chiefly the CSP header when delivered as a header rather than a `<meta>`
+     * tag). The `astro:build:generated` hook writes these to a static headers file,
+     * so a skipped path replays them to keep its route in that file.
+     */
+    headers?: [string, string][];
+}
+export interface IncrementalRouteEntry {
+    dependencyHash: string;
+    paths: Record<string, IncrementalPathEntry>;
+}
+/**
+ * On-disk shape of the incremental build cache.
+ */
+export interface IncrementalManifest {
+    version: number;
+    /**
+     * Hash of the output-affecting subset of the resolved config. A mismatch
+     * invalidates the whole cache, since config baked into compiled output or
+     * inlined via Vite cannot be seen by the per-route dependency hash.
+     */
+    configHash: string;
+    /**
+     * Hash of the project's lockfiles. Externalized dependencies are leaf nodes
+     * in the bundle graph with no code and a versionless id, so the per-route
+     * dependency hash cannot see when a (possibly transitive) dependency changes.
+     * A mismatch invalidates the whole cache.
+     */
+    lockfileHash: string;
+    /**
+     * Hash of the server-island encryption key. A page's island props are baked
+     * into its HTML as ciphertext bound to this key, so a restored page whose key
+     * has changed would be undecryptable at runtime. Server-island pages are only
+     * reused when this matches; it does not affect pages without islands.
+     */
+    keyDigest: string;
+    routes: Record<string, IncrementalRouteEntry>;
+}
+/**
+ * Tracks which prerendered paths can be reused from a previous build.
+ *
+ * The invalidation logic (`canSkip`, `record`, `findOrphanedFiles`) is pure and
+ * operates on the previous and next manifests held in memory. Disk access is
+ * confined to `load` and the output-file methods.
+ */
+export declare class IncrementalBuildCache {
+    #private;
+    constructor(configHash: string, lockfileHash: string, keyDigest: string, contentEntryHashes?: Map<string, string>, previous?: IncrementalManifest | null);
+    /**
+     * Load the cache from disk. When no valid manifest exists (missing, wrong
+     * version, or a config or lockfile hash mismatch) the returned cache has no
+     * previous build, so every path is rendered as a full build.
+     *
+     * `contentEntryHashes` is this build's map of content-entry render hashes,
+     * used to detect when the content a path renders has changed.
+     *
+     * `force` ignores any existing manifest so every path is rebuilt, while still
+     * recording a fresh cache for the next build.
+     */
+    static load(settings: AstroSettings, configHash: string, lockfileHash: string, keyDigest: string, contentEntryHashes?: Map<string, string>, force?: boolean): IncrementalBuildCache;
+    /**
+     * Determine if a path can be reused from the previous build. A path is
+     * skippable when:
+     * 1. It returned a cacheKey in this build.
+     * 2. The previous cache has an entry for the route.
+     * 3. The route's dependency hash matches the previous build (template code is identical).
+     * 4. The previous cache has an entry for this exact path.
+     * 5. The path's cacheKey matches the previous build (user data is identical).
+     * 6. Every content entry the path rendered last build still has a matching
+     *    render hash (imported components inside that content are unchanged).
+     * 7. If the path renders a server island, the encryption key is unchanged, so
+     *    the ciphertext baked into the restored HTML is still decryptable.
+     */
+    canSkip(routeComponent: string, pathname: string, dependencyHash: string, cacheKey: string, hasServerIsland?: boolean): boolean;
+    /**
+     * The content entries a path rendered in the previous build, so a skipped path
+     * can carry its content-entry tracking forward without re-rendering.
+     */
+    previousContentEntryKeys(routeComponent: string, pathname: string): string[] | undefined;
+    /**
+     * The image transforms a path resolved in the previous build, so a skipped
+     * path can replay them and carry them forward without re-rendering.
+     */
+    previousStaticImages(routeComponent: string, pathname: string): SerializedStaticImage[] | undefined;
+    /**
+     * The response headers a path collected in the previous build, so a skipped
+     * path can replay them into a `staticHeaders` adapter's headers file.
+     */
+    previousHeaders(routeComponent: string, pathname: string): [string, string][] | undefined;
+    /** Record a path in the next manifest so a later build can skip or prune it. */
+    record(routeComponent: string, dependencyHash: string, pathname: string, cacheKey: string, outputFile: string, contentEntryKeys?: string[], staticImages?: SerializedStaticImage[], headers?: [string, string][]): void;
+    /**
+     * Cache copies recorded in the previous build that are no longer keyed in this
+     * one, either because the path was removed from `getStaticPaths()` or dropped
+     * its `cacheKey`. Their stored copies are stale and should be pruned. Paths
+     * that are still keyed keep their copies, even when the `cacheKey` changed.
+     */
+    findOrphanedFiles(): string[];
+    writeManifest(settings: AstroSettings): void;
+    restoreOutputFile(settings: AstroSettings, outputFile: string, destination: URL): Promise<boolean>;
+    writeOutputFile(settings: AstroSettings, outputFile: string, body: string | Uint8Array): Promise<void>;
+    deleteOutputFile(settings: AstroSettings, outputFile: string): Promise<void>;
+}