@riebeckite/honox 0.0.21 → 0.0.23

package/dist/index.js

@@ -1,18 +1,42 @@
 // src/config_loader.ts
-import fs2 from "node:fs/promises";
-import path3 from "node:path";
+import fs3 from "node:fs/promises";
+import path4 from "node:path";
 import { build as buildWithEsbuild } from "esbuild";
 
-// src/workspace_packages.ts
+// src/site_externals.ts
 import fs from "node:fs";
 import path from "node:path";
+function siteRiebeckiteExternals(siteRoot) {
+  const packageJsonPath = path.join(siteRoot, "package.json");
+  let contents;
+  try {
+    contents = fs.readFileSync(packageJsonPath, "utf8");
+  } catch {
+    return [];
+  }
+  let packageJson;
+  try {
+    packageJson = JSON.parse(contents);
+  } catch {
+    return [];
+  }
+  const dependencies = packageJson.dependencies;
+  if (!dependencies || typeof dependencies !== "object") return [];
+  return Object.keys(dependencies).filter(
+    (name) => name === "@riebeckite/core" || name.startsWith("@riebeckite/plugin-") || name.startsWith("@riebeckite/theme-")
+  );
+}
+
+// src/workspace_packages.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
 function createWorkspacePackageAliases(workspaceRoot) {
-  const packagesRoot = path.join(workspaceRoot, "packages");
-  if (!fs.existsSync(packagesRoot)) return [];
+  const packagesRoot = path2.join(workspaceRoot, "packages");
+  if (!fs2.existsSync(packagesRoot)) return [];
   return findWorkspacePackageDirectories(packagesRoot).flatMap(
     (packageDirectory) => {
-      const packageJsonPath = path.join(packageDirectory, "package.json");
-      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+      const packageJsonPath = path2.join(packageDirectory, "package.json");
+      const packageJson = JSON.parse(fs2.readFileSync(packageJsonPath, "utf8"));
       if (typeof packageJson.name !== "string") return [];
       return createPackageAliases(
         packageJson.name,
@@ -37,10 +61,10 @@ function workspacePackageResolver(workspaceRoot) {
   };
 }
 function findWorkspacePackageDirectories(rootDirectory) {
-  const packageJsonPath = path.join(rootDirectory, "package.json");
-  if (fs.existsSync(packageJsonPath)) return [rootDirectory];
-  return fs.readdirSync(rootDirectory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap(
-    (entry) => findWorkspacePackageDirectories(path.join(rootDirectory, entry.name))
+  const packageJsonPath = path2.join(rootDirectory, "package.json");
+  if (fs2.existsSync(packageJsonPath)) return [rootDirectory];
+  return fs2.readdirSync(rootDirectory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap(
+    (entry) => findWorkspacePackageDirectories(path2.join(rootDirectory, entry.name))
   );
 }
 function createPackageAliases(packageName, packageDirectory, packageJson) {
@@ -49,7 +73,7 @@ function createPackageAliases(packageName, packageDirectory, packageJson) {
   if (mainEntry) {
     aliases.push({
       find: new RegExp(`^${escapeRegExp(packageName)}$`),
-      replacement: path.join(packageDirectory, mainEntry)
+      replacement: path2.join(packageDirectory, mainEntry)
     });
   }
   if (!packageJson.exports || typeof packageJson.exports !== "object") {
@@ -61,7 +85,7 @@ function createPackageAliases(packageName, packageDirectory, packageJson) {
     if (!resolvedTarget) continue;
     aliases.push({
       find: new RegExp(`^${escapeRegExp(packageName + subpath.slice(1))}$`),
-      replacement: path.join(packageDirectory, resolvedTarget)
+      replacement: path2.join(packageDirectory, resolvedTarget)
     });
   }
   return aliases;
@@ -108,15 +132,15 @@ function escapeRegExp(value) {
 }
 
 // src/resolved_config.ts
-import path2 from "node:path";
+import path3 from "node:path";
 function resolveHonoxConfig(config, appRoot) {
   return {
     ...config,
-    buildDirectory: path2.join(appRoot, ".riebeckite"),
-    outputDirectory: path2.join(appRoot, "dist"),
+    buildDirectory: path3.join(appRoot, ".riebeckite"),
+    outputDirectory: path3.join(appRoot, "dist"),
     content: {
       ...config.content,
-      directory: path2.resolve(appRoot, config.content.directory)
+      directory: path3.resolve(appRoot, config.content.directory)
     }
   };
 }
@@ -124,15 +148,15 @@ function resolveHonoxConfig(config, appRoot) {
 // src/config_loader.ts
 async function loadRiebeckiteConfig(options) {
   const configFile = options.configFile ?? "riebeckite.config.ts";
-  const temporaryDirectory = await fs2.mkdtemp(
-    path3.join(options.configRoot, ".riebeckite-config-")
+  const temporaryDirectory = await fs3.mkdtemp(
+    path4.join(options.configRoot, ".riebeckite-config-")
   );
-  const outputFile = path3.join(temporaryDirectory, "config.mjs");
+  const outputFile = path4.join(temporaryDirectory, "config.mjs");
   try {
     await buildWithEsbuild({
       stdin: {
         contents: `
-          import rawConfig from ${JSON.stringify(path3.resolve(options.configRoot, configFile))};
+          import rawConfig from ${JSON.stringify(path4.resolve(options.configRoot, configFile))};
           import { resolveConfigModule } from "@riebeckite/core";
           export default resolveConfigModule(rawConfig);
         `,
@@ -143,6 +167,7 @@ async function loadRiebeckiteConfig(options) {
       bundle: true,
       platform: "node",
       format: "esm",
+      external: options.workspaceRoot ? [] : ["@riebeckite/core", ...siteRiebeckiteExternals(options.configRoot)],
       banner: {
         js: 'import { createRequire as __riebeckiteCreateRequire } from "node:module"; const require = __riebeckiteCreateRequire(import.meta.url);'
       },
@@ -151,7 +176,7 @@ async function loadRiebeckiteConfig(options) {
     const module = await import(`${pathToFileUrl(outputFile)}?t=${Date.now()}`);
     return module.default;
   } finally {
-    await fs2.rm(temporaryDirectory, { recursive: true, force: true });
+    await fs3.rm(temporaryDirectory, { recursive: true, force: true });
   }
 }
 function pathToFileUrl(filePath) {
@@ -159,8 +184,8 @@ function pathToFileUrl(filePath) {
 }
 
 // src/honox_islands.ts
-import fs3 from "node:fs/promises";
-import path4 from "node:path";
+import fs4 from "node:fs/promises";
+import path5 from "node:path";
 import { parse } from "@babel/parser";
 var honoxIslandDependencyPluginName = "inject-importing-islands";
 var importingIslandsExport = "__importing_islands";
@@ -187,8 +212,8 @@ function scopedIslandDependencyPlugin() {
   return {
     name: "riebeckite-inject-importing-islands",
     configResolved(config) {
-      appDirectory = path4.resolve(config.root, "app");
-      islandDirectory = path4.join(appDirectory, "islands");
+      appDirectory = path5.resolve(config.root, "app");
+      islandDirectory = path5.join(appDirectory, "islands");
     },
     async transform(sourceCode, id) {
       const modulePath = toFilePath(id);
@@ -222,7 +247,7 @@ export const ${importingIslandsExport} = true;
           continue;
         }
         try {
-          const dependencySourceCode = await fs3.readFile(
+          const dependencySourceCode = await fs4.readFile(
             dependencyPath,
             "utf8"
           );
@@ -251,8 +276,8 @@ function toFilePath(id) {
   return id.split("?", 1)[0] ?? id;
 }
 function isInDirectory(filePath, directory) {
-  const relativePath = path4.relative(directory, filePath);
-  return relativePath !== "" && !relativePath.startsWith(`..${path4.sep}`) && !path4.isAbsolute(relativePath);
+  const relativePath = path5.relative(directory, filePath);
+  return relativePath !== "" && !relativePath.startsWith(`..${path5.sep}`) && !path5.isAbsolute(relativePath);
 }
 function isJavaScriptModule(filePath) {
   return /\.[cm]?[jt]sx?$/.test(filePath);
@@ -260,7 +285,10 @@ function isJavaScriptModule(filePath) {
 
 // src/ssg_plugin.ts
 import { createHash, randomUUID } from "node:crypto";
+import { createReadStream } from "node:fs";
 import {
+  copyFile,
+  lstat,
   mkdir,
   readdir,
   readFile,
@@ -271,14 +299,14 @@ import {
 } from "node:fs/promises";
 import { dirname, join, relative, resolve } from "node:path";
 import { performance } from "node:perf_hooks";
-import { defaultExtensionMap, toSSG } from "hono/ssg";
+import { defaultExtensionMap, redirectPlugin, toSSG } from "hono/ssg";
 import {
   createServer
 } from "vite";
 
 // src/content_assets.ts
-import fs4 from "node:fs/promises";
-import path6 from "node:path";
+import fs5 from "node:fs/promises";
+import path7 from "node:path";
 import {
   isIgnoredContentPath as isIgnoredContentPath2,
   isImagePath as isImagePath2,
@@ -286,7 +314,7 @@ import {
 } from "@riebeckite/core";
 
 // src/content_watch.ts
-import path5 from "node:path";
+import path6 from "node:path";
 import {
   isAttachmentPath,
   isIgnoredContentPath,
@@ -407,13 +435,13 @@ function isPathInsideDirectory(directory, file) {
 }
 function toLogicalPath(directory, file) {
   return normalizeContentPath(
-    path5.relative(normalizeContentPath(directory), normalizeContentPath(file))
+    path6.relative(normalizeContentPath(directory), normalizeContentPath(file))
   );
 }
 function invalidateApplicationRuntime(server, appRoot) {
   const moduleGraph = server.environments?.ssr?.moduleGraph;
   if (!moduleGraph) return 0;
-  const appDirectory = path5.join(appRoot, "app") + path5.sep;
+  const appDirectory = path6.join(appRoot, "app") + path6.sep;
   const seen = /* @__PURE__ */ new Set();
   const timestamp = Date.now();
   let invalidated = 0;
@@ -462,7 +490,7 @@ function riebeckiteContentAssets(options) {
     enforce: "pre",
     configureServer(server) {
       const contentRoot = options.contentRoot();
-      const entry = path6.join(options.appRoot(), "app", "server.ts");
+      const entry = path7.join(options.appRoot(), "app", "server.ts");
       const base = server.config.base;
       const publicDir = server.config.publicDir;
       let cachedManifest;
@@ -502,7 +530,7 @@ function riebeckiteContentAssets(options) {
             next();
             return;
           }
-          const file = path6.join(contentRoot, logicalPath);
+          const file = path7.join(contentRoot, logicalPath);
           if (!isPathInsideDirectory(contentRoot, file)) {
             next();
             return;
@@ -511,7 +539,7 @@ function riebeckiteContentAssets(options) {
             next();
             return;
           }
-          const content = await fs4.readFile(file);
+          const content = await fs5.readFile(file);
           response.statusCode = 200;
           response.setHeader("Content-Type", contentType);
           response.setHeader("Content-Length", String(content.byteLength));
@@ -549,16 +577,16 @@ function collectPublicImagePaths(manifest) {
 async function collectSiteOwnedOutputPaths(publicDir) {
   const paths = /* @__PURE__ */ new Set();
   if (!publicDir) return paths;
-  const root = path6.resolve(publicDir);
+  const root = path7.resolve(publicDir);
   const walk = async (directory) => {
-    const entries = await fs4.readdir(directory, { withFileTypes: true }).catch(() => void 0);
+    const entries = await fs5.readdir(directory, { withFileTypes: true }).catch(() => void 0);
     if (!entries) return;
     for (const entry of entries) {
-      const full = path6.join(directory, entry.name);
+      const full = path7.join(directory, entry.name);
       if (entry.isDirectory()) {
         await walk(full);
       } else {
-        paths.add(path6.relative(root, full).replaceAll("\\", "/"));
+        paths.add(path7.relative(root, full).replaceAll("\\", "/"));
       }
     }
   };
@@ -593,22 +621,33 @@ function imageContentType(logicalPath) {
 }
 async function hasSiteOwnedFile(publicDir, logicalPath) {
   if (!publicDir) return false;
-  const file = path6.join(publicDir, logicalPath);
+  const file = path7.join(publicDir, logicalPath);
   try {
-    return (await fs4.stat(file)).isFile();
+    return (await fs5.stat(file)).isFile();
   } catch {
     return false;
   }
 }
 
 // src/ssg_plugin.ts
+function createNoChangeFastPathOutputMetrics() {
+  return {
+    outputInventoryValidationDurationMs: 0,
+    outputHashValidationDurationMs: 0,
+    outputFilesHashed: 0,
+    outputBytesHashed: 0
+  };
+}
 var defaultEntry = "./src/index.tsx";
+var faultInjectionCounts = /* @__PURE__ */ new Map();
 var cloudflareWorkerAssetLimit = 25 * 1024 * 1024;
 function riebeckiteSsg(options = {}) {
   const virtualId = "virtual:riebeckite-ssg-void-entry";
   const resolvedVirtualId = `\0${virtualId}`;
   const entry = options.entry ?? defaultEntry;
   let resolvedConfig;
+  let pendingOutputCache;
+  let clientBuildArtifacts;
   return {
     name: "riebeckite-ssg",
     apply: shouldApplyRiebeckiteSsg,
@@ -625,6 +664,25 @@ function riebeckiteSsg(options = {}) {
     configResolved(config) {
       resolvedConfig = config;
     },
+    async buildStart() {
+      const config = resolvedConfig;
+      if (!config) return;
+      if (!config.plugins.some(
+        (plugin) => plugin.name.startsWith("@hono/vite-build/")
+      )) {
+        return;
+      }
+      const outDir = resolve(config.root, config.build.outDir);
+      clientBuildArtifacts = await preserveClientBuildArtifacts(outDir);
+      logSsgDiagnostics(
+        this,
+        `client manifest ${clientBuildArtifacts ? `preserved (${clientBuildArtifacts.paths.length} files)` : "not found"}`
+      );
+      await rm(outDir, {
+        recursive: true,
+        force: true
+      });
+    },
     resolveId(id) {
       return id === virtualId ? resolvedVirtualId : void 0;
     },
@@ -638,7 +696,8 @@ function riebeckiteSsg(options = {}) {
           "Riebeckite SSG could not resolve the Vite configuration."
         );
       }
-      const timingsMs = {};
+      const timingsMs = process.env.RIEBECKITE_SSG_METRICS_FILE ? {} : void 0;
+      const outDir = resolve(config.root, config.build.outDir);
       removeVirtualEntryChunk(bundle, resolvedVirtualId);
       const server = await measure(
         timingsMs,
@@ -652,11 +711,19 @@ function riebeckiteSsg(options = {}) {
           },
           plugins: [],
           build: { ssr: true },
+          environments: {
+            ssr: { resolve: { noExternal: [/^honox(?:\/.*)?$/] } }
+          },
           mode: config.mode,
           server: { watch: null }
         })
       );
       try {
+        await restoreClientBuildArtifacts(outDir, clientBuildArtifacts);
+        logSsgDiagnostics(
+          this,
+          `SSR noExternal=${formatSsrNoExternal()} · client manifest ${clientBuildArtifacts ? "restored" : "not found"}`
+        );
         const module = await measure(
           timingsMs,
           "ssrModuleLoad",
@@ -700,23 +767,31 @@ function riebeckiteSsg(options = {}) {
             `Build outputs take precedence over site public assets: ${siteOutputCollisions.join(", ")}`
           );
         }
-        const canUseIncremental = outputChangeSet && !outputChangeSet.fullRegenerationRequired && previousOutputCache && previousOutputCache.appFingerprint === appFingerprint && outputChangeSet.unchanged.every(
+        const canUseIncremental = outputChangeSet && !outputChangeSet.fullRegenerationRequired && previousOutputCache && previousOutputCache.appFingerprint === appFingerprint && previousOutputCache.clientManifestFingerprint === clientBuildArtifacts?.manifestFingerprint && outputChangeSet.unchanged.every(
           (output) => siteOwnedOutputPaths.has(output.path) || previousOutputCache.outputs[output.path]
         );
         const reusablePaths = new Set(
           canUseIncremental ? outputChangeSet.unchanged.map((output) => output.path) : []
         );
+        logSsgDiagnostics(
+          this,
+          `output cache ${canUseIncremental ? "hit" : "miss"} · ${reusablePaths.size} reusable outputs`
+        );
         const shadowedOutputs = /* @__PURE__ */ new Set();
         const skippedRouteCount = canUseIncremental ? outputChangeSet.unchanged.filter(
           (output) => output.kind !== "generated"
         ).length : 0;
         const generatedHtml = [];
         const nextOutputCache = {
-          version: 1,
+          version: 4,
           appFingerprint,
-          outputs: {}
+          clientManifestFingerprint: clientBuildArtifacts?.manifestFingerprint,
+          outputs: {},
+          configFile: config.configFile
         };
         const metrics = {
+          processedContentCount: 0,
+          reusedContentCount: 0,
           candidateOutputCount: outputChangeSet?.candidateOutputCount ?? 0,
           affectedOutputCount: outputChangeSet?.affectedOutputCount ?? 0,
           removedOutputCount: outputChangeSet?.removedOutputCount ?? 0,
@@ -735,10 +810,16 @@ function riebeckiteSsg(options = {}) {
           enumeratedRouteCount: 0,
           renderedRouteCount: 0,
           skippedRouteCount,
-          timingsMs
+          manifestHooksExecuted: 0,
+          manifestHooksReused: 0,
+          manifestHookCacheHit: 0,
+          manifestHookCacheMiss: 0,
+          manifestHookDurationMs: 0,
+          manifestHookPlugins: {},
+          timingsMs: timingsMs ?? {}
         };
         process.env.RIEBECKITE_SSG_FULL_REGENERATION = canUseIncremental ? "" : "1";
-        const outDir = resolve(config.root, config.build.outDir);
+        process.env.RIEBECKITE_SSG_SKIP_UNCHANGED = canUseIncremental ? "1" : "";
         const result = await measure(
           timingsMs,
           "toSSG",
@@ -750,7 +831,6 @@ function riebeckiteSsg(options = {}) {
                   "\\",
                   "/"
                 );
-                metrics.enumeratedRouteCount += 1;
                 if (siteOwnedOutputPaths.has(fileName)) {
                   shadowedOutputs.add(fileName);
                   return;
@@ -760,49 +840,72 @@ function riebeckiteSsg(options = {}) {
                 }
                 if (fileName.endsWith(".html") && typeof data === "string") {
                   metrics.renderedOutputCount += 1;
+                  metrics.renderedRouteCount += 1;
                   metrics.htmlOutputCount += 1;
                   generatedHtml.push({ path: fileName, html: data });
                 } else {
                   metrics.assetOutputCount += 1;
                 }
-                this.emitFile({
-                  type: "asset",
-                  fileName,
-                  source: data
-                });
+                measureSync(
+                  timingsMs,
+                  "outputWrite",
+                  () => this.emitFile({
+                    type: "asset",
+                    fileName,
+                    source: data
+                  })
+                );
                 metrics.emittedOutputCount += 1;
-                nextOutputCache.outputs[fileName] = encodeOutput(data);
+                nextOutputCache.outputs[fileName] = {
+                  cachePath: "",
+                  checksum: ""
+                };
               },
               async mkdir() {
               }
             },
             {
               dir: outDir,
-              plugins: [...options.plugins ?? []],
+              plugins: [redirectPlugin(), ...options.plugins ?? []],
               extensionMap: options.extensionMap ?? defaultExtensionMap
             }
           )
         );
         delete process.env.RIEBECKITE_SSG_FULL_REGENERATION;
-        metrics.renderedRouteCount = result.files.length;
+        delete process.env.RIEBECKITE_SSG_SKIP_UNCHANGED;
+        metrics.enumeratedRouteCount = result.files.length;
         if (!result.success) throw result.error;
+        metrics.processedContentCount = module.content?.getProcessedContentCount() ?? 0;
+        metrics.reusedContentCount = module.content?.getReusedContentCount() ?? 0;
+        const manifestHookMetrics = module.content?.getManifestHookMetrics();
+        metrics.manifestHooksExecuted = manifestHookMetrics?.manifestHooksExecuted ?? 0;
+        metrics.manifestHooksReused = manifestHookMetrics?.manifestHooksReused ?? 0;
+        metrics.manifestHookCacheHit = manifestHookMetrics?.manifestHookCacheHit ?? 0;
+        metrics.manifestHookCacheMiss = manifestHookMetrics?.manifestHookCacheMiss ?? 0;
+        metrics.manifestHookDurationMs = manifestHookMetrics?.manifestHookDurationMs ?? 0;
+        metrics.manifestHookPlugins = manifestHookMetrics?.byPlugin ?? {};
         const emittedGeneratedOutputCount = await measure(
           timingsMs,
           "generatedOutputs",
           () => emitGeneratedOutputs(
             module,
             (asset) => {
-              this.emitFile(asset);
-              metrics.emittedOutputCount += 1;
-              nextOutputCache.outputs[asset.fileName] = encodeOutput(
-                asset.source
+              measureSync(
+                timingsMs,
+                "outputWrite",
+                () => this.emitFile(asset)
               );
+              metrics.emittedOutputCount += 1;
+              nextOutputCache.outputs[asset.fileName] = {
+                cachePath: "",
+                checksum: ""
+              };
             },
             canUseIncremental ? new Set(
               outputChangeSet.affected.filter((output) => output.kind === "generated").map((output) => output.path)
             ) : void 0,
             siteOwnedOutputPaths,
-            (path10) => shadowedOutputs.add(path10)
+            (path11) => shadowedOutputs.add(path11)
           )
         );
         if (!outputChangeSet)
@@ -810,21 +913,21 @@ function riebeckiteSsg(options = {}) {
         if (canUseIncremental) {
           await measure(timingsMs, "unchangedOutputReuse", async () => {
             for (const output of outputChangeSet.unchanged) {
-              const path10 = output.path;
-              if (siteOwnedOutputPaths.has(path10)) {
-                shadowedOutputs.add(path10);
+              const path11 = output.path;
+              if (siteOwnedOutputPaths.has(path11)) {
+                shadowedOutputs.add(path11);
                 continue;
               }
-              const cached = previousOutputCache.outputs[path10];
+              const cached = previousOutputCache.outputs[path11];
               if (!cached) continue;
               this.emitFile({
                 type: "asset",
-                fileName: path10,
-                source: decodeOutput(cached)
+                fileName: path11,
+                source: await decodeOutput(outputCachePath, cached)
               });
               metrics.emittedOutputCount += 1;
               metrics.reusedOutputCount += 1;
-              nextOutputCache.outputs[path10] = cached;
+              nextOutputCache.outputs[path11] = cached;
             }
           });
         }
@@ -848,14 +951,15 @@ function riebeckiteSsg(options = {}) {
         metrics.cacheEntriesSerialized = Object.keys(
           nextOutputCache.outputs
         ).length;
-        try {
-          await saveOutputCache(outputCachePath, nextOutputCache, timingsMs);
-        } catch (error) {
-          this.warn(
-            `SSG output cache could not be saved; the next build regenerates every output. ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-        await writeSsgOutputMetrics(metrics);
+        pendingOutputCache = {
+          path: outputCachePath,
+          state: nextOutputCache,
+          metrics,
+          timingsMs,
+          outDir,
+          publicDir: config.publicDir,
+          configFile: config.configFile
+        };
         this.info(
           `SSG outputs: ${metrics.renderedOutputCount} rendered · ${metrics.reusedOutputCount} reused · ${metrics.deletedOutputCount} removed`
         );
@@ -863,18 +967,58 @@ function riebeckiteSsg(options = {}) {
           warn: (message) => this.warn(message),
           info: (message) => this.info(message)
         });
+        logGeneratedHtmlAssetDiagnostics(this, generatedHtml);
       } finally {
         await server.close();
+        await discardClientBuildArtifacts(clientBuildArtifacts);
+        clientBuildArtifacts = void 0;
       }
     },
-    async closeBundle() {
-      if (!resolvedConfig) return;
-      const outDir = resolve(resolvedConfig.root, resolvedConfig.build.outDir);
-      const oversizedAssets = await findOversizedAssets(outDir);
-      for (const asset of oversizedAssets) {
-        this.warn(
-          `Generated asset ${asset.path} is ${formatBytes(asset.size)}, exceeding Cloudflare Workers' ${formatBytes(cloudflareWorkerAssetLimit)} asset limit.`
+    closeBundle: {
+      order: "post",
+      async handler() {
+        if (!resolvedConfig) return;
+        const outDir = resolve(
+          resolvedConfig.root,
+          resolvedConfig.build.outDir
         );
+        const oversizedAssets = await findOversizedAssets(outDir);
+        for (const asset of oversizedAssets) {
+          this.warn(
+            `Generated asset ${asset.path} is ${formatBytes(asset.size)}, exceeding Cloudflare Workers' ${formatBytes(cloudflareWorkerAssetLimit)} asset limit.`
+          );
+        }
+        const outputCache = pendingOutputCache;
+        if (!outputCache) return;
+        try {
+          outputCache.state.finalOutputInventory = await measure(
+            outputCache.timingsMs,
+            "outputInventory",
+            () => fingerprintOutputDirectory(outputCache.outDir)
+          );
+          const publicDir = outputCache.publicDir;
+          outputCache.state.publicDirectory = publicDir ? resolve(publicDir) : void 0;
+          outputCache.state.publicFingerprint = publicDir ? await measure(
+            outputCache.timingsMs,
+            "publicFingerprint",
+            () => fingerprintDirectory(resolve(publicDir))
+          ) : void 0;
+          await waitForFaultInjection("build-state-before");
+          await saveOutputCache(
+            outputCache.path,
+            outputCache.state,
+            outputCache.outDir,
+            outputCache.timingsMs
+          );
+          await waitForFaultInjection("build-state-committed");
+        } catch (error) {
+          this.warn(
+            `SSG output cache could not be saved; the next build regenerates every output. ${error instanceof Error ? error.message : String(error)}`
+          );
+        } finally {
+          await writeSsgOutputMetrics(outputCache.metrics);
+          pendingOutputCache = void 0;
+        }
       }
     }
   };
@@ -888,16 +1032,16 @@ async function findOversizedAssets(directory, relativeDirectory = "") {
   );
   const nestedAssets = await Promise.all(
     entries.map(async (entry) => {
-      const path10 = join(directory, entry.name);
+      const path11 = join(directory, entry.name);
       const relativePath = join(relativeDirectory, entry.name).replaceAll(
         "\\",
         "/"
       );
       if (entry.isDirectory()) {
-        return findOversizedAssets(path10, relativePath);
+        return findOversizedAssets(path11, relativePath);
       }
       if (!entry.isFile()) return [];
-      const size = (await stat(path10)).size;
+      const size = (await stat(path11)).size;
       return size > cloudflareWorkerAssetLimit ? [{ path: relativePath, size }] : [];
     })
   );
@@ -909,19 +1053,146 @@ function isMissingDirectoryError(error) {
 function formatBytes(bytes) {
   return `${(bytes / (1024 * 1024)).toFixed(1)} MiB`;
 }
+async function preserveClientBuildArtifacts(outDir) {
+  const manifestPath = ".vite/manifest.json";
+  let manifestSource;
+  try {
+    manifestSource = await readFile(join(outDir, manifestPath), "utf8");
+  } catch (error) {
+    if (isNotFoundError(error)) return void 0;
+    throw error;
+  }
+  const paths = [manifestPath, ...collectClientAssetPaths(manifestSource)];
+  const stagingDirectory = join(
+    dirname(outDir),
+    ".riebeckite",
+    `client-build-${randomUUID()}`
+  );
+  for (const relativePath of paths) {
+    const source = resolveBuildArtifactPath(outDir, relativePath);
+    const destination = resolveBuildArtifactPath(
+      stagingDirectory,
+      relativePath
+    );
+    await mkdir(dirname(destination), { recursive: true });
+    await rename(source, destination);
+  }
+  return {
+    stagingDirectory,
+    paths,
+    manifestFingerprint: createHash("sha256").update(manifestSource).digest("hex")
+  };
+}
+async function restoreClientBuildArtifacts(outDir, artifacts) {
+  if (!artifacts) return;
+  for (const relativePath of artifacts.paths) {
+    const source = resolveBuildArtifactPath(
+      artifacts.stagingDirectory,
+      relativePath
+    );
+    const destination = resolveBuildArtifactPath(outDir, relativePath);
+    await mkdir(dirname(destination), { recursive: true });
+    await rename(source, destination);
+  }
+}
+async function discardClientBuildArtifacts(artifacts) {
+  if (!artifacts) return;
+  await rm(artifacts.stagingDirectory, { recursive: true, force: true });
+}
+function collectClientAssetPaths(manifestSource) {
+  let manifest;
+  try {
+    manifest = JSON.parse(manifestSource);
+  } catch (error) {
+    throw new Error(
+      `Vite client manifest could not be parsed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (typeof manifest !== "object" || manifest === null || Array.isArray(manifest)) {
+    throw new Error("Vite client manifest must be an object.");
+  }
+  const paths = /* @__PURE__ */ new Set();
+  for (const entry of Object.values(manifest)) {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+      continue;
+    }
+    const assets = entry;
+    addClientAssetPath(paths, assets.file);
+    addClientAssetPaths(paths, assets.css);
+    addClientAssetPaths(paths, assets.assets);
+  }
+  return [...paths].sort();
+}
+function addClientAssetPath(paths, value) {
+  if (typeof value === "string") paths.add(value);
+}
+function addClientAssetPaths(paths, value) {
+  if (!Array.isArray(value)) return;
+  for (const path11 of value) addClientAssetPath(paths, path11);
+}
+function resolveBuildArtifactPath(directory, relativePath) {
+  if (!relativePath || relativePath.startsWith("/") || relativePath.includes("\0")) {
+    throw new Error(
+      `Vite client manifest has an invalid asset path: ${relativePath}`
+    );
+  }
+  const file = resolve(directory, relativePath);
+  const relativePathFromDirectory = relative(directory, file);
+  if (relativePathFromDirectory.startsWith("..") || relativePathFromDirectory === "" || isAbsolutePath(relativePathFromDirectory)) {
+    throw new Error(
+      `Vite client manifest has an unsafe asset path: ${relativePath}`
+    );
+  }
+  return file;
+}
+function isAbsolutePath(path11) {
+  return /^([a-z]:)?[\\/]/iu.test(path11);
+}
+function formatSsrNoExternal() {
+  return "/^honox(?:\\/.*)?$/";
+}
+function logSsgDiagnostics(logger, message) {
+  if (process.env.RIEBECKITE_SSG_DIAGNOSTICS !== "1") return;
+  logger.info(`[riebeckite-ssg] ${message}`);
+}
+function logGeneratedHtmlAssetDiagnostics(logger, pages) {
+  if (process.env.RIEBECKITE_SSG_DIAGNOSTICS !== "1") return;
+  const renderedPages = pages.filter(
+    (page) => !/<meta\b[^>]*\bhttp-equiv=["']refresh["'][^>]*\bcontent=["'][^"']*\burl=/iu.test(
+      page.html
+    )
+  );
+  const cssPages = renderedPages.filter(
+    (page) => /<link\b[^>]*\brel=["'][^"']*\bstylesheet\b[^"']*["']/iu.test(page.html)
+  );
+  const scriptPages = renderedPages.filter(
+    (page) => /<script\b[^>]*\bsrc=["'][^"']+["']/iu.test(page.html)
+  );
+  const missingCss = renderedPages.filter((page) => !cssPages.includes(page)).map((page) => page.path);
+  const missingScript = renderedPages.filter((page) => !scriptPages.includes(page)).map((page) => page.path);
+  logger.info(
+    `[riebeckite-ssg] rendered HTML assets: ${pages.length} documents (${renderedPages.length} pages, ${pages.length - renderedPages.length} redirects) · CSS ${cssPages.length} · JavaScript ${scriptPages.length} · missing CSS ${missingCss.length} · missing JavaScript ${missingScript.length}`
+  );
+  if (missingCss.length > 0 || missingScript.length > 0) {
+    logger.info(
+      `[riebeckite-ssg] missing asset references: CSS ${missingCss.join(", ") || "none"} · JavaScript ${missingScript.join(", ") || "none"}`
+    );
+  }
+}
 function shouldApplyRiebeckiteSsg(_config, env) {
   return env.command === "build" && env.mode !== "client";
 }
 function findBuildOutputSiteCollisions(buildOutputPaths, siteOwnedOutputPaths) {
   const collisions = /* @__PURE__ */ new Set();
-  for (const path10 of buildOutputPaths) {
-    if (siteOwnedOutputPaths.has(path10)) collisions.add(path10);
+  for (const path11 of buildOutputPaths) {
+    if (siteOwnedOutputPaths.has(path11)) collisions.add(path11);
   }
   return [...collisions].sort();
 }
 async function emitGeneratedOutputs(module, emit, affectedPaths, shadowedPaths, onShadowed) {
   const content = module.content;
   if (!content) return 0;
+  if (affectedPaths?.size === 0) return 0;
   const manifest = await content.getManifest();
   let count = 0;
   for (const output of manifest.generatedOutputs ?? []) {
@@ -975,6 +1246,92 @@ async function computeAppFingerprint(root, configFile) {
   }
   return hash.digest("hex");
 }
+async function verifyNoChangeFastPath(input) {
+  const outputCachePath = join(
+    input.root,
+    ".riebeckite",
+    "ssg-output-cache.json"
+  );
+  const cache = await loadFastPathCache(fastPathCachePath(outputCachePath));
+  if (!cache)
+    return { used: false, blockReason: "output-cache-missing-or-invalid" };
+  if (cache.outputCacheChecksum !== await checksumFile(outputCachePath)) {
+    return { used: false, blockReason: "output-cache-missing-or-invalid" };
+  }
+  if (cache.appFingerprint !== await computeAppFingerprint(input.root, cache.configFile)) {
+    return { used: false, blockReason: "app-fingerprint-changed" };
+  }
+  if (cache.publicDirectory && cache.publicFingerprint !== await fingerprintDirectory(cache.publicDirectory)) {
+    return { used: false, blockReason: "static-assets-changed" };
+  }
+  if (input.expectedOutputPaths.some(
+    (output) => !cache.outputPaths.includes(output) || !cache.finalOutputInventory[output]
+  )) {
+    return { used: false, blockReason: "output-cache-incomplete" };
+  }
+  const inventoryStartedAt = performance.now();
+  const currentInventory = await fingerprintOutputDirectory(
+    input.outputDirectory,
+    "",
+    input.metrics
+  );
+  if (input.metrics)
+    input.metrics.outputInventoryValidationDurationMs += performance.now() - inventoryStartedAt;
+  if (!inventoriesEqual(cache.finalOutputInventory, currentInventory)) {
+    return { used: false, blockReason: "output-inventory-mismatch" };
+  }
+  return { used: true };
+}
+async function fingerprintDirectory(directory) {
+  const inventory = await fingerprintOutputDirectory(directory);
+  const hash = createHash("sha256");
+  for (const [path11, checksum] of Object.entries(inventory).sort(
+    ([left], [right]) => left.localeCompare(right)
+  )) {
+    hash.update(path11).update("\0").update(checksum).update("\0");
+  }
+  return hash.digest("hex");
+}
+async function fingerprintOutputDirectory(directory, relativeDirectory = "", metrics) {
+  const entries = await readdir(directory, { withFileTypes: true }).catch(
+    (error) => {
+      if (isMissingDirectoryError(error)) return void 0;
+      throw error;
+    }
+  );
+  if (!entries) return {};
+  const inventory = {};
+  for (const entry of entries) {
+    const file = join(directory, entry.name);
+    const relativePath = join(relativeDirectory, entry.name).replaceAll(
+      "\\",
+      "/"
+    );
+    if (entry.isDirectory()) {
+      Object.assign(
+        inventory,
+        await fingerprintOutputDirectory(file, relativePath, metrics)
+      );
+      continue;
+    }
+    if (entry.isFile()) {
+      const hashedAt = performance.now();
+      const content = await readFile(file);
+      inventory[relativePath] = createHash("sha256").update(content).digest("hex");
+      if (metrics) {
+        metrics.outputHashValidationDurationMs += performance.now() - hashedAt;
+        metrics.outputFilesHashed += 1;
+        metrics.outputBytesHashed += content.length;
+      }
+    }
+  }
+  return inventory;
+}
+function inventoriesEqual(left, right) {
+  const leftPaths = Object.keys(left);
+  const rightPaths = Object.keys(right);
+  return leftPaths.length === rightPaths.length && leftPaths.every((path11) => left[path11] === right[path11]);
+}
 async function collectAppFiles(directory, files) {
   const entries = await readdir(directory, { withFileTypes: true }).catch(
     () => void 0
@@ -990,14 +1347,21 @@ async function collectAppFiles(directory, files) {
     }
   }
 }
-async function loadOutputCache(path10, timingsMs, log = () => {
+async function loadOutputCache(path11, timingsMs, log = () => {
 }) {
+  if (!await isSafeOutputCacheDirectory(dirname(path11))) {
+    log("SSG output cache directory is unsafe and will be ignored.");
+    return void 0;
+  }
+  if (!await isRegularFile(path11)) {
+    return void 0;
+  }
   let raw;
   try {
     raw = await measure(
       timingsMs,
       "outputCacheRead",
-      () => readFile(path10, "utf8")
+      () => readFile(path11, "utf8")
     );
   } catch (error) {
     if (isNotFoundError(error)) return void 0;
@@ -1019,32 +1383,65 @@ async function loadOutputCache(path10, timingsMs, log = () => {
     log("SSG output cache uses an unsupported format and will be rebuilt.");
     return void 0;
   }
+  const entriesAreValid = await measure(
+    timingsMs,
+    "outputCacheEntriesValidate",
+    () => validateOutputCacheEntries(path11, parsed.outputs, timingsMs)
+  );
+  if (!entriesAreValid) {
+    log("SSG output cache entries are corrupted and will be rebuilt.");
+    return void 0;
+  }
   return timingsMs ? { ...parsed, fileSizeBytes: Buffer.byteLength(raw) } : parsed;
 }
 function isOutputCacheState(value) {
   if (typeof value !== "object" || value === null) return false;
   const candidate = value;
-  return candidate.version === 1 && (candidate.appFingerprint === void 0 || typeof candidate.appFingerprint === "string") && isOutputCacheEntries(candidate.outputs);
+  return candidate.version === 4 && (candidate.appFingerprint === void 0 || typeof candidate.appFingerprint === "string") && (candidate.clientManifestFingerprint === void 0 || typeof candidate.clientManifestFingerprint === "string") && isOutputCacheEntries(candidate.outputs) && (candidate.finalOutputInventory === void 0 || isOutputInventory(candidate.finalOutputInventory)) && (candidate.publicDirectory === void 0 || typeof candidate.publicDirectory === "string") && (candidate.publicFingerprint === void 0 || typeof candidate.publicFingerprint === "string") && (candidate.configFile === void 0 || typeof candidate.configFile === "string");
+}
+function isOutputInventory(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.entries(value).every(
+    ([outputPath, checksum]) => isSafeLogicalOutputPath(outputPath) && isChecksum(checksum)
+  );
 }
 function isOutputCacheEntries(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return false;
   }
-  return Object.values(value).every(
-    (entry) => typeof entry === "object" && entry !== null && typeof entry.source === "string" && (entry.encoding === "utf8" || entry.encoding === "base64")
+  return Object.entries(value).every(
+    ([outputPath, entry]) => isSafeLogicalOutputPath(outputPath) && typeof entry === "object" && entry !== null && typeof entry.cachePath === "string" && entry.cachePath === outputCacheEntryName(outputPath) && isChecksum(entry.checksum)
   );
 }
-async function saveOutputCache(path10, state, timingsMs) {
-  const directory = dirname(path10);
+async function saveOutputCache(path11, state, outputDirectory, timingsMs) {
+  const directory = dirname(path11);
   await mkdir(directory, { recursive: true });
-  const temporaryPath = `${path10}.${randomUUID()}.tmp`;
-  const serialized = measureSync(
-    timingsMs,
-    "outputCacheSerialize",
-    () => `${JSON.stringify(state)}
-`
-  );
+  if (!await isSafeOutputCacheDirectory(directory)) {
+    throw new Error(`Unsafe SSG output cache directory: ${directory}`);
+  }
+  if (!await isSafeCacheFileTarget(path11)) {
+    throw new Error(`Unsafe SSG output cache file: ${path11}`);
+  }
+  const entriesPath = outputCacheEntriesPath(path11);
+  const temporaryPath = `${path11}.${randomUUID()}.tmp`;
   try {
+    await waitForFaultInjection("metadata-save-start");
+    const outputs = await measure(
+      timingsMs,
+      "outputCacheEntriesWrite",
+      () => saveOutputCacheEntries(
+        entriesPath,
+        outputDirectory,
+        state.outputs,
+        state.finalOutputInventory,
+        timingsMs
+      )
+    );
+    const serialized = measureSync(
+      timingsMs,
+      "outputCacheSerialize",
+      () => `${JSON.stringify({ ...state, outputs })}
+`
+    );
     await measure(
       timingsMs,
       "outputCacheWrite",
@@ -1053,13 +1450,157 @@ async function saveOutputCache(path10, state, timingsMs) {
     await measure(
       timingsMs,
       "outputCacheRename",
-      () => replaceFile(temporaryPath, path10)
+      () => replaceFile(temporaryPath, path11)
+    );
+    await waitForFaultInjection("metadata-committed");
+    const checksum = createHash("sha256").update(serialized).digest("hex");
+    if (state.finalOutputInventory && state.configFile) {
+      await saveFastPathCache(
+        fastPathCachePath(path11),
+        createFastPathCacheState(state, checksum),
+        timingsMs
+      );
+    }
+    await collectUnreferencedOutputCacheEntries(
+      outputCacheEntriesPath(path11),
+      outputs,
+      timingsMs
+    );
+    return checksum;
+  } catch (error) {
+    await rm(temporaryPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+function outputCacheEntriesPath(outputCachePath) {
+  return outputCachePath.replace(/\.json$/, ".entries");
+}
+async function saveOutputCacheEntries(directory, outputDirectory, outputs, finalOutputInventory, timingsMs) {
+  await ensureOutputCacheEntriesDirectory(directory);
+  const entries = {};
+  for (const outputPath of Object.keys(outputs).sort()) {
+    assertSafeLogicalOutputPath(outputPath);
+    const existing = outputs[outputPath];
+    if (existing.cachePath && existing.checksum) {
+      if (existing.cachePath !== outputCacheEntryName(outputPath) || !isChecksum(existing.checksum)) {
+        throw new Error(`Invalid SSG output cache entry: ${outputPath}`);
+      }
+      entries[outputPath] = existing;
+      continue;
+    }
+    const source = resolveOutputCacheFile(outputDirectory, outputPath);
+    const cachePath = outputCacheEntryName(outputPath);
+    const destination = join(directory, cachePath);
+    await waitForFaultInjection("entry-create-start");
+    await replaceOutputCacheEntry(source, destination, timingsMs);
+    const checksum = finalOutputInventory?.[outputPath];
+    if (!checksum) {
+      const cachedChecksum = await checksumFile(destination);
+      if (!cachedChecksum) {
+        throw new Error(`Could not checksum cached output: ${outputPath}`);
+      }
+      entries[outputPath] = { cachePath, checksum: cachedChecksum };
+      continue;
+    }
+    entries[outputPath] = { cachePath, checksum };
+  }
+  return entries;
+}
+async function validateOutputCacheEntries(outputCachePath, entries, timingsMs) {
+  try {
+    const directory = outputCacheEntriesPath(outputCachePath);
+    if (!await isSafeOutputCacheEntriesDirectory(directory)) return false;
+    for (const [outputPath, entry] of Object.entries(entries)) {
+      if (!isSafeLogicalOutputPath(outputPath) || entry.cachePath !== outputCacheEntryName(outputPath) || !isChecksum(entry.checksum)) {
+        return false;
+      }
+      const path11 = resolveOutputCacheFile(directory, entry.cachePath);
+      if (!await isRegularFile(path11)) return false;
+      if (await measure(
+        timingsMs,
+        "outputCacheEntryChecksum",
+        () => checksumFile(path11)
+      ) !== entry.checksum)
+        return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function fastPathCachePath(outputCachePath) {
+  return outputCachePath.replace(/\.json$/, ".fast-path.json");
+}
+function createFastPathCacheState(state, outputCacheChecksum) {
+  if (!state.finalOutputInventory || !state.configFile) {
+    throw new Error("SSG output cache is missing fast-path validation data.");
+  }
+  return {
+    version: 1,
+    outputCacheChecksum,
+    appFingerprint: state.appFingerprint,
+    finalOutputInventory: state.finalOutputInventory,
+    publicDirectory: state.publicDirectory,
+    publicFingerprint: state.publicFingerprint,
+    configFile: state.configFile,
+    outputPaths: Object.keys(state.outputs).sort()
+  };
+}
+async function saveFastPathCache(path11, state, timingsMs) {
+  const directory = dirname(path11);
+  await mkdir(directory, { recursive: true });
+  if (!await isSafeOutputCacheDirectory(directory)) {
+    throw new Error(`Unsafe SSG fast-path cache directory: ${directory}`);
+  }
+  if (!await isSafeCacheFileTarget(path11)) {
+    throw new Error(`Unsafe SSG fast-path cache file: ${path11}`);
+  }
+  const temporaryPath = `${path11}.${randomUUID()}.tmp`;
+  try {
+    await waitForFaultInjection("sidecar-save-start");
+    await measure(
+      timingsMs,
+      "sidecarWrite",
+      () => writeFile(temporaryPath, `${JSON.stringify(state)}
+`, "utf8")
     );
+    await measure(
+      timingsMs,
+      "sidecarRename",
+      () => replaceFile(temporaryPath, path11)
+    );
+    await waitForFaultInjection("sidecar-committed");
   } catch (error) {
     await rm(temporaryPath, { force: true }).catch(() => void 0);
     throw error;
   }
 }
+async function loadFastPathCache(path11) {
+  try {
+    if (!await isSafeOutputCacheDirectory(dirname(path11))) return void 0;
+    if (!await isRegularFile(path11)) return void 0;
+    const candidate = JSON.parse(await readFile(path11, "utf8"));
+    return isFastPathCacheState(candidate) ? candidate : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isFastPathCacheState(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  return candidate.version === 1 && typeof candidate.outputCacheChecksum === "string" && (candidate.appFingerprint === void 0 || typeof candidate.appFingerprint === "string") && isOutputInventory(candidate.finalOutputInventory) && (candidate.publicDirectory === void 0 || typeof candidate.publicDirectory === "string") && (candidate.publicFingerprint === void 0 || typeof candidate.publicFingerprint === "string") && typeof candidate.configFile === "string" && Array.isArray(candidate.outputPaths) && candidate.outputPaths.every(isSafeLogicalOutputPath) && candidate.outputPaths.every(
+    (path11, index, paths) => index === 0 || paths[index - 1] < path11
+  );
+}
+async function checksumFile(path11) {
+  const hash = createHash("sha256");
+  try {
+    for await (const chunk of createReadStream(path11)) hash.update(chunk);
+    return hash.digest("hex");
+  } catch {
+    return void 0;
+  }
+}
 async function replaceFile(temporaryPath, targetPath) {
   try {
     await rename(temporaryPath, targetPath);
@@ -1079,11 +1620,160 @@ function isReplacementFailure(error) {
 function isNotFoundError(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
-function encodeOutput(source) {
-  return typeof source === "string" ? { source, encoding: "utf8" } : { source: Buffer.from(source).toString("base64"), encoding: "base64" };
+async function decodeOutput(outputCachePath, entry) {
+  const file = resolveOutputCacheFile(
+    outputCacheEntriesPath(outputCachePath),
+    entry.cachePath
+  );
+  const content = await readFile(file);
+  const checksum = createHash("sha256").update(content).digest("hex");
+  if (checksum !== entry.checksum) {
+    throw new Error("SSG output cache entry checksum mismatch.");
+  }
+  return content;
+}
+function resolveOutputCacheFile(directory, relativePath) {
+  if (!relativePath || relativePath.includes("\0") || isAbsolutePath(relativePath)) {
+    throw new Error(`Invalid SSG output cache path: ${relativePath}`);
+  }
+  const file = resolve(directory, relativePath);
+  const relativePathFromDirectory = relative(directory, file);
+  if (relativePathFromDirectory.startsWith("..") || relativePathFromDirectory === "" || isAbsolutePath(relativePathFromDirectory)) {
+    throw new Error(`Unsafe SSG output cache path: ${relativePath}`);
+  }
+  return file;
+}
+function isSafeLogicalOutputPath(path11) {
+  if (typeof path11 !== "string" || !path11 || path11.includes("\\") || path11.includes("\0") || isAbsolutePath(path11)) {
+    return false;
+  }
+  try {
+    resolveOutputCacheFile("/riebeckite-output-root", path11);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function assertSafeLogicalOutputPath(path11) {
+  if (!isSafeLogicalOutputPath(path11)) {
+    throw new Error(`Invalid SSG output path: ${path11}`);
+  }
+}
+function outputCacheEntryName(outputPath) {
+  return createHash("sha256").update(outputPath).digest("hex");
+}
+function isChecksum(value) {
+  return typeof value === "string" && /^[a-f0-9]{64}$/u.test(value);
+}
+async function ensureOutputCacheEntriesDirectory(directory) {
+  await mkdir(directory, { recursive: true });
+  if (!await isSafeOutputCacheEntriesDirectory(directory)) {
+    throw new Error(`Unsafe SSG output cache entries directory: ${directory}`);
+  }
+}
+async function isSafeOutputCacheDirectory(directory) {
+  try {
+    const info = await lstat(directory);
+    return info.isDirectory() && !info.isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+async function isSafeCacheFileTarget(path11) {
+  try {
+    return !(await lstat(path11)).isSymbolicLink();
+  } catch (error) {
+    return isNotFoundError(error);
+  }
+}
+async function isSafeOutputCacheEntriesDirectory(directory) {
+  return isSafeOutputCacheDirectory(directory);
+}
+async function isRegularFile(path11) {
+  try {
+    const info = await lstat(path11);
+    return info.isFile() && !info.isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+async function replaceOutputCacheEntry(source, destination, timingsMs) {
+  if ((await lstat(destination).catch(() => void 0))?.isSymbolicLink()) {
+    throw new Error(`Unsafe SSG output cache entry: ${destination}`);
+  }
+  const temporaryPath = `${destination}.${randomUUID()}.tmp`;
+  try {
+    await measure(
+      timingsMs,
+      "outputCacheEntryWrite",
+      () => writeFile(temporaryPath, new Uint8Array())
+    );
+    await waitForFaultInjection("entry-body-write");
+    await measure(
+      timingsMs,
+      "outputCacheEntryCopy",
+      () => copyFile(source, temporaryPath)
+    );
+    await waitForFaultInjection("entry-rename-before");
+    await measure(
+      timingsMs,
+      "outputCacheEntryRename",
+      () => replaceFile(temporaryPath, destination)
+    );
+    await waitForFaultInjection("entry-committed");
+  } catch (error) {
+    await rm(temporaryPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+async function collectUnreferencedOutputCacheEntries(directory, outputs, timingsMs) {
+  try {
+    if (!await isSafeOutputCacheEntriesDirectory(directory)) return;
+    await waitForFaultInjection("gc-start");
+    const referenced = new Set(
+      Object.values(outputs).map((entry) => entry.cachePath)
+    );
+    const entries = await measure(
+      timingsMs,
+      "outputCacheGcScan",
+      () => readdir(directory, { withFileTypes: true })
+    );
+    for (const entry of entries) {
+      if (!/^[a-f0-9]{64}$/u.test(entry.name) || referenced.has(entry.name)) {
+        continue;
+      }
+      const path11 = join(directory, entry.name);
+      if (await isRegularFile(path11)) {
+        await waitForFaultInjection("gc-entry-delete");
+        await measure(
+          timingsMs,
+          "outputCacheGcDelete",
+          () => rm(path11, { force: true })
+        );
+      }
+    }
+  } catch {
+    return;
+  }
 }
-function decodeOutput(entry) {
-  return entry.encoding === "utf8" ? entry.source : Buffer.from(entry.source, "base64");
+async function waitForFaultInjection(point) {
+  if (process.env.NODE_ENV !== "test" || process.env.RIEBECKITE_SSG_FAULT_INJECTION !== "1" || process.env.RIEBECKITE_SSG_FAULT_POINT !== point) {
+    return;
+  }
+  const occurrence = Number.parseInt(
+    process.env.RIEBECKITE_SSG_FAULT_OCCURRENCE ?? "1",
+    10
+  );
+  const count = (faultInjectionCounts.get(point) ?? 0) + 1;
+  faultInjectionCounts.set(point, count);
+  if (!Number.isSafeInteger(occurrence) || occurrence < 1 || count !== occurrence)
+    return;
+  const signalFile = process.env.RIEBECKITE_SSG_FAULT_SIGNAL_FILE;
+  if (!signalFile) return;
+  await writeFile(signalFile, `${point}
+`, "utf8");
+  await new Promise(() => {
+  });
 }
 async function writeSsgOutputMetrics(metrics) {
   const file = process.env.RIEBECKITE_SSG_METRICS_FILE;
@@ -1092,6 +1782,7 @@ async function writeSsgOutputMetrics(metrics) {
 `, "utf8");
 }
 async function measure(timingsMs, name, fn) {
+  if (!timingsMs) return await fn();
   const start = performance.now();
   try {
     return await fn();
@@ -1101,6 +1792,7 @@ async function measure(timingsMs, name, fn) {
   }
 }
 function measureSync(timingsMs, name, fn) {
+  if (!timingsMs) return fn();
   const start = performance.now();
   try {
     return fn();
@@ -1156,11 +1848,11 @@ function createRiebeckiteSsg(options = {}) {
 }
 
 // src/vite_plugin.ts
-import path9 from "node:path";
+import path10 from "node:path";
 
 // src/asset_entries.ts
-import fs5 from "node:fs";
-import path7 from "node:path";
+import fs6 from "node:fs";
+import path8 from "node:path";
 import { uniqueStrings } from "@riebeckite/core";
 function writeRiebeckiteAssetEntries(config, paths) {
   writeGeneratedFile(paths.frameworkStyles, createFrameworkStylesEntry());
@@ -1201,12 +1893,12 @@ ${imports}
 }
 function writeGeneratedFile(filePath, contents) {
   if (readGeneratedFile(filePath) === contents) return;
-  fs5.mkdirSync(path7.dirname(filePath), { recursive: true });
-  fs5.writeFileSync(filePath, contents);
+  fs6.mkdirSync(path8.dirname(filePath), { recursive: true });
+  fs6.writeFileSync(filePath, contents);
 }
 function readGeneratedFile(filePath) {
   try {
-    return fs5.readFileSync(filePath, "utf8");
+    return fs6.readFileSync(filePath, "utf8");
   } catch (error) {
     if (isNotFoundError2(error)) return void 0;
     throw error;
@@ -1274,8 +1966,8 @@ ${initializers.map((initializer) => `  ${initializer};`).join("\n")}
 }
 
 // src/vite_runner.ts
-import fs6 from "node:fs/promises";
-import path8 from "node:path";
+import fs7 from "node:fs/promises";
+import path9 from "node:path";
 import { build, createServer as createServer2 } from "vite";
 var viteConfigFileNames = [
   "vite.config.ts",
@@ -1301,10 +1993,10 @@ var HonoxApplicationRootError = class extends Error {
   }
 };
 async function resolveHonoxApplication(options) {
-  const configRoot = path8.resolve(options.configRoot);
-  const appRoot = options.appRoot ? path8.resolve(options.appRoot) : await resolveHonoxApplicationRoot(configRoot, options.startDirectory);
+  const configRoot = path9.resolve(options.configRoot);
+  const appRoot = options.appRoot ? path9.resolve(options.appRoot) : await resolveHonoxApplicationRoot(configRoot, options.startDirectory);
   const workspaceRoot = options.workspaceRoot ?? await findWorkspaceRoot(configRoot);
-  const configFile = path8.resolve(
+  const configFile = path9.resolve(
     configRoot,
     options.configFile ?? "riebeckite.config.ts"
   );
@@ -1324,14 +2016,14 @@ async function resolveHonoxApplication(options) {
 }
 async function findWorkspaceRoot(configRoot) {
   try {
-    const workspaceConfig = path8.join(configRoot, "pnpm-workspace.yaml");
-    return (await fs6.stat(workspaceConfig)).isFile() ? configRoot : void 0;
+    const workspaceConfig = path9.join(configRoot, "pnpm-workspace.yaml");
+    return (await fs7.stat(workspaceConfig)).isFile() ? configRoot : void 0;
   } catch {
     return void 0;
   }
 }
 async function startHonoxDevServer(options) {
-  const root = path8.resolve(options.root);
+  const root = path9.resolve(options.root);
   await withWorkingDirectory(root, async () => {
     const server = await createServer2({ root });
     await server.listen();
@@ -1340,7 +2032,7 @@ async function startHonoxDevServer(options) {
   });
 }
 async function buildHonoxApplication(options) {
-  const root = path8.resolve(options.root);
+  const root = path9.resolve(options.root);
   await withWorkingDirectory(root, async () => {
     await runTraced(
       options.tracer,
@@ -1385,34 +2077,34 @@ async function findViteApplicationRoots(root, startDirectory) {
     const directory = directories.pop();
     if (!directory) continue;
     if (await hasViteConfig(directory)) applicationRoots.push(directory);
-    const entries = await fs6.readdir(directory, { withFileTypes: true });
+    const entries = await fs7.readdir(directory, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name === "node_modules" || entry.name === ".git" || entry.name === "tests") {
         continue;
       }
-      directories.push(path8.join(directory, entry.name));
+      directories.push(path9.join(directory, entry.name));
     }
   }
   return applicationRoots;
 }
 async function findViteApplicationRootFrom(startDirectory, configRoot) {
-  let directory = path8.resolve(startDirectory);
+  let directory = path9.resolve(startDirectory);
   while (isWithin(configRoot, directory)) {
     if (await hasViteConfig(directory)) return directory;
-    const parent = path8.dirname(directory);
+    const parent = path9.dirname(directory);
     if (parent === directory) return void 0;
     directory = parent;
   }
   return void 0;
 }
 function isWithin(parent, target) {
-  const relative2 = path8.relative(parent, target);
-  return relative2 === "" || !relative2.startsWith("..") && !path8.isAbsolute(relative2);
+  const relative2 = path9.relative(parent, target);
+  return relative2 === "" || !relative2.startsWith("..") && !path9.isAbsolute(relative2);
 }
 async function hasViteConfig(directory) {
   for (const fileName of viteConfigFileNames) {
     try {
-      if ((await fs6.stat(path8.join(directory, fileName))).isFile()) return true;
+      if ((await fs7.stat(path9.join(directory, fileName))).isFile()) return true;
     } catch {
     }
   }
@@ -1430,7 +2122,7 @@ var defaultSsrExternals = [
   "vfile-matter",
   "yaml"
 ];
-function riebeckite(options = {}) {
+function riebeckite(options = {}, onApplicationResolved) {
   let resolvedConfig;
   let application;
   const getConfig = () => {
@@ -1443,7 +2135,7 @@ function riebeckite(options = {}) {
     {
       name: "riebeckite-host-integration",
       async config(userConfig) {
-        const root = userConfig.root ? path9.resolve(userConfig.root) : process.cwd();
+        const root = userConfig.root ? path10.resolve(userConfig.root) : process.cwd();
         const appRoot = options.appRoot ?? root;
         const resolvedApplication = await resolveHonoxApplication({
           configRoot: options.configRoot ?? appRoot,
@@ -1453,13 +2145,14 @@ function riebeckite(options = {}) {
         });
         resolvedConfig = resolvedApplication.config;
         application = resolvedApplication;
+        onApplicationResolved?.(resolvedApplication);
         writeRiebeckiteAssetEntries(resolvedConfig, {
-          frameworkStyles: path9.join(
+          frameworkStyles: path10.join(
             appRoot,
             "app/.riebeckite/framework-styles.css"
           ),
-          pluginStyles: path9.join(appRoot, "app/.riebeckite/plugin-styles.css"),
-          themeStyles: path9.join(appRoot, "app/.riebeckite/theme-styles.css")
+          pluginStyles: path10.join(appRoot, "app/.riebeckite/plugin-styles.css"),
+          themeStyles: path10.join(appRoot, "app/.riebeckite/theme-styles.css")
         });
         return {
           define: {
@@ -1497,13 +2190,24 @@ function requireApplication(application) {
 }
 function riebeckiteVite(options = {}) {
   const { ssg, ssrExternals, ...integration } = options;
+  const fallbackSiteRoot = integration.configRoot ?? integration.appRoot;
+  let resolvedSiteRoot;
   return [
-    ...riebeckite(integration),
-    riebeckiteSsrExternals([...defaultSsrExternals, ...ssrExternals ?? []]),
+    ...riebeckite(integration, (application) => {
+      resolvedSiteRoot = application.configRoot;
+    }),
+    riebeckiteSsrExternals(
+      [...defaultSsrExternals, ...ssrExternals ?? []],
+      () => {
+        if (integration.workspaceRoot) return [];
+        const siteRoot = resolvedSiteRoot ?? fallbackSiteRoot;
+        return siteRoot ? siteRiebeckiteExternals(siteRoot) : [];
+      }
+    ),
     createRiebeckiteSsg(ssg)
   ];
 }
-function riebeckiteSsrExternals(externals) {
+function riebeckiteSsrExternals(externals, siteExternals = () => []) {
   return {
     name: "riebeckite-ssr-externals",
     config() {
@@ -1511,7 +2215,7 @@ function riebeckiteSsrExternals(externals) {
         environments: {
           ssr: {
             resolve: {
-              external: [...externals]
+              external: [...externals, ...siteExternals()]
             }
           }
         }
@@ -1521,6 +2225,7 @@ function riebeckiteSsrExternals(externals) {
 }
 export {
   buildHonoxApplication,
+  createNoChangeFastPathOutputMetrics,
   createRiebeckiteSsg,
   defaultSsgEntry,
   defaultSsrExternals,
@@ -1533,5 +2238,6 @@ export {
   riebeckiteSsg,
   riebeckiteSsgExtensionMap,
   riebeckiteVite,
-  startHonoxDevServer
+  startHonoxDevServer,
+  verifyNoChangeFastPath
 };