astro 7.1.6 → 7.2.1

package/dist/core/build/incremental.js

@@ -0,0 +1,178 @@
+import fs from "node:fs";
+const INCREMENTAL_CACHE_FILE = "incremental-build.json";
+const INCREMENTAL_OUTPUT_DIR = "dist/";
+const CACHE_VERSION = 1;
+function getManifestFile(settings) {
+  return new URL(INCREMENTAL_CACHE_FILE, settings.config.cacheDir);
+}
+function getCachedOutputFile(settings, outputFile) {
+  return new URL(outputFile, new URL(INCREMENTAL_OUTPUT_DIR, settings.config.cacheDir));
+}
+function readManifest(settings, expectedConfigHash, expectedLockfileHash) {
+  try {
+    const raw = fs.readFileSync(getManifestFile(settings), "utf-8");
+    const data = JSON.parse(raw);
+    if (data.version !== CACHE_VERSION) {
+      return null;
+    }
+    if (data.configHash !== expectedConfigHash) {
+      return null;
+    }
+    if (data.lockfileHash !== expectedLockfileHash) {
+      return null;
+    }
+    return data;
+  } catch {
+    return null;
+  }
+}
+class IncrementalBuildCache {
+  #previous;
+  #next;
+  #contentEntryHashes;
+  #createdDirs = /* @__PURE__ */ new Set();
+  constructor(configHash, lockfileHash, keyDigest, contentEntryHashes = /* @__PURE__ */ new Map(), previous = null) {
+    this.#previous = previous;
+    this.#contentEntryHashes = contentEntryHashes;
+    this.#next = { version: CACHE_VERSION, configHash, lockfileHash, keyDigest, routes: {} };
+  }
+  /**
+   * 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, configHash, lockfileHash, keyDigest, contentEntryHashes = /* @__PURE__ */ new Map(), force = false) {
+    return new IncrementalBuildCache(
+      configHash,
+      lockfileHash,
+      keyDigest,
+      contentEntryHashes,
+      force ? null : readManifest(settings, configHash, lockfileHash)
+    );
+  }
+  /**
+   * 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, pathname, dependencyHash, cacheKey, hasServerIsland = false) {
+    const routeEntry = this.#previous?.routes[routeComponent];
+    if (!routeEntry) return false;
+    if (hasServerIsland && this.#previous?.keyDigest !== this.#next.keyDigest) return false;
+    if (routeEntry.dependencyHash !== dependencyHash) return false;
+    const pathEntry = routeEntry.paths[pathname];
+    if (!pathEntry) return false;
+    if (pathEntry.cacheKey !== cacheKey) return false;
+    if (pathEntry.contentHashes) {
+      for (const [entryPath, previousHash] of Object.entries(pathEntry.contentHashes)) {
+        if (this.#contentEntryHashes.get(entryPath) !== previousHash) return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * 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, pathname) {
+    const pathEntry = this.#previous?.routes[routeComponent]?.paths[pathname];
+    return pathEntry?.contentHashes ? Object.keys(pathEntry.contentHashes) : void 0;
+  }
+  /**
+   * 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, pathname) {
+    return this.#previous?.routes[routeComponent]?.paths[pathname]?.staticImages;
+  }
+  /**
+   * 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, pathname) {
+    return this.#previous?.routes[routeComponent]?.paths[pathname]?.headers;
+  }
+  /** Record a path in the next manifest so a later build can skip or prune it. */
+  record(routeComponent, dependencyHash, pathname, cacheKey, outputFile, contentEntryKeys, staticImages, headers) {
+    let routeEntry = this.#next.routes[routeComponent];
+    if (!routeEntry) {
+      routeEntry = { dependencyHash, paths: {} };
+      this.#next.routes[routeComponent] = routeEntry;
+    }
+    routeEntry.dependencyHash = dependencyHash;
+    const pathEntry = { cacheKey, outputFile };
+    if (contentEntryKeys && contentEntryKeys.length > 0) {
+      const contentHashes = {};
+      for (const key of contentEntryKeys) {
+        const hash = this.#contentEntryHashes.get(key);
+        if (hash !== void 0) contentHashes[key] = hash;
+      }
+      if (Object.keys(contentHashes).length > 0) pathEntry.contentHashes = contentHashes;
+    }
+    if (staticImages && staticImages.length > 0) pathEntry.staticImages = staticImages;
+    if (headers && headers.length > 0) pathEntry.headers = headers;
+    routeEntry.paths[pathname] = pathEntry;
+  }
+  /**
+   * 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() {
+    if (!this.#previous) return [];
+    const orphans = [];
+    for (const [routeComponent, routeEntry] of Object.entries(this.#previous.routes)) {
+      const nextRouteEntry = this.#next.routes[routeComponent];
+      for (const [pathname, pathEntry] of Object.entries(routeEntry.paths)) {
+        if (!nextRouteEntry?.paths[pathname]) {
+          orphans.push(pathEntry.outputFile);
+        }
+      }
+    }
+    return orphans;
+  }
+  writeManifest(settings) {
+    const manifestFile = getManifestFile(settings);
+    fs.mkdirSync(new URL("./", manifestFile), { recursive: true });
+    fs.writeFileSync(manifestFile, JSON.stringify(this.#next, null, "	"));
+  }
+  async restoreOutputFile(settings, outputFile, destination) {
+    const cachedOutputFile = getCachedOutputFile(settings, outputFile);
+    if (!fs.existsSync(cachedOutputFile)) return false;
+    await this.#ensureDir(new URL("./", destination));
+    await fs.promises.copyFile(cachedOutputFile, destination);
+    return true;
+  }
+  async writeOutputFile(settings, outputFile, body) {
+    const cachedOutputFile = getCachedOutputFile(settings, outputFile);
+    await this.#ensureDir(new URL("./", cachedOutputFile));
+    await fs.promises.writeFile(cachedOutputFile, body);
+  }
+  async deleteOutputFile(settings, outputFile) {
+    await fs.promises.rm(getCachedOutputFile(settings, outputFile), { force: true });
+  }
+  async #ensureDir(dir) {
+    const key = dir.href;
+    if (this.#createdDirs.has(key)) return;
+    await fs.promises.mkdir(dir, { recursive: true });
+    this.#createdDirs.add(key);
+  }
+}
+export {
+  IncrementalBuildCache
+};

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

@@ -31,6 +31,8 @@ interface AstroBuilderOptions extends BuildOptions {
      * Set to false for in-memory builds that don't need type generation.
      */
     sync?: boolean;
+    /** Set by `astro build --force` to rebuild every page and ignore the incremental cache. */
+    force?: boolean;
 }
 export declare class AstroBuilder {
     private settings;
@@ -41,6 +43,7 @@ export declare class AstroBuilder {
     private routesList;
     private timer;
     private sync;
+    private force;
     constructor(settings: AstroSettings, options: AstroBuilderOptions);
     /** Setup Vite and run any async setup logic that couldn't run inside of the constructor. */
     private setup;

package/dist/core/build/index.js

@@ -44,7 +44,8 @@ async function build(inlineConfig, options = {}) {
     ...options,
     logger,
     mode: inlineConfig.mode ?? "production",
-    runtimeMode: options.devOutput ? "development" : "production"
+    runtimeMode: options.devOutput ? "development" : "production",
+    force: inlineConfig.force ?? false
   });
   await builder.run();
 }
@@ -57,12 +58,14 @@ class AstroBuilder {
   routesList;
   timer;
   sync;
+  force;
   constructor(settings, options) {
     this.mode = options.mode;
     this.runtimeMode = options.runtimeMode;
     this.settings = settings;
     this.logger = options.logger;
     this.sync = options.sync ?? true;
+    this.force = options.force ?? false;
     this.origin = settings.config.site ? new URL(settings.config.site).origin : `http://localhost:${settings.config.server.port}`;
     this.routesList = options.routesList ?? { routes: [] };
     this.timer = {};
@@ -151,7 +154,8 @@ class AstroBuilder {
       origin: this.origin,
       pageNames,
       viteConfig,
-      key: keyPromise
+      key: keyPromise,
+      force: this.force
     };
     await viteBuild(opts);
     this.timer.assetsStart = performance.now();

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

@@ -107,6 +107,25 @@ export interface BuildInternals {
      * vs CSS that was included in SSR.
      */
     ssrRenderedExports?: Map<string, Set<string>>;
+    /**
+     * Map of page component path -> dependency hash for incremental builds.
+     * Populated during the prerender Rolldown build by the incremental plugin.
+     */
+    pageDependencyHashes?: Map<string, string>;
+    /**
+     * Map of content entry root-relative `filePath` -> render-graph hash for
+     * incremental builds. Keyed to match what the content runtime reports when it
+     * renders an entry, so a path's cache entry can be invalidated when a component
+     * imported by the content it renders changes.
+     */
+    contentEntryRenderHashes?: Map<string, string>;
+    /**
+     * Set of page component paths whose render graph contains a server island.
+     * Populated during the prerender Rolldown build by the incremental plugin.
+     * Such pages bake key-bound ciphertext into their HTML, so the incremental
+     * cache only reuses them while the encryption key is unchanged.
+     */
+    serverIslandPageComponents?: Set<string>;
 }
 /**
  * Creates internal maps used to coordinate the CSS and HTML plugins.

package/dist/core/build/lockfile/finder.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Lockfile names recognized across the package managers we support. A project
+ * can commit more than one, so these carry no priority: every match in a
+ * directory is returned.
+ */
+export declare const KNOWN_LOCKFILES: readonly ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lock", "bun.lockb"];
+/** Subset of `node:fs` the finder depends on, so tests can pass a fake. */
+export interface LockfileFinderFs {
+    existsSync(path: string): boolean;
+}
+export declare class LockfileFinder {
+    #private;
+    constructor(fs?: LockfileFinderFs, lockfileNames?: readonly string[]);
+    /**
+     * Walk upward from `startDir` and return the absolute paths of every known
+     * lockfile in the first directory that contains at least one. In a workspace
+     * the lockfile lives above the individual project, so the walk continues until
+     * a directory yields a match. Returns an empty array if the filesystem root is
+     * reached without finding one.
+     */
+    find(startDir: string): string[];
+}

package/dist/core/build/lockfile/finder.js

@@ -0,0 +1,45 @@
+import nodeFs from "node:fs";
+import path from "node:path";
+const KNOWN_LOCKFILES = [
+  "pnpm-lock.yaml",
+  "package-lock.json",
+  "yarn.lock",
+  "bun.lock",
+  "bun.lockb"
+];
+class LockfileFinder {
+  #fs;
+  #lockfileNames;
+  constructor(fs = nodeFs, lockfileNames = KNOWN_LOCKFILES) {
+    this.#fs = fs;
+    this.#lockfileNames = lockfileNames;
+  }
+  /**
+   * Walk upward from `startDir` and return the absolute paths of every known
+   * lockfile in the first directory that contains at least one. In a workspace
+   * the lockfile lives above the individual project, so the walk continues until
+   * a directory yields a match. Returns an empty array if the filesystem root is
+   * reached without finding one.
+   */
+  find(startDir) {
+    let dir = path.resolve(startDir);
+    let previous = "";
+    while (dir !== previous) {
+      const found = [];
+      for (const name of this.#lockfileNames) {
+        const candidate = path.join(dir, name);
+        if (this.#fs.existsSync(candidate)) {
+          found.push(candidate);
+        }
+      }
+      if (found.length > 0) return found;
+      previous = dir;
+      dir = path.dirname(dir);
+    }
+    return [];
+  }
+}
+export {
+  KNOWN_LOCKFILES,
+  LockfileFinder
+};

package/dist/core/build/lockfile/hasher.d.ts

@@ -0,0 +1,16 @@
+/** Subset of `node:fs` the hasher depends on, so tests can pass a fake. */
+export interface LockfileHasherFs {
+    readFileSync(path: string): Buffer;
+}
+export declare class LockfileHasher {
+    #private;
+    constructor(fs?: LockfileHasherFs);
+    /**
+     * Produce a sha256 over the raw bytes of the given lockfiles. Files are sorted
+     * by name so discovery order does not affect the result, and each name is mixed
+     * in so identical content under different package managers still yields distinct
+     * hashes. Returns an empty string for an empty list, letting callers treat
+     * "no lockfile" as "no signal" rather than a hash collision.
+     */
+    hash(lockfilePaths: string[]): Promise<string>;
+}

package/dist/core/build/lockfile/hasher.js

@@ -0,0 +1,46 @@
+import nodeFs from "node:fs";
+import path from "node:path";
+import { encodeHexLowerCase } from "@oslojs/encoding";
+const encoder = new TextEncoder();
+const SEPARATOR = new Uint8Array([0]);
+function concatBytes(parts) {
+  const total = parts.reduce((sum, part) => sum + part.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+class LockfileHasher {
+  #fs;
+  constructor(fs = nodeFs) {
+    this.#fs = fs;
+  }
+  /**
+   * Produce a sha256 over the raw bytes of the given lockfiles. Files are sorted
+   * by name so discovery order does not affect the result, and each name is mixed
+   * in so identical content under different package managers still yields distinct
+   * hashes. Returns an empty string for an empty list, letting callers treat
+   * "no lockfile" as "no signal" rather than a hash collision.
+   */
+  async hash(lockfilePaths) {
+    if (lockfilePaths.length === 0) return "";
+    const sorted = [...lockfilePaths].sort(
+      (a, b) => path.basename(a).localeCompare(path.basename(b))
+    );
+    const parts = [];
+    for (const filePath of sorted) {
+      parts.push(encoder.encode(path.basename(filePath)));
+      parts.push(SEPARATOR);
+      parts.push(new Uint8Array(this.#fs.readFileSync(filePath)));
+      parts.push(SEPARATOR);
+    }
+    const digest = await crypto.subtle.digest("SHA-256", concatBytes(parts));
+    return encodeHexLowerCase(new Uint8Array(digest));
+  }
+}
+export {
+  LockfileHasher
+};

package/dist/core/build/lockfile/index.d.ts

@@ -0,0 +1,9 @@
+import nodeFs from 'node:fs';
+export { KNOWN_LOCKFILES, LockfileFinder, type LockfileFinderFs } from './finder.js';
+export { LockfileHasher, type LockfileHasherFs } from './hasher.js';
+/**
+ * Find the nearest lockfiles at or above `startDir` and hash them into a single
+ * digest used to globally invalidate the incremental build cache when
+ * dependencies change. Returns an empty string when no lockfile is found.
+ */
+export declare function computeLockfileHash(startDir: string, fs?: typeof nodeFs): Promise<string>;

package/dist/core/build/lockfile/index.js

@@ -0,0 +1,16 @@
+import nodeFs from "node:fs";
+import { LockfileFinder } from "./finder.js";
+import { LockfileHasher } from "./hasher.js";
+import { KNOWN_LOCKFILES, LockfileFinder as LockfileFinder2 } from "./finder.js";
+import { LockfileHasher as LockfileHasher2 } from "./hasher.js";
+function computeLockfileHash(startDir, fs = nodeFs) {
+  const finder = new LockfileFinder(fs);
+  const hasher = new LockfileHasher(fs);
+  return hasher.hash(finder.find(startDir));
+}
+export {
+  KNOWN_LOCKFILES,
+  LockfileFinder2 as LockfileFinder,
+  LockfileHasher2 as LockfileHasher,
+  computeLockfileHash
+};

package/dist/core/build/plugins/index.js

@@ -10,6 +10,7 @@ import { pluginPrerender } from "./plugin-prerender.js";
 import { pluginScripts } from "./plugin-scripts.js";
 import { pluginSSR } from "./plugin-ssr.js";
 import { pluginChunkImports } from "./plugin-chunk-imports.js";
+import { pluginIncremental } from "./plugin-incremental.js";
 import { pluginNoop } from "./plugin-noop.js";
 import { vitePluginSSRAssets } from "../vite-plugin-ssr-assets.js";
 function getAllBuildPlugins(internals, options) {
@@ -27,7 +28,8 @@ function getAllBuildPlugins(internals, options) {
     ...pluginSSR(options, internals),
     pluginNoop(),
     vitePluginSSRAssets(internals),
-    pluginChunkImports(options)
+    pluginChunkImports(options),
+    options.settings.config.experimental.incrementalBuild ? pluginIncremental(internals, options.settings.config.root) : void 0
   ].filter(Boolean);
 }
 export {

package/dist/core/build/plugins/plugin-incremental.d.ts

@@ -0,0 +1,14 @@
+import type { Plugin as VitePlugin } from 'vite';
+import type { BuildInternals } from '../internal.js';
+/**
+ * Captures a dependency hash for each prerendered page route during the build.
+ *
+ * The base hash is derived during the prerender build from the sorted set of all
+ * transitive module dependencies of the page, so any change to the page's
+ * template, layouts, components, or utilities produces a different hash. During
+ * the client build, the hash of each `client:only` component's and hoisted
+ * `<script>`'s own module graph is folded in, since those never enter the
+ * prerender graph. Content entries are hashed separately per entry, since their
+ * render modules sit behind `content-data`-pruned bridges.
+ */
+export declare function pluginIncremental(internals: BuildInternals, root: URL): VitePlugin;

package/dist/core/build/plugins/plugin-incremental.js

@@ -0,0 +1,152 @@
+import crypto from "node:crypto";
+import { PROPAGATED_ASSET_FLAG } from "../../../content/consts.js";
+import { hasContentFlag } from "../../../content/utils.js";
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../../constants.js";
+import { removeQueryString } from "../../path.js";
+import { rootRelativePath } from "../../viteUtils.js";
+import { moduleIsTopLevelPage } from "../graph.js";
+import { isContentDataIncrementalModule } from "../incremental-metadata.js";
+import { getPageDataByViteID } from "../internal.js";
+function collectTransitiveDeps(graph, rootId) {
+  const deps = /* @__PURE__ */ new Set();
+  const queue = [rootId];
+  while (queue.length > 0) {
+    const current = queue.pop();
+    if (deps.has(current)) continue;
+    const modInfo = graph.getModuleInfo(current);
+    if (isContentDataIncrementalModule(modInfo)) continue;
+    deps.add(current);
+    if (!modInfo) continue;
+    for (const dep of modInfo.importedIds) {
+      if (!deps.has(dep)) queue.push(dep);
+    }
+    for (const dep of modInfo.dynamicallyImportedIds) {
+      if (!deps.has(dep)) queue.push(dep);
+    }
+  }
+  return [...deps].sort();
+}
+const ASSET_PLACEHOLDERS = [
+  { token: "__ASTRO_ASSET_IMAGE__", pattern: /__ASTRO_ASSET_IMAGE__([\w$]+)__(?:_(.*?)__)?/g },
+  { token: "__VITE_ASSET__", pattern: /__VITE_ASSET__([\w$]+)__(?:\$_(.*?)__)?/g }
+];
+function resolveAssetPlaceholders(graph, code) {
+  let resolved = code;
+  for (const { token, pattern } of ASSET_PLACEHOLDERS) {
+    if (!resolved.includes(token)) continue;
+    resolved = resolved.replace(pattern, (placeholder, handle, postfix = "") => {
+      try {
+        return graph.getFileName(handle) + postfix;
+      } catch {
+        return placeholder;
+      }
+    });
+  }
+  return resolved;
+}
+function hashModules(graph, sortedIds) {
+  const hasher = crypto.createHash("sha256");
+  for (const id of sortedIds) {
+    hasher.update(id);
+    hasher.update("\n");
+    const code = graph.getModuleInfo(id)?.code;
+    if (code != null) {
+      hasher.update(resolveAssetPlaceholders(graph, code));
+    }
+    hasher.update("\n");
+  }
+  return hasher.digest("hex");
+}
+function collectClientEntrypointHashes(graph, entrypointIds, pagesByEntrypoint, hashesByComponent) {
+  for (const entrypointId of entrypointIds) {
+    const pages = pagesByEntrypoint.get(entrypointId);
+    if (!pages?.size) continue;
+    const hash = hashModules(graph, collectTransitiveDeps(graph, entrypointId));
+    for (const pageData of pages) {
+      let list = hashesByComponent.get(pageData.component);
+      if (!list) {
+        list = [];
+        hashesByComponent.set(pageData.component, list);
+      }
+      list.push(hash);
+    }
+  }
+}
+function foldClientDependencies(graph, internals) {
+  const baseHashes = internals.pageDependencyHashes;
+  if (!baseHashes) return;
+  const hashesByComponent = /* @__PURE__ */ new Map();
+  collectClientEntrypointHashes(
+    graph,
+    internals.discoveredClientOnlyComponents.keys(),
+    internals.pagesByClientOnly,
+    hashesByComponent
+  );
+  collectClientEntrypointHashes(
+    graph,
+    internals.discoveredScripts,
+    internals.pagesByScriptId,
+    hashesByComponent
+  );
+  for (const [component, clientHashes] of hashesByComponent) {
+    const hasher = crypto.createHash("sha256");
+    hasher.update(baseHashes.get(component) ?? "");
+    for (const hash of clientHashes.sort()) {
+      hasher.update("\n");
+      hasher.update(hash);
+    }
+    baseHashes.set(component, hasher.digest("hex"));
+  }
+}
+function collectContentEntryHashes(graph, root) {
+  const entryHashes = /* @__PURE__ */ new Map();
+  for (const id of graph.getModuleIds()) {
+    if (!hasContentFlag(id, PROPAGATED_ASSET_FLAG)) continue;
+    const renderModuleId = removeQueryString(id);
+    const key = rootRelativePath(root, renderModuleId, false);
+    const deps = collectTransitiveDeps(graph, renderModuleId);
+    entryHashes.set(key, hashModules(graph, deps));
+  }
+  return entryHashes;
+}
+function pageContainsServerIsland(graph, ids) {
+  for (const id of ids) {
+    const serverComponents = graph.getModuleInfo(id)?.meta?.astro?.serverComponents;
+    if (serverComponents?.length) return true;
+  }
+  return false;
+}
+function pluginIncremental(internals, root) {
+  return {
+    name: "@astro/plugin-incremental",
+    applyToEnvironment(environment) {
+      return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender || environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.client;
+    },
+    generateBundle() {
+      if (this.environment?.name === ASTRO_VITE_ENVIRONMENT_NAMES.client) {
+        foldClientDependencies(this, internals);
+        return;
+      }
+      const hashes = /* @__PURE__ */ new Map();
+      const serverIslandComponents = /* @__PURE__ */ new Set();
+      for (const id of this.getModuleIds()) {
+        const info = this.getModuleInfo(id);
+        if (!info) continue;
+        if (!moduleIsTopLevelPage(info)) continue;
+        const pageData = getPageDataByViteID(internals, info.id);
+        if (!pageData) continue;
+        const deps = collectTransitiveDeps(this, info.id);
+        hashes.set(pageData.component, hashModules(this, deps));
+        if (pageContainsServerIsland(this, deps)) {
+          serverIslandComponents.add(pageData.component);
+        }
+      }
+      internals.pageDependencyHashes = hashes;
+      internals.contentEntryRenderHashes = collectContentEntryHashes(this, root);
+      internals.serverIslandPageComponents = serverIslandComponents;
+    }
+  };
+}
+export {
+  pluginIncremental
+};

package/dist/core/build/plugins/plugin-manifest.js

@@ -21,7 +21,8 @@ import {
   trackStyleHashes
 } from "../../csp/common.js";
 import { partitionByKind } from "../../csp/runtime.js";
-import { encodeKey } from "../../encryption.js";
+import { generateSpeculationRulesContent } from "../../../prefetch/speculation-rules.js";
+import { encodeKey, generateCspDigest } from "../../encryption.js";
 import { fileExtension, joinPaths, prependForwardSlash } from "../../path.js";
 import { DEFAULT_COMPONENTS } from "../../routing/default.js";
 import { getOutFile, getOutFolder } from "../common.js";
@@ -204,6 +205,13 @@ async function buildManifest(opts, internals, staticFiles, encodedKey) {
       ...settings.injectedCsp.styleHashes,
       ...await trackStyleHashes(internals, settings, algorithm)
     ];
+    let speculationRulesContent;
+    if (settings.config.experimental.clientPrerender && settings.config.prefetch) {
+      const prefetchAll = typeof settings.config.prefetch === "object" ? settings.config.prefetch.prefetchAll ?? false : false;
+      speculationRulesContent = generateSpeculationRulesContent(prefetchAll);
+      const speculationRulesHash = await generateCspDigest(speculationRulesContent, algorithm);
+      scriptHashes.push(speculationRulesHash);
+    }
     const scriptDirective = {
       resources: getScriptResources(cspConfig),
       hashes: scriptHashes,
@@ -225,7 +233,8 @@ async function buildManifest(opts, internals, staticFiles, encodedKey) {
       styleHashes: styleDefault.hashes,
       styleResources: styleDefault.resources,
       scriptDirective,
-      styleDirective
+      styleDirective,
+      speculationRulesContent
     };
   }
   let internalFetchHeaders = void 0;

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

@@ -38,6 +38,8 @@ export interface StaticBuildOptions {
     pageNames: string[];
     viteConfig: InlineConfig;
     key: Promise<CryptoKey>;
+    /** Set by `astro build --force` to rebuild every page and ignore the incremental cache. */
+    force: boolean;
 }
 type ImportComponentInstance = () => Promise<ComponentInstance>;
 export interface SinglePageBuiltModule {

package/dist/core/config/schemas/base.d.ts

@@ -393,7 +393,7 @@ export declare const AstroConfigSchema: z.ZodObject<{
         }, z.core.$strip>]>>>>>;
         validateSecrets: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     }, z.core.$strict>>>;
-    session: z.ZodOptional<z.ZodObject<{
+    session: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodObject<{
         driver: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
             config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
             entrypoint: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<URL, URL>]>;
@@ -414,7 +414,7 @@ export declare const AstroConfigSchema: z.ZodObject<{
             name: string;
         }, string>>]>>;
         ttl: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
+    }, z.core.$strip>]>>;
     prerenderConflictBehavior: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
         error: "error";
         ignore: "ignore";
@@ -484,6 +484,7 @@ export declare const AstroConfigSchema: z.ZodObject<{
         clientPrerender: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         contentIntellisense: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         chromeDevtoolsWorkspace: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        incrementalBuild: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         svgOptimizer: z.ZodOptional<z.ZodObject<{
             name: z.ZodString;
             optimize: z.ZodCustom<(contents: string) => string | Promise<string>, (contents: string) => string | Promise<string>>;