@askrjs/askr 0.2.3 → 0.3.0

package/dist/ssg/index.js

@@ -1,14 +1,109 @@
-import "../access-Rr7CMa06.js";
-import { n as createRouteRegistry } from "../manifest-D6rfj_jC.js";
-import { o as addRouteBasePath } from "../route-matching-Bo6UqG-5.js";
-import { c as route, n as resolveDeferredValues } from "../deferred-BELyvMsC.js";
-import { S as RouteDataLoadError, c as prepareRouteHydrationData, t as bindResolvedRouteData, v as getRenderHandler, y as _preloadRouteHandler } from "../resolution-t8J0yNaU.js";
-import { n as renderDocument } from "../ssr-DSHd_Q9K.js";
-import { n as renderToString } from "../ssr-BaC5qHEw.js";
-import * as fs from "node:fs/promises";
-import * as pathModule from "node:path";
+import "../access-CEA2pOry.js";
+import { n as createRouteRegistry } from "../manifest-D1P3UNWV.js";
+import { _ as prepareRouteHydrationData, d as _preloadRouteHandler, m as RouteDataLoadError, t as bindResolvedRouteData, u as getRenderHandler } from "../resolution-3DskUkjG.js";
+import { o as addRouteBasePath } from "../route-matching-CUzZ31gT.js";
+import { c as route, n as resolveDeferredValues } from "../deferred-CbgNhf67.js";
+import { n as renderDocument } from "../ssr-EPjwJH5R.js";
+import { n as renderToString } from "../ssr-CiNm6Vzl.js";
+import * as fs$1 from "node:fs/promises";
 import * as os from "node:os";
-import * as fsSync from "node:fs";
+import * as pathModule from "node:path";
+import * as fs from "node:fs";
+//#region src/ssg/parallelism.ts
+function resolveParallelism(requested) {
+	if (requested !== "auto") return Math.max(1, requested ?? 1);
+	const maybeNavigator = globalThis;
+	const envWorkers = Number(maybeNavigator.process?.env?.ASKR_SSG_WORKERS ?? maybeNavigator.process?.env?.NUMBER_OF_PROCESSORS ?? maybeNavigator.process?.env?.UV_THREADPOOL_SIZE);
+	if (Number.isFinite(envWorkers) && envWorkers > 0) return Math.max(1, Math.trunc(envWorkers));
+	if (typeof maybeNavigator.navigator?.hardwareConcurrency === "number") return Math.max(1, maybeNavigator.navigator.hardwareConcurrency);
+	const availableParallelism = os.availableParallelism;
+	return Math.max(1, availableParallelism?.() ?? os.cpus().length ?? 1);
+}
+//#endregion
+//#region src/ssg/output-publication.ts
+const outputDirectoryQueues = /* @__PURE__ */ new Map();
+async function withOutputDirectoryLock(outputDir, operation) {
+	const key = pathModule.resolve(outputDir).normalize("NFC").toLowerCase();
+	const previous = outputDirectoryQueues.get(key) ?? Promise.resolve();
+	let release;
+	const current = new Promise((resolve) => {
+		release = resolve;
+	});
+	const tail = previous.then(() => current, () => current);
+	outputDirectoryQueues.set(key, tail);
+	await previous.catch(() => void 0);
+	try {
+		return await operation();
+	} finally {
+		release();
+		if (outputDirectoryQueues.get(key) === tail) outputDirectoryQueues.delete(key);
+	}
+}
+async function createStagingDirectory(outputDir) {
+	const parent = pathModule.dirname(outputDir);
+	const base = pathModule.basename(outputDir);
+	await fs$1.mkdir(parent, { recursive: true });
+	return fs$1.mkdtemp(pathModule.join(parent, `.${base}.askr-staging-`));
+}
+function resolveAssetDestination(outputDir, source) {
+	const relativeDestination = source.to ?? pathModule.basename(source.from);
+	const destination = pathModule.resolve(outputDir, relativeDestination);
+	const relative = pathModule.relative(pathModule.resolve(outputDir), destination);
+	if (relative.startsWith("..") || pathModule.isAbsolute(relative)) throw new Error(`SSG asset destination must stay inside outputDir: ${relativeDestination}`);
+	return destination;
+}
+async function copyStaticAssets(assets, outputDir) {
+	for (const source of assets ?? []) {
+		if (!source.from || source.from.trim().length === 0) throw new Error("SSG asset source requires a non-empty from path");
+		const from = pathModule.resolve(source.from);
+		const to = resolveAssetDestination(outputDir, source);
+		await fs$1.mkdir(pathModule.dirname(to), { recursive: true });
+		await fs$1.cp(from, to, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+async function replaceOutputDirectory(stagingDir, outputDir, fileOperations = fs$1) {
+	const parent = pathModule.dirname(outputDir);
+	const backupDir = pathModule.join(parent, `.${pathModule.basename(outputDir)}.askr-backup-${Date.now()}`);
+	let backedUp = false;
+	let failed = false;
+	let failure;
+	try {
+		try {
+			await fileOperations.rename(outputDir, backupDir);
+			backedUp = true;
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+		await fileOperations.rename(stagingDir, outputDir);
+		await fileOperations.rm(backupDir, {
+			recursive: true,
+			force: true
+		});
+	} catch (error) {
+		failed = true;
+		failure = error;
+		if (backedUp) try {
+			await fileOperations.rm(outputDir, {
+				recursive: true,
+				force: true
+			});
+			await fileOperations.rename(backupDir, outputDir);
+		} catch {}
+	}
+	try {
+		await fileOperations.rm(stagingDir, {
+			recursive: true,
+			force: true
+		});
+	} catch (error) {
+		if (!failed) throw error;
+	}
+	if (failed) throw failure;
+}
+//#endregion
 //#region src/ssg/route-utils.ts
 function getPortableOutputPathKey(filePath) {
 	return filePath.normalize("NFC").replaceAll("\\", "/").toLowerCase();
@@ -312,15 +407,13 @@ function resolveSsgOutputPath(outputDir, filePath) {
 * Write rendered routes to disk
 * Creates outputDir/{route-path}/index.html structure
 */
-async function writeStaticFiles(results, outputDir, options = {}, fileOperations = fs) {
+async function writeStaticFiles(results, outputDir, options = {}, fileOperations = fs$1) {
 	await fileOperations.mkdir(outputDir, { recursive: true });
 	for (const result of results) {
 		if (result.status !== "removed") continue;
 		const fullPath = resolveSsgOutputPath(outputDir, result.filePath);
-		if (fsSync.existsSync(fullPath)) {
-			await fileOperations.rm(fullPath, { force: true });
-			await pruneEmptyDirs(pathModule.dirname(fullPath), outputDir, fileOperations);
-		}
+		await fileOperations.rm(fullPath, { force: true });
+		await pruneEmptyDirs(pathModule.dirname(fullPath), outputDir, fileOperations);
 	}
 	const pendingWrites = [];
 	const reportedErrors = /* @__PURE__ */ new Set();
@@ -348,23 +441,42 @@ async function writeStaticFiles(results, outputDir, options = {}, fileOperations
 	for (const dir of directories) await fileOperations.mkdir(dir, { recursive: true });
 	const concurrency = Math.max(1, Math.min(options.concurrency ?? 8, pendingWrites.length || 1));
 	let nextIndex = 0;
+	let failed = false;
+	let failure;
+	const recordFailure = (error) => {
+		if (!failed) {
+			failed = true;
+			failure = error;
+		}
+	};
 	const worker = async () => {
-		while (true) {
-			const current = nextIndex;
-			nextIndex += 1;
-			if (current >= pendingWrites.length) return;
-			const result = pendingWrites[current];
-			const fullPath = resolveSsgOutputPath(outputDir, result.filePath);
-			const tempPath = pathModule.join(pathModule.dirname(fullPath), `.${pathModule.basename(fullPath)}.askr-${process.pid}-${current}.tmp`);
-			try {
-				await fileOperations.writeFile(tempPath, result.html, "utf8");
-				await fileOperations.rename(tempPath, fullPath);
-			} finally {
-				await fileOperations.rm(tempPath, { force: true });
+		try {
+			while (!failed) {
+				const current = nextIndex;
+				nextIndex += 1;
+				if (current >= pendingWrites.length) return;
+				const result = pendingWrites[current];
+				const fullPath = resolveSsgOutputPath(outputDir, result.filePath);
+				const tempPath = pathModule.join(pathModule.dirname(fullPath), `.${pathModule.basename(fullPath)}.askr-${process.pid}-${current}.tmp`);
+				try {
+					await fileOperations.writeFile(tempPath, result.html, "utf8");
+					await fileOperations.rename(tempPath, fullPath);
+				} catch (error) {
+					recordFailure(error);
+				} finally {
+					try {
+						await fileOperations.rm(tempPath, { force: true });
+					} catch (error) {
+						recordFailure(error);
+					}
+				}
 			}
+		} catch (error) {
+			recordFailure(error);
 		}
 	};
 	await Promise.all(Array.from({ length: concurrency }, () => worker()));
+	if (failed) throw failure;
 }
 async function pruneEmptyDirs(startDir, rootDir, fileOperations) {
 	let current = startDir;
@@ -372,8 +484,12 @@ async function pruneEmptyDirs(startDir, rootDir, fileOperations) {
 	while (pathModule.resolve(current) !== normalizedRoot) {
 		const relative = pathModule.relative(normalizedRoot, current);
 		if (relative === ".." || relative.startsWith(`..${pathModule.sep}`) || pathModule.isAbsolute(relative)) break;
-		if (!fsSync.existsSync(current)) break;
-		if ((await fileOperations.readdir(current)).length > 0) break;
+		try {
+			if ((await fileOperations.readdir(current)).length > 0) break;
+		} catch (error) {
+			if (error.code === "ENOENT") break;
+			throw error;
+		}
 		await fileOperations.rmdir(current);
 		current = pathModule.dirname(current);
 	}
@@ -464,8 +580,8 @@ function resultToMetadata(result) {
 */
 async function writeMetadata(metadata, outputDir) {
 	const filePath = pathModule.join(outputDir, "metadata.json");
-	await fs.mkdir(outputDir, { recursive: true });
-	await fs.writeFile(filePath, JSON.stringify(metadata, null, 2), "utf8");
+	await fs$1.mkdir(outputDir, { recursive: true });
+	await fs$1.writeFile(filePath, JSON.stringify(metadata, null, 2), "utf8");
 }
 const MANIFEST_DIR = ".askr";
 const MANIFEST_FILE = "ssg-manifest.json";
@@ -482,9 +598,9 @@ function getIncrementalManifestPath(outputDir) {
 }
 function readIncrementalManifest(outputDir, seed) {
 	const manifestPath = getIncrementalManifestPath(outputDir);
-	if (!fsSync.existsSync(manifestPath)) return null;
+	if (!fs.existsSync(manifestPath)) return null;
 	try {
-		const raw = fsSync.readFileSync(manifestPath, "utf8");
+		const raw = fs.readFileSync(manifestPath, "utf8");
 		const parsed = JSON.parse(raw);
 		if (parsed.schemaVersion !== 1 || parsed.seed !== seed || !Array.isArray(parsed.routes)) return null;
 		const routes = parsed.routes.filter((entry) => !!entry && typeof entry.routeId === "string" && typeof entry.path === "string" && typeof entry.filePath === "string" && isContainedManifestFilePath(outputDir, entry.filePath) && Array.isArray(entry.invalidationKeys) && (entry.htmlHash === null || typeof entry.htmlHash === "string") && (entry.lastStatus === "success" || entry.lastStatus === "error"));
@@ -510,20 +626,20 @@ function isContainedManifestFilePath(outputDir, filePath) {
 async function writeIncrementalManifest(manifest, outputDir) {
 	if (!manifest.routes.every((entry) => isContainedManifestFilePath(outputDir, entry.filePath))) throw new Error("SSG manifest contains a path outside outputDir.");
 	const manifestPath = getIncrementalManifestPath(outputDir);
-	await fs.mkdir(pathModule.dirname(manifestPath), { recursive: true });
-	await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf8");
+	await fs$1.mkdir(pathModule.dirname(manifestPath), { recursive: true });
+	await fs$1.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf8");
 }
 function getExistingOutputFileSize(outputDir, filePath) {
 	const fullPath = resolveSsgOutputPath(outputDir, filePath);
-	if (!fsSync.existsSync(fullPath)) return 0;
+	if (!fs.existsSync(fullPath)) return 0;
 	try {
-		return fsSync.statSync(fullPath).size;
+		return fs.statSync(fullPath).size;
 	} catch {
 		return 0;
 	}
 }
 function outputFileExists(outputDir, filePath) {
-	return fsSync.existsSync(resolveSsgOutputPath(outputDir, filePath));
+	return fs.existsSync(resolveSsgOutputPath(outputDir, filePath));
 }
 //#endregion
 //#region src/ssg/generation-plan.ts
@@ -671,107 +787,114 @@ function routeRegistryToRouteConfigs(registry) {
 }
 //#endregion
 //#region src/ssg/create-static-gen.ts
-function resolveParallelism(requested) {
-	if (requested !== "auto") return Math.max(1, requested ?? 1);
-	const maybeNavigator = globalThis;
-	const envWorkers = Number(maybeNavigator.process?.env?.ASKR_SSG_WORKERS ?? maybeNavigator.process?.env?.NUMBER_OF_PROCESSORS ?? maybeNavigator.process?.env?.UV_THREADPOOL_SIZE);
-	if (Number.isFinite(envWorkers) && envWorkers > 0) return Math.max(1, Math.trunc(envWorkers));
-	if (typeof maybeNavigator.navigator?.hardwareConcurrency === "number") return Math.max(1, maybeNavigator.navigator.hardwareConcurrency);
-	const availableParallelism = os.availableParallelism;
-	return Math.max(1, availableParallelism?.() ?? os.cpus().length ?? 1);
-}
-const outputDirectoryQueues = /* @__PURE__ */ new Map();
-async function withOutputDirectoryLock(outputDir, operation) {
-	const key = pathModule.resolve(outputDir).normalize("NFC").toLowerCase();
-	const previous = outputDirectoryQueues.get(key) ?? Promise.resolve();
-	let release;
-	const current = new Promise((resolve) => {
-		release = resolve;
-	});
-	const tail = previous.then(() => current, () => current);
-	outputDirectoryQueues.set(key, tail);
-	await previous.catch(() => void 0);
-	try {
-		return await operation();
-	} finally {
-		release();
-		if (outputDirectoryQueues.get(key) === tail) outputDirectoryQueues.delete(key);
-	}
-}
-async function createStagingDirectory(outputDir) {
-	const parent = pathModule.dirname(outputDir);
-	const base = pathModule.basename(outputDir);
-	await fs.mkdir(parent, { recursive: true });
-	return fs.mkdtemp(pathModule.join(parent, `.${base}.askr-staging-`));
-}
-function resolveAssetDestination(outputDir, source) {
-	const relativeDestination = source.to ?? pathModule.basename(source.from);
-	const destination = pathModule.resolve(outputDir, relativeDestination);
-	const relative = pathModule.relative(pathModule.resolve(outputDir), destination);
-	if (relative.startsWith("..") || pathModule.isAbsolute(relative)) throw new Error(`SSG asset destination must stay inside outputDir: ${relativeDestination}`);
-	return destination;
-}
-async function copyStaticAssets(assets, outputDir) {
-	for (const source of assets ?? []) {
-		if (!source.from || source.from.trim().length === 0) throw new Error("SSG asset source requires a non-empty from path");
-		const from = pathModule.resolve(source.from);
-		const to = resolveAssetDestination(outputDir, source);
-		await fs.mkdir(pathModule.dirname(to), { recursive: true });
-		await fs.cp(from, to, {
-			recursive: true,
-			force: true
+/**
+* Turn selected routes and their renders into results and manifest entries.
+*
+* A route arrives in one of three states: unchanged and therefore skipped,
+* rendered successfully, or rendered with an error. Each produces a different
+* result shape and a different manifest entry, and a successful render is only
+* written when its HTML actually differs from what the previous build left.
+*/
+function assembleRouteResults({ selected, renderedByRouteId, routeResultsById, dataMap, effectiveMode, outputDir }) {
+	let cacheHits = 0;
+	const nextManifestRoutes = [];
+	for (const entry of selected) {
+		const { descriptor, previous, reason } = entry;
+		const resolvedData = resolveSsgRouteData(dataMap, descriptor.route.path, descriptor.path);
+		const baseData = resolvedData.hasData ? resolvedData.data : void 0;
+		const resourceCount = resolvedData.hasData && baseData ? Object.keys(baseData).length : 0;
+		if (reason === "unchanged") {
+			routeResultsById.set(descriptor.routeId, {
+				path: descriptor.path,
+				filePath: descriptor.filePath,
+				html: "",
+				fileSize: previous?.htmlHash !== null && previous !== null ? getExistingOutputFileSize(outputDir, descriptor.filePath) : 0,
+				renderDuration: 0,
+				resourceCount,
+				status: "skipped",
+				reason: "unchanged",
+				written: false
+			});
+			if (previous) nextManifestRoutes.push({
+				...previous,
+				path: descriptor.path,
+				filePath: descriptor.filePath,
+				invalidationKeys: descriptor.invalidationKeys.slice()
+			});
+			continue;
+		}
+		const rendered = renderedByRouteId.get(descriptor.routeId);
+		if (!rendered) throw new Error(`Missing rendered result for route "${descriptor.path}"`);
+		const nextResult = {
+			...rendered,
+			path: descriptor.path,
+			filePath: descriptor.filePath,
+			resourceCount,
+			reason,
+			written: false
+		};
+		if (nextResult.status === "success") {
+			const htmlDigest = hashHtml(nextResult.html);
+			const shouldWrite = effectiveMode === "full" || !previous || previous.htmlHash !== htmlDigest || !outputFileExists(outputDir, descriptor.filePath);
+			nextResult.written = shouldWrite;
+			if (!shouldWrite) cacheHits += 1;
+			nextManifestRoutes.push({
+				routeId: descriptor.routeId,
+				path: descriptor.path,
+				filePath: descriptor.filePath,
+				invalidationKeys: descriptor.invalidationKeys.slice(),
+				htmlHash: htmlDigest,
+				lastStatus: "success"
+			});
+		} else nextManifestRoutes.push({
+			routeId: descriptor.routeId,
+			path: descriptor.path,
+			filePath: descriptor.filePath,
+			invalidationKeys: descriptor.invalidationKeys.slice(),
+			htmlHash: previous?.htmlHash ?? null,
+			lastStatus: "error"
 		});
+		routeResultsById.set(descriptor.routeId, nextResult);
 	}
+	return {
+		cacheHits,
+		nextManifestRoutes
+	};
 }
-async function replaceOutputDirectory(stagingDir, outputDir, fileOperations = fs) {
-	const parent = pathModule.dirname(outputDir);
-	const backupDir = pathModule.join(parent, `.${pathModule.basename(outputDir)}.askr-backup-${Date.now()}`);
-	let backedUp = false;
+/**
+* Write a completed generation to disk.
+*
+* A full build is all-or-nothing, so it writes into a sibling staging directory
+* and swaps it into place only once every file, the metadata and the manifest
+* have landed; a failure removes the staging directory and rethrows. Incremental
+* builds write in place, because they are already only touching routes that
+* changed.
+*/
+async function publishGeneration({ routeResults, nextManifestRoutes, effectiveMode, seed, concurrency, outputDir, assets, metadata }) {
+	const targetOutputDir = effectiveMode === "full" ? await createStagingDirectory(outputDir) : outputDir;
 	try {
-		try {
-			await fileOperations.rename(outputDir, backupDir);
-			backedUp = true;
-		} catch (error) {
-			if (error.code !== "ENOENT") throw error;
-		}
-		await fileOperations.rename(stagingDir, outputDir);
-		await fileOperations.rm(backupDir, {
-			recursive: true,
-			force: true
-		});
+		const writeStartTime = performance.now();
+		await writeStaticFiles(routeResults, targetOutputDir, { concurrency });
+		performance.now() - writeStartTime;
+		await writeMetadata(metadata, targetOutputDir);
+		await writeIncrementalManifest({
+			schemaVersion: 1,
+			seed,
+			mode: effectiveMode,
+			routes: nextManifestRoutes
+		}, targetOutputDir);
+		await copyStaticAssets(assets, targetOutputDir);
+		if (effectiveMode === "full") await replaceOutputDirectory(targetOutputDir, outputDir);
 	} catch (error) {
-		if (backedUp) {
-			await fileOperations.rm(outputDir, {
+		if (effectiveMode === "full") try {
+			await fs$1.rm(targetOutputDir, {
 				recursive: true,
 				force: true
 			});
-			await fileOperations.rename(backupDir, outputDir);
-		}
+		} catch {}
 		throw error;
-	} finally {
-		await fileOperations.rm(stagingDir, {
-			recursive: true,
-			force: true
-		});
 	}
 }
-/**
-* Create a Static Site Generator
-*
-* Usage:
-* ```ts
-* const ssg = createStaticGen({
-*   registry,
-*   outputDir: './dist',
-*   dataOverrides: {
-*     '/api/posts': { posts: [...] }
-*   }
-* });
-*
-* const result = await ssg.generate();
-* console.log(`Generated ${result.successful}/${result.totalRoutes} routes`);
-* ```
-*/
 function createStaticGen(options) {
 	let result = null;
 	if (!options || !("registry" in options) || !options.registry) throw new Error("route registry is required");
@@ -824,66 +947,14 @@ function createStaticGen(options) {
 				performance.now() - renderStartTime;
 				const renderedByRouteId = /* @__PURE__ */ new Map();
 				for (let index = 0; index < renderedResults.length; index += 1) renderedByRouteId.set(routesToRender[index].descriptor.routeId, renderedResults[index]);
-				let cacheHits = 0;
-				const nextManifestRoutes = [];
-				for (const entry of selected) {
-					const { descriptor, previous, reason } = entry;
-					const resolvedData = resolveSsgRouteData(dataMap, descriptor.route.path, descriptor.path);
-					const baseData = resolvedData.hasData ? resolvedData.data : void 0;
-					const resourceCount = resolvedData.hasData && baseData ? Object.keys(baseData).length : 0;
-					if (reason === "unchanged") {
-						routeResultsById.set(descriptor.routeId, {
-							path: descriptor.path,
-							filePath: descriptor.filePath,
-							html: "",
-							fileSize: previous?.htmlHash !== null && previous !== null ? getExistingOutputFileSize(options.outputDir, descriptor.filePath) : 0,
-							renderDuration: 0,
-							resourceCount,
-							status: "skipped",
-							reason: "unchanged",
-							written: false
-						});
-						if (previous) nextManifestRoutes.push({
-							...previous,
-							path: descriptor.path,
-							filePath: descriptor.filePath,
-							invalidationKeys: descriptor.invalidationKeys.slice()
-						});
-						continue;
-					}
-					const rendered = renderedByRouteId.get(descriptor.routeId);
-					if (!rendered) throw new Error(`Missing rendered result for route "${descriptor.path}"`);
-					const nextResult = {
-						...rendered,
-						path: descriptor.path,
-						filePath: descriptor.filePath,
-						resourceCount,
-						reason,
-						written: false
-					};
-					if (nextResult.status === "success") {
-						const htmlDigest = hashHtml(nextResult.html);
-						const shouldWrite = effectiveMode === "full" || !previous || previous.htmlHash !== htmlDigest || !outputFileExists(options.outputDir, descriptor.filePath);
-						nextResult.written = shouldWrite;
-						if (!shouldWrite) cacheHits += 1;
-						nextManifestRoutes.push({
-							routeId: descriptor.routeId,
-							path: descriptor.path,
-							filePath: descriptor.filePath,
-							invalidationKeys: descriptor.invalidationKeys.slice(),
-							htmlHash: htmlDigest,
-							lastStatus: "success"
-						});
-					} else nextManifestRoutes.push({
-						routeId: descriptor.routeId,
-						path: descriptor.path,
-						filePath: descriptor.filePath,
-						invalidationKeys: descriptor.invalidationKeys.slice(),
-						htmlHash: previous?.htmlHash ?? null,
-						lastStatus: "error"
-					});
-					routeResultsById.set(descriptor.routeId, nextResult);
-				}
+				const { cacheHits, nextManifestRoutes } = assembleRouteResults({
+					selected,
+					renderedByRouteId,
+					routeResultsById,
+					dataMap,
+					effectiveMode,
+					outputDir: options.outputDir
+				});
 				const removedResults = collectRemovedRouteResults(previousManifest, currentRouteIds);
 				const routeResults = [];
 				for (const routeId of splitRoutes.outputRouteIds) {
@@ -901,27 +972,16 @@ function createStaticGen(options) {
 					for (const routeResult of result.routes) if (routeResult.status === "success") routeResult.written = false;
 					return result;
 				}
-				const targetOutputDir = effectiveMode === "full" ? await createStagingDirectory(options.outputDir) : options.outputDir;
-				try {
-					const writeStartTime = performance.now();
-					await writeStaticFiles(routeResults, targetOutputDir, { concurrency: resolvedConcurrency });
-					performance.now() - writeStartTime;
-					await writeMetadata(resultToMetadata(result), targetOutputDir);
-					await writeIncrementalManifest({
-						schemaVersion: 1,
-						seed,
-						mode: effectiveMode,
-						routes: nextManifestRoutes
-					}, targetOutputDir);
-					await copyStaticAssets(options.assets, targetOutputDir);
-					if (effectiveMode === "full") await replaceOutputDirectory(targetOutputDir, options.outputDir);
-				} catch (error) {
-					if (effectiveMode === "full") await fs.rm(targetOutputDir, {
-						recursive: true,
-						force: true
-					});
-					throw error;
-				}
+				await publishGeneration({
+					routeResults,
+					nextManifestRoutes,
+					effectiveMode,
+					seed,
+					concurrency: resolvedConcurrency,
+					outputDir: options.outputDir,
+					assets: options.assets,
+					metadata: resultToMetadata(result)
+				});
 				return result;
 			});
 		},