astro 7.1.6 → 7.2.0

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

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;