@t09tanaka/stoneage 0.1.0

package/dist/core.js

@@ -0,0 +1,2897 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join, posix } from "node:path";
+import { copyPublicAssets, expandPublicDir, resolveClientAssets, } from "./assets.js";
+import { withDeferredFragmentDefaults, } from "./fragment.js";
+import { renderNetlifyHeaders, renderNetlifyRedirects } from "./deploy.js";
+import { publicAssetOutputPath as publicOutputPathForAsset } from "./paths.js";
+export * from "./data.js";
+const validationConfigKeys = ["budgets", "requiredMetadata", "requirePrecompressed"];
+const requiredMetadataKeys = [
+    "title",
+    "description",
+    "canonical",
+    "favicon",
+    "ogImage",
+    "twitterImage",
+];
+const requiredMetadataKeyList = requiredMetadataKeys.join(", ");
+const numericBudgetConfigKeys = [
+    "maxPages",
+    "maxArtifacts",
+    "maxHtmlBytes",
+    "maxCssBytes",
+    "maxJsBytes",
+    "maxPublicFileBytes",
+    "maxTotalPublicBytes",
+    "maxImageBytes",
+    "maxBrotliBytes",
+    "maxGzipBytes",
+    "maxDependencyFanout",
+];
+const budgetConfigKeys = [
+    ...numericBudgetConfigKeys,
+    "maxRouteFamilyPages",
+    "maxArtifactFamilyOutputs",
+];
+const manifestReadCache = new Map();
+const buildReportReadCache = new Map();
+export async function loadValidationConfig(path) {
+    const raw = await readFile(path, "utf8");
+    return {
+        configPath: path,
+        configHash: createHash("sha256").update(raw).digest("hex"),
+        ...parseValidationConfig(JSON.parse(raw), path),
+    };
+}
+function parseValidationConfig(value, path) {
+    if (!isJsonRecord(value)) {
+        throw new Error(`Validation config must be a JSON object: ${path}`);
+    }
+    rejectUnknownJsonKeys(value, validationConfigKeys, "Validation config", path);
+    const requirePrecompressed = value.requirePrecompressed;
+    if (requirePrecompressed !== undefined && typeof requirePrecompressed !== "boolean") {
+        throw new Error(`Validation config requirePrecompressed must be a boolean: ${path}`);
+    }
+    const requiredMetadata = readRequiredMetadata(value.requiredMetadata, path);
+    const budgets = readValidationBudgetConfig(value.budgets, path);
+    return {
+        ...(requiredMetadata === undefined ? {} : { requiredMetadata }),
+        ...(budgets ? { budgets } : {}),
+    };
+}
+function readRequiredMetadata(value, path) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(value)) {
+        throw new Error(`Validation config requiredMetadata must be an array: ${path}`);
+    }
+    return value.map((item, index) => {
+        if (!isRequiredMetadataKey(item)) {
+            throw new Error(`Validation config requiredMetadata[${index}] must be one of ${requiredMetadataKeyList}: ${path}`);
+        }
+        return item;
+    });
+}
+function isRequiredMetadataKey(value) {
+    return typeof value === "string" && requiredMetadataKeys.includes(value);
+}
+function readValidationBudgetConfig(value, path) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!isJsonRecord(value)) {
+        throw new Error(`Validation config budgets must be a JSON object: ${path}`);
+    }
+    rejectUnknownBudgetKeys(value, path);
+    const budgets = {};
+    for (const key of numericBudgetConfigKeys) {
+        const raw = value[key];
+        if (raw === undefined) {
+            continue;
+        }
+        if (typeof raw !== "number" || !Number.isInteger(raw) || raw <= 0) {
+            throw new Error(`Validation config budgets.${key} must be a positive integer: ${path}`);
+        }
+        budgets[key] = raw;
+    }
+    if (value.maxRouteFamilyPages !== undefined) {
+        budgets.maxRouteFamilyPages = readPositiveIntegerRecord(value.maxRouteFamilyPages, "Validation config budgets.maxRouteFamilyPages", path);
+    }
+    if (value.maxArtifactFamilyOutputs !== undefined) {
+        budgets.maxArtifactFamilyOutputs = readPositiveIntegerRecord(value.maxArtifactFamilyOutputs, "Validation config budgets.maxArtifactFamilyOutputs", path);
+    }
+    return Object.keys(budgets).length > 0 ? budgets : undefined;
+}
+function readPositiveIntegerRecord(value, label, path) {
+    if (!isJsonRecord(value)) {
+        throw new Error(`${label} must be a JSON object: ${path}`);
+    }
+    const result = {};
+    for (const [key, raw] of Object.entries(value)) {
+        if (typeof raw !== "number" || !Number.isInteger(raw) || raw <= 0) {
+            throw new Error(`${label}.${key} must be a positive integer: ${path}`);
+        }
+        result[key] = raw;
+    }
+    return result;
+}
+function isJsonRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function rejectUnknownJsonKeys(value, allowedKeys, label, path) {
+    const allowed = new Set(allowedKeys);
+    for (const key of Object.keys(value)) {
+        if (!allowed.has(key)) {
+            throw new Error(`Unknown ${label.toLowerCase()} key ${key}: ${path}`);
+        }
+    }
+}
+function rejectUnknownBudgetKeys(value, path) {
+    const allowed = new Set(budgetConfigKeys);
+    for (const key of Object.keys(value)) {
+        if (!allowed.has(key)) {
+            throw new Error(`Unknown validation config budgets.${key}: ${path}`);
+        }
+    }
+}
+const internalPageFingerprintKey = "\0stoneage:page";
+const internalArtifactFingerprintKey = "\0stoneage:artifact";
+export const notFoundRouteName = "\0stoneage:not-found";
+const notFoundPath = "/404.html";
+export const notFoundOutputPath = "404.html";
+export function component(render) {
+    return render;
+}
+export function routePath(pattern, params) {
+    return pattern.replaceAll(/:([A-Za-z0-9_]+)/g, (_, key) => {
+        const value = params[key];
+        if (value === undefined || value === null) {
+            throw new Error(`Missing route parameter: ${key}`);
+        }
+        return encodeURIComponent(String(value));
+    });
+}
+export function artifactPath(pattern, params) {
+    return normalizeArtifactPath(routePath(pattern, params));
+}
+export function fragmentPath(pattern, params) {
+    const filled = routePath(pattern, params);
+    const normalized = normalizeFragmentCandidatePath(filled);
+    return normalizeArtifactPath(normalized.endsWith(".html") ? normalized : `${normalized}.html`);
+}
+export function patternParamMatcher(pattern) {
+    return (value) => {
+        pattern.lastIndex = 0;
+        return pattern.test(value);
+    };
+}
+export function pathForRoute(pattern, params) {
+    return routePath(pattern, params);
+}
+export function pathForArtifact(pattern, params) {
+    return artifactPath(pattern, params);
+}
+export function pathForRedirect(pattern, params) {
+    return routePath(pattern, params);
+}
+export function redirectToRoute(redirect) {
+    return {
+        from: routePath(redirect.from, redirect.fromParams),
+        to: routePath(redirect.to, redirect.toParams),
+        ...(redirect.status === undefined ? {} : { status: redirect.status }),
+    };
+}
+export function redirectsFromRecords(records, options) {
+    return records.map((record, index) => redirectToRoute({
+        from: options.from,
+        fromParams: options.fromParams(record, index),
+        to: options.to,
+        toParams: options.toParams(record, index),
+        status: typeof options.status === "function"
+            ? options.status(record, index)
+            : options.status,
+    }));
+}
+export function defineRouteFamily(config) {
+    return {
+        name: config.name,
+        pattern: config.pattern,
+        ...(config.metadata ? { metadata: config.metadata } : {}),
+        ...(config.paramMatchers ? { paramMatchers: config.paramMatchers } : {}),
+        path: (params) => routePath(config.pattern, params),
+        entries: async () => config.entries(),
+    };
+}
+export function defineArtifactFamily(config) {
+    return {
+        name: config.name,
+        pattern: config.pattern,
+        ...(config.paramMatchers ? { paramMatchers: config.paramMatchers } : {}),
+        entries: async () => config.entries(),
+    };
+}
+export function defineFragmentFamily(config) {
+    return {
+        name: config.name,
+        pattern: config.pattern,
+        ...(config.paramMatchers ? { paramMatchers: config.paramMatchers } : {}),
+        path: (params) => fragmentPath(config.pattern, params),
+        entries: async () => config.entries(),
+    };
+}
+export function defineSvgAssetFamily(config) {
+    const dir = normalizeSvgAssetDir(config.dir ?? "/_assets/svg");
+    const resolvedPaths = new Map();
+    const family = {
+        name: config.name,
+        dir,
+        ...(config.paramMatchers ? { paramMatchers: config.paramMatchers } : {}),
+        path: (params) => {
+            const key = stableJson(params);
+            const path = resolvedPaths.get(key);
+            if (!path) {
+                throw new Error(`SVG asset ${config.name} has no resolved entry for params ${key}. Include the family in buildSite({ svgAssets }).`);
+            }
+            return path;
+        },
+        entries: async () => config.entries(),
+        resolvePath: (params, path) => resolvedPaths.set(stableJson(params), path),
+        clearResolvedPaths: () => resolvedPaths.clear(),
+    };
+    return family;
+}
+async function resolveSvgAssetFamilies(families) {
+    const tasks = [];
+    const pathsByContentHash = new Map();
+    for (const family of families) {
+        assertReservedRouteUnused("artifact", family.name);
+        const resolvedFamily = family;
+        if (typeof resolvedFamily.resolvePath !== "function" ||
+            typeof resolvedFamily.clearResolvedPaths !== "function") {
+            throw new Error(`SVG asset family ${family.name} must be created with defineSvgAssetFamily().`);
+        }
+        resolvedFamily.clearResolvedPaths();
+        const entries = await family.entries();
+        for (const entry of entries) {
+            validateParamMatchers("SVG asset", family.name, entry.params, family.paramMatchers);
+            const svg = normalizeSvgAssetContent(await entry.render(), family.name);
+            const contentHash = svgAssetContentHash(svg);
+            const contentKey = `${family.dir}\0${contentHash}`;
+            const path = pathsByContentHash.get(contentKey) ?? `${family.dir}/${contentHash}.svg`;
+            pathsByContentHash.set(contentKey, path);
+            resolvedFamily.resolvePath(entry.params, path);
+            if (tasks.some((task) => task.entry.path === path)) {
+                continue;
+            }
+            tasks.push({
+                routeName: family.name,
+                pattern: path,
+                entry: {
+                    params: {},
+                    path,
+                    dependencies: [
+                        ...(entry.dependencies ?? []),
+                        { key: "\0stoneage:svg-asset", hash: contentHash },
+                    ],
+                    render: () => artifactResponse(svg, {
+                        contentType: "image/svg+xml; charset=utf-8",
+                        headers: {
+                            "cache-control": "public, max-age=31536000, immutable",
+                            "x-robots-tag": "noindex",
+                        },
+                    }),
+                },
+            });
+        }
+    }
+    return tasks;
+}
+export function artifactResponse(body, init = {}) {
+    return {
+        body,
+        ...(init.contentType ? { contentType: init.contentType } : {}),
+        status: normalizeArtifactStatus(init.status),
+        headers: normalizeArtifactHeaders(init.headers),
+    };
+}
+export function jsonArtifact(value, options = {}) {
+    return artifactResponse(`${JSON.stringify(value, null, options.pretty ? 2 : undefined)}\n`, {
+        ...options,
+        contentType: options.contentType ?? "application/json; charset=utf-8",
+    });
+}
+export function textArtifact(body, init = {}) {
+    return artifactResponse(body, {
+        ...init,
+        contentType: init.contentType ?? "text/plain; charset=utf-8",
+    });
+}
+export function csvArtifact(body, init = {}) {
+    return artifactResponse(body, {
+        ...init,
+        contentType: init.contentType ?? "text/csv; charset=utf-8",
+    });
+}
+export function xmlArtifact(body, init = {}) {
+    return artifactResponse(body, {
+        ...init,
+        contentType: init.contentType ?? "application/xml; charset=utf-8",
+    });
+}
+function htmlFragmentArtifact(body) {
+    return artifactResponse(body, {
+        contentType: "text/html; charset=utf-8",
+        headers: {
+            "x-robots-tag": "noindex",
+        },
+    });
+}
+const fragmentClientRouteName = "stoneage:fragment-client";
+const defaultFragmentClientPublicPath = "/_stoneage/fragment-client.js";
+const fragmentClientSource = `const selector="[data-stoneage-fragment]";
+
+function fragmentController(){
+  const elements=Array.from(document.querySelectorAll(selector));
+  const armedElements=new WeakSet();
+  const load=async(element)=>{
+    await loadFragmentElement(element);
+    for(const nested of Array.from(element.querySelectorAll(selector))){
+      armElement(nested);
+    }
+  };
+  const armElement=(element)=>{
+    if(armedElements.has(element)){
+      return;
+    }
+    armedElements.add(element);
+    const trigger=readFragmentTrigger(element);
+    if(trigger==="manual"){
+      return;
+    }
+    if(trigger==="details-open"){
+      loadWhenDetailsOpen(element,load);
+      return;
+    }
+    if(trigger==="idle"){
+      loadWhenIdle(element,load);
+      return;
+    }
+    loadWhenVisible(element,load);
+  };
+  for(const element of elements){
+    armElement(element);
+  }
+}
+
+async function loadFragmentElement(element){
+  if(element.hasAttribute("data-fragment-loaded")||element.hasAttribute("data-fragment-loading")){
+    return;
+  }
+  const src=element.getAttribute("data-fragment-src");
+  if(!src){
+    throw new Error("Deferred fragment placeholder is missing data-fragment-src.");
+  }
+  element.setAttribute("data-fragment-loading","true");
+  element.removeAttribute("data-fragment-error");
+  dispatchFragmentEvent(element,"stoneage:fragmentbeforeload",{src});
+  try{
+    const response=await fetch(src,{headers:{accept:"text/html"}});
+    if(!response.ok){
+      throw new Error(\`Failed to load deferred fragment \${src}: \${response.status}\`);
+    }
+    element.innerHTML=await response.text();
+    element.setAttribute("data-fragment-loaded","true");
+    element.removeAttribute("data-fragment-error");
+    dispatchFragmentEvent(element,"stoneage:fragmentload",{src});
+  }catch(error){
+    element.setAttribute("data-fragment-error","true");
+    dispatchFragmentEvent(element,"stoneage:fragmenterror",{src,error});
+    throw error;
+  }finally{
+    element.removeAttribute("data-fragment-loading");
+  }
+}
+
+function dispatchFragmentEvent(element,type,detail){
+  element.dispatchEvent(new CustomEvent(type,{bubbles:true,detail}));
+}
+
+function readFragmentTrigger(element){
+  const trigger=element.getAttribute("data-fragment-trigger");
+  return trigger==="manual"||trigger==="details-open"||trigger==="idle"||trigger==="visible"
+    ? trigger
+    : "visible";
+}
+
+function loadWhenDetailsOpen(element,load){
+  const details=element.closest("details");
+  if(!details){
+    loadWhenVisible(element,load);
+    return;
+  }
+  if(details.open){
+    loadAutomatically(element,load);
+    return;
+  }
+  const onToggle=()=>{
+    if(details.open){
+      loadAutomatically(element,load);
+      details.removeEventListener("toggle",onToggle);
+    }
+  };
+  details.addEventListener("toggle",onToggle);
+}
+
+function loadWhenVisible(element,load){
+  if(typeof IntersectionObserver==="undefined"){
+    loadAutomatically(element,load);
+    return;
+  }
+  const observer=new IntersectionObserver((entries)=>{
+    if(entries.some((entry)=>entry.isIntersecting)){
+      loadAutomatically(element,load);
+      observer.disconnect();
+    }
+  });
+  observer.observe(element);
+}
+
+function loadWhenIdle(element,load){
+  const handle=globalThis.requestIdleCallback
+    ? globalThis.requestIdleCallback(()=>loadAutomatically(element,load))
+    : setTimeout(()=>loadAutomatically(element,load),0);
+  void handle;
+}
+
+function loadAutomatically(element,load){
+  void load(element).catch(()=>{});
+}
+
+fragmentController();
+`;
+function fragmentFamiliesFromConfig(config) {
+    if (config === undefined) {
+        return [];
+    }
+    return Array.isArray(config) ? config : (config.families ?? []);
+}
+function fragmentDefaultFallbackTextFromConfig(config) {
+    return Array.isArray(config) ? undefined : config?.defaultFallbackText;
+}
+function fragmentClientPublicPathFromConfig(config, families) {
+    if (families.length === 0) {
+        return undefined;
+    }
+    if (Array.isArray(config)) {
+        return defaultFragmentClientPublicPath;
+    }
+    if (config?.client === false) {
+        return undefined;
+    }
+    return typeof config?.client === "object"
+        ? (config.client.publicPath ?? defaultFragmentClientPublicPath)
+        : defaultFragmentClientPublicPath;
+}
+function fragmentClientArtifact(publicPath) {
+    return {
+        routeName: fragmentClientRouteName,
+        pattern: publicPath,
+        entry: {
+            params: {},
+            path: publicPath,
+            dependencies: [
+                {
+                    key: "\0stoneage:fragment-client",
+                    hash: hashText(fragmentClientSource),
+                },
+            ],
+            render: () => artifactResponse(fragmentClientSource, {
+                contentType: "application/javascript; charset=utf-8",
+                headers: {
+                    "x-robots-tag": "noindex",
+                },
+            }),
+        },
+    };
+}
+const immutableStaticAssetCacheControl = "public, max-age=31536000, immutable";
+async function resolveStaticAssetReferences(assets) {
+    if (!assets) {
+        return {
+            assets,
+            publicAssets: [],
+            headers: [],
+        };
+    }
+    const publicAssetsByPath = new Map();
+    const headersByPath = new Map();
+    const resolveImmutablePublicAsset = async (asset, publicPath) => {
+        const bytes = await immutableAssetBytes(asset);
+        const hashedPath = contentHashedPublicPath(publicPath, contentHash(bytes));
+        if (!publicAssetsByPath.has(hashedPath)) {
+            publicAssetsByPath.set(hashedPath, "source" in asset
+                ? { source: asset.source, publicPath: hashedPath }
+                : { content: bytes, publicPath: hashedPath });
+        }
+        if (!headersByPath.has(hashedPath)) {
+            headersByPath.set(hashedPath, {
+                path: hashedPath,
+                headers: {
+                    "cache-control": immutableStaticAssetCacheControl,
+                },
+            });
+        }
+        return hashedPath;
+    };
+    const stylesheets = await Promise.all((assets.stylesheets ?? []).map(async (stylesheet) => resolveStylesheetAsset(stylesheet, resolveImmutablePublicAsset)));
+    const client = assets.client
+        ? await resolveClientAssetRegistry(assets.client, resolveImmutablePublicAsset)
+        : undefined;
+    return {
+        assets: {
+            ...assets,
+            ...(assets.stylesheets ? { stylesheets } : {}),
+            ...(client ? { client } : {}),
+        },
+        publicAssets: [...publicAssetsByPath.values()],
+        headers: [...headersByPath.values()],
+    };
+}
+async function resolveStylesheetAsset(stylesheet, resolveImmutablePublicAsset) {
+    if (typeof stylesheet === "string" || stylesheet.immutable === false) {
+        return stylesheet;
+    }
+    if ("source" in stylesheet) {
+        return resolveImmutablePublicAsset({ source: stylesheet.source }, stylesheet.href);
+    }
+    return resolveGoogleFontsStylesheet(stylesheet.href, stylesheet.googleFonts, resolveImmutablePublicAsset);
+}
+async function resolveClientAssetRegistry(registry, resolveImmutablePublicAsset) {
+    const entries = await Promise.all(Object.entries(registry).map(async ([id, declarations]) => [
+        id,
+        await Promise.all((Array.isArray(declarations) ? declarations : [declarations]).map(async (declaration) => ({
+            ...(declaration.stylesheets
+                ? {
+                    stylesheets: await Promise.all(declaration.stylesheets.map((stylesheet) => resolveStylesheetAsset(stylesheet, resolveImmutablePublicAsset))),
+                }
+                : {}),
+            ...(declaration.scripts
+                ? {
+                    scripts: await Promise.all(declaration.scripts.map((script) => resolveClientScriptAsset(script, resolveImmutablePublicAsset))),
+                }
+                : {}),
+        }))),
+    ]));
+    return Object.fromEntries(entries);
+}
+async function resolveClientScriptAsset(script, resolveImmutablePublicAsset) {
+    if (!script.source || script.immutable === false) {
+        const { source: _source, immutable: _immutable, ...runtimeScript } = script;
+        return runtimeScript;
+    }
+    const src = await resolveImmutablePublicAsset({ source: script.source }, script.src);
+    const { source: _source, immutable: _immutable, ...runtimeScript } = script;
+    return {
+        ...runtimeScript,
+        src,
+    };
+}
+async function immutableAssetBytes(asset) {
+    return "source" in asset ? readFile(asset.source) : Buffer.from(asset.content);
+}
+const defaultGoogleFontsCssEndpoint = "https://fonts.googleapis.com/css2";
+const defaultGoogleFontsUserAgent = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 " +
+    "(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+async function resolveGoogleFontsStylesheet(href, options, resolveImmutablePublicAsset) {
+    const fetchAsset = options.fetch ?? defaultAssetFetch;
+    const requestHeaders = {
+        "user-agent": options.userAgent ?? defaultGoogleFontsUserAgent,
+        accept: "text/css,*/*;q=0.1",
+    };
+    const cssUrl = googleFontsCssUrl(options);
+    const cssResponse = await fetchAsset(cssUrl, { headers: requestHeaders });
+    if (!cssResponse.ok) {
+        throw new Error(`Google Fonts CSS request failed with status ${cssResponse.status}: ${cssUrl}`);
+    }
+    const css = await cssResponse.text();
+    const fontPathsByUrl = new Map();
+    for (const font of googleFontsCssFonts(css)) {
+        if (fontPathsByUrl.has(font.url)) {
+            continue;
+        }
+        const fontPublicPath = googleFontPublicPath(font.url, font.format, options.fontBasePath ?? defaultGoogleFontBasePath(href));
+        const fontResponse = await fetchAsset(font.url, { headers: requestHeaders });
+        if (!fontResponse.ok) {
+            throw new Error(`Google Fonts file request failed with status ${fontResponse.status}: ${font.url}`);
+        }
+        const bytes = Buffer.from(await fontResponse.arrayBuffer());
+        fontPathsByUrl.set(font.url, await resolveImmutablePublicAsset({ content: bytes }, fontPublicPath));
+    }
+    const rewrittenCss = rewriteCssUrls(css, fontPathsByUrl);
+    return resolveImmutablePublicAsset({ content: rewrittenCss }, href);
+}
+const defaultAssetFetch = async (url, init) => {
+    return fetch(url, init);
+};
+function googleFontsCssUrl(options) {
+    if (options.families.length === 0) {
+        throw new Error("Google Fonts stylesheet requires at least one family.");
+    }
+    const url = new URL(options.endpoint ?? defaultGoogleFontsCssEndpoint);
+    for (const family of options.families) {
+        url.searchParams.append("family", family);
+    }
+    url.searchParams.set("display", options.display ?? "swap");
+    if (options.text !== undefined) {
+        url.searchParams.set("text", options.text);
+    }
+    return url.toString();
+}
+function googleFontsCssFonts(css) {
+    const fonts = [];
+    const seen = new Set();
+    const pattern = /url\(\s*(?:"([^"]+)"|'([^']+)'|([^'")\s]+))\s*\)\s*(?:format\(\s*(?:"([^"]+)"|'([^']+)'|([^'")\s]+))\s*\))?/g;
+    let match;
+    while ((match = pattern.exec(css)) !== null) {
+        const url = match[1] ?? match[2] ?? match[3];
+        if (!url || seen.has(url)) {
+            continue;
+        }
+        seen.add(url);
+        fonts.push({
+            url,
+            format: match[4] ?? match[5] ?? match[6],
+        });
+    }
+    return fonts;
+}
+function googleFontPublicPath(fontUrl, format, fontBasePath) {
+    const url = new URL(fontUrl);
+    const normalizedFormat = format?.replace(/^['"]|['"]$/g, "").toLowerCase();
+    if (normalizedFormat !== "woff2") {
+        throw new Error(`Google Fonts stylesheet contains a font URL without format(woff2): ${fontUrl}`);
+    }
+    const basename = posix.basename(url.pathname);
+    const filename = basename.endsWith(".woff2") ? basename : "font.woff2";
+    const base = fontBasePath.endsWith("/") ? fontBasePath : `${fontBasePath}/`;
+    return `${base}${filename}`;
+}
+function defaultGoogleFontBasePath(stylesheetHref) {
+    const outputPath = publicOutputPathForAsset(stylesheetHref);
+    const directory = posix.dirname(outputPath);
+    const extension = posix.extname(outputPath);
+    const basename = extension
+        ? posix.basename(outputPath, extension)
+        : posix.basename(outputPath);
+    return `/${directory === "." ? basename : posix.join(directory, basename)}/`;
+}
+function rewriteCssUrls(css, replacements) {
+    let output = css;
+    for (const [from, to] of replacements) {
+        output = output.split(from).join(to);
+    }
+    return output;
+}
+function contentHash(bytes) {
+    return createHash("sha256").update(bytes).digest("hex").slice(0, 16);
+}
+function contentHashedPublicPath(publicPath, hash) {
+    if (/[?#]/.test(publicPath)) {
+        throw new Error(`Immutable public asset path must not include a query or fragment: ${publicPath}`);
+    }
+    const outputPath = publicOutputPathForAsset(publicPath);
+    const lastSlash = outputPath.lastIndexOf("/");
+    const directory = lastSlash === -1 ? "" : outputPath.slice(0, lastSlash + 1);
+    const filename = lastSlash === -1 ? outputPath : outputPath.slice(lastSlash + 1);
+    const extensionIndex = filename.lastIndexOf(".");
+    const hashedFilename = extensionIndex <= 0
+        ? `${filename}.${hash}`
+        : `${filename.slice(0, extensionIndex)}.${hash}${filename.slice(extensionIndex)}`;
+    return `/${directory}${hashedFilename}`;
+}
+function canSkipUnchangedFingerprintBuild(config, previousManifest, previousReport, currentPublicAssets, sitemapFiles, publicAssetsCopied, fragmentDefaultFallbackText, fragmentClientPublicPath) {
+    if (config.buildFingerprint === undefined ||
+        config.partial ||
+        config.validation !== undefined ||
+        previousReport.buildFingerprint !== config.buildFingerprint ||
+        previousReport.renderFingerprint !== config.renderFingerprint ||
+        previousReport.fragmentDefaultFallbackText !== fragmentDefaultFallbackText ||
+        previousReport.fragmentClientPublicPath !== fragmentClientPublicPath ||
+        publicAssetsCopied > 0) {
+        return false;
+    }
+    const hasPreviousOutputs = previousManifest.pages.length > 0 || previousManifest.artifacts.length > 0;
+    return (hasPreviousOutputs &&
+        sameStringList(previousReport.publicAssets, currentPublicAssets) &&
+        sameStringList(previousReport.sitemapFiles, sitemapFiles));
+}
+export async function buildSite(config) {
+    const trailingSlash = config.trailingSlash ?? "always";
+    const fragmentFamilies = fragmentFamiliesFromConfig(config.fragments);
+    const fragmentDefaultFallbackText = fragmentDefaultFallbackTextFromConfig(config.fragments);
+    const fragmentClientPublicPath = fragmentClientPublicPathFromConfig(config.fragments, fragmentFamilies);
+    const fragmentClientScripts = fragmentClientPublicPath
+        ? [{ src: fragmentClientPublicPath, module: true }]
+        : [];
+    const staticAssets = await resolveStaticAssetReferences(config.assets);
+    const assets = staticAssets.assets;
+    const resolvedPublicAssets = [
+        ...(config.assets?.publicDir ? await expandPublicDir(config.assets.publicDir) : []),
+        ...(config.assets?.public ?? []),
+        ...staticAssets.publicAssets,
+    ];
+    const publicAssetSync = resolvedPublicAssets.length
+        ? await copyPublicAssets({
+            outDir: config.outDir,
+            assets: resolvedPublicAssets,
+        })
+        : { copied: [], skipped: [] };
+    const publicAssetsCopied = publicAssetSync.copied.length;
+    const publicAssetsSkipped = publicAssetSync.skipped.length;
+    const currentPublicAssets = managedPublicAssetPaths(resolvedPublicAssets);
+    const previousManifest = await readManifest(config.outDir);
+    const previousReport = await readBuildReport(config.outDir);
+    const svgAssetTasks = await resolveSvgAssetFamilies(config.svgAssets ?? []);
+    const compareExistingGeneratedOutput = previousManifest.pages.length > 0 ||
+        previousManifest.artifacts.length > 0 ||
+        previousReport !== undefined;
+    const publicAssets = config.partial
+        ? mergePublicAssets(previousReport?.publicAssets ?? [], currentPublicAssets)
+        : currentPublicAssets;
+    const unchangedBuildSitemapFiles = sitemapFilesFor(previousManifest, config.sitemap);
+    if (svgAssetTasks.length === 0 &&
+        previousReport !== undefined &&
+        canSkipUnchangedFingerprintBuild(config, previousManifest, previousReport, currentPublicAssets, unchangedBuildSitemapFiles, publicAssetsCopied, fragmentDefaultFallbackText, fragmentClientPublicPath)) {
+        const report = unchangedBuildReportFromPrevious(previousReport, {
+            pagesWritten: 0,
+            artifactsWritten: 0,
+            publicAssetsCopied,
+            publicAssetsSkipped,
+            publicAssets,
+            staleOutputsRemoved: 0,
+            sitemapRendered: false,
+            sitemapFiles: unchangedBuildSitemapFiles,
+            routeWrites: {},
+            artifactWrites: {},
+        });
+        return {
+            pagesWritten: 0,
+            artifactsWritten: 0,
+            publicAssetsCopied,
+            publicAssetsSkipped,
+            manifest: previousManifest,
+            report,
+        };
+    }
+    const previousPages = new Map(previousManifest.pages.map((page) => [page.path, page]));
+    const previousArtifacts = new Map(previousManifest.artifacts.map((artifact) => [artifact.path, artifact]));
+    const pageTasks = [];
+    const artifactTasks = [
+        ...svgAssetTasks,
+        ...(fragmentClientPublicPath ? [fragmentClientArtifact(fragmentClientPublicPath)] : []),
+    ];
+    for (const route of config.routes) {
+        const entries = await route.entries();
+        for (const entry of entries) {
+            validateParamMatchers("route", route.name, entry.params, route.paramMatchers);
+            pageTasks.push({
+                routeName: route.name,
+                pattern: route.pattern,
+                metadataDefaults: route.metadata,
+                entry,
+            });
+        }
+    }
+    for (const artifact of config.artifacts ?? []) {
+        assertReservedRouteUnused("artifact", artifact.name);
+        const entries = await artifact.entries();
+        for (const entry of entries) {
+            validateParamMatchers("artifact", artifact.name, entry.params, artifact.paramMatchers);
+            artifactTasks.push({
+                routeName: artifact.name,
+                pattern: artifact.pattern,
+                entry,
+            });
+        }
+    }
+    for (const fragment of fragmentFamilies) {
+        assertReservedRouteUnused("fragment", fragment.name);
+        const entries = await fragment.entries();
+        for (const entry of entries) {
+            validateParamMatchers("fragment", fragment.name, entry.params, fragment.paramMatchers);
+            artifactTasks.push({
+                routeName: fragment.name,
+                pattern: fragment.pattern,
+                entry: {
+                    params: entry.params,
+                    path: entry.path ? fragmentPath(entry.path, {}) : fragment.path(entry.params),
+                    ...(entry.dependencies ? { dependencies: entry.dependencies } : {}),
+                    render: async () => htmlFragmentArtifact(await entry.render()),
+                },
+            });
+        }
+    }
+    const plannedPages = pageTasks.map((task) => {
+        const path = normalizePath(task.entry.path ?? routePath(task.pattern, task.entry.params), trailingSlash);
+        const pathDefaults = config.site.metadata?.(path);
+        const metadata = resolvePageMetadata(task.metadataDefaults, pathDefaults, task.entry.metadata);
+        return {
+            ...task,
+            path,
+            metadata,
+            declaredLinks: task.entry.links === undefined
+                ? undefined
+                : normalizeDeclaredInternalLinks(task.entry.links, trailingSlash),
+            outputPath: outputPathFor(path, trailingSlash),
+        };
+    });
+    const plannedArtifacts = artifactTasks.map((task) => {
+        const path = normalizeArtifactPath(task.entry.path ?? artifactPath(task.pattern, task.entry.params));
+        return {
+            ...task,
+            path,
+            outputPath: outputPathForArtifact(path),
+        };
+    });
+    validateOutputPlan(plannedPages, plannedArtifacts, config.notFound !== undefined);
+    const sharedPageFingerprintHash = hashValue({
+        site: config.site,
+        stylesheets: assets?.stylesheets ?? [],
+        prefetch: config.prefetch ?? {},
+        trailingSlash,
+        renderFingerprint: config.renderFingerprint,
+        fragmentDefaultFallbackText,
+        fragmentClientPublicPath,
+    });
+    const pageResults = await mapConcurrent(plannedPages, config.concurrency ?? 64, async (task) => {
+        const path = task.path;
+        const outputPath = task.outputPath;
+        const absoluteOutputPath = join(config.outDir, outputPath);
+        const canonical = task.metadata.canonical ?? absoluteUrl(config.site.baseUrl, path, trailingSlash);
+        const dependencies = await hashDependencies([
+            ...(task.entry.dependencies ?? []),
+            {
+                key: internalPageFingerprintKey,
+                hash: pageFingerprintHash(task.routeName, path, outputPath, canonical, task.metadata, sharedPageFingerprintHash, task.declaredLinks),
+            },
+        ]);
+        const previousPage = previousPages.get(path);
+        if (previousPage && sameDependencies(previousPage.dependencies, dependencies)) {
+            return {
+                page: previousPage,
+                validationPage: validationPageFor(path, canonical, task.metadata, config.site),
+                pagesWritten: 0,
+            };
+        }
+        const body = await withDeferredFragmentDefaults({ defaultFallbackText: fragmentDefaultFallbackText }, () => task.entry.render());
+        const html = renderDocument(config.site, task.metadata, canonical, body, assets, config.prefetch, trailingSlash, fragmentClientScripts);
+        await writeText(absoluteOutputPath, html, {
+            compareExisting: compareExistingGeneratedOutput,
+        });
+        return {
+            page: {
+                route: task.routeName,
+                path,
+                outputPath,
+                dependencies,
+                links: task.declaredLinks ?? extractInternalLinks(html, trailingSlash),
+                htmlBytes: Buffer.byteLength(html),
+                sitemap: task.metadata.sitemap !== false && task.metadata.noindex !== true,
+            },
+            validationPage: validationPageFor(path, canonical, task.metadata, config.site),
+            pagesWritten: 1,
+        };
+    });
+    const publishArtifactHeaders = config.publishing !== undefined && config.publishing.headers !== false;
+    const artifactResults = await mapConcurrent(plannedArtifacts, config.concurrency ?? 64, async (task) => {
+        const path = task.path;
+        const outputPath = task.outputPath;
+        const absoluteOutputPath = join(config.outDir, outputPath);
+        const dependencies = await hashDependencies([
+            ...(task.entry.dependencies ?? []),
+            {
+                key: internalArtifactFingerprintKey,
+                hash: artifactFingerprintHash(task.routeName, path, outputPath, config.renderFingerprint, fragmentDefaultFallbackText),
+            },
+        ]);
+        const previousArtifact = previousArtifacts.get(path);
+        if (previousArtifact && sameDependencies(previousArtifact.dependencies, dependencies)) {
+            if (publishArtifactHeaders) {
+                const content = artifactContent(await withDeferredFragmentDefaults({ defaultFallbackText: fragmentDefaultFallbackText }, () => task.entry.render()));
+                return {
+                    artifact: {
+                        route: task.routeName,
+                        path,
+                        outputPath,
+                        dependencies,
+                        bytes: previousArtifact.bytes,
+                        ...content.metadata,
+                    },
+                    artifactsWritten: 0,
+                };
+            }
+            return {
+                artifact: previousArtifact,
+                artifactsWritten: 0,
+            };
+        }
+        const content = artifactContent(await withDeferredFragmentDefaults({ defaultFallbackText: fragmentDefaultFallbackText }, () => task.entry.render()));
+        const bytes = toBuffer(content.body);
+        await writeBytes(absoluteOutputPath, bytes, {
+            compareExisting: compareExistingGeneratedOutput,
+        });
+        return {
+            artifact: {
+                route: task.routeName,
+                path,
+                outputPath,
+                dependencies,
+                bytes: bytes.byteLength,
+                ...content.metadata,
+            },
+            artifactsWritten: 1,
+        };
+    });
+    const notFoundResults = config.notFound
+        ? [
+            await buildNotFoundPage(config, config.notFound, trailingSlash, previousPages, sharedPageFingerprintHash, compareExistingGeneratedOutput, fragmentDefaultFallbackText, fragmentClientScripts, assets),
+        ]
+        : [];
+    const allPageResults = [...pageResults, ...notFoundResults];
+    const pages = config.partial
+        ? mergePartialPages(previousManifest.pages, allPageResults.map((result) => result.page))
+        : allPageResults.map((result) => result.page);
+    const builtArtifacts = artifactResults.map((result) => result.artifact);
+    // Plan redirect HTML stubs before assembling the artifact list so they can be
+    // tracked in the manifest (orphan/stale/partial all key off manifest entries).
+    //
+    // `occupied` must reflect the *final merged* outputs, not just this build's
+    // results: on a partial rebuild only a subset of routes/artifacts is
+    // re-enumerated, so collision detection against `pageResults`/`builtArtifacts`
+    // alone would miss pages/artifacts that `mergePartialPages` /
+    // `mergePartialArtifacts` carry over from the previous manifest. Missing them
+    // would let a redirect stub overwrite a real (retained) page on disk and add a
+    // duplicate `outputPath` to the manifest.
+    //
+    // Output paths are recomputed from each entry's `path` with the *current*
+    // build's `trailingSlash` rather than read from `page.outputPath`: the
+    // persisted manifest does not store `trailingSlash`, so pages reconstructed
+    // from it default to "always"-style output paths (e.g. `foo/index.html`) which
+    // would not match a redirect stub planned under `trailingSlash: "never"`
+    // (`foo.html`). The redirect stub path itself is derived via
+    // `outputPathFor(from, trailingSlash)`, so deriving occupied paths the same way
+    // keeps collision detection correct across trailing-slash modes.
+    //
+    // `publicAssets` is already partial-merged above.
+    //
+    // On a partial rebuild `previousManifest.artifacts` includes the redirect stubs
+    // registered by earlier builds. A redirect's own prior stub must NOT count as
+    // occupied, otherwise re-planning the same redirect would see that stub and
+    // skip it, dropping the redirect from the manifest.
+    //
+    // A prior stub is recognised by BOTH signals: its reserved `route`
+    // (REDIRECT_ARTIFACT_ROUTE, rejected as a user family name going forward) AND
+    // its output path being one the current config would plan a redirect for. The
+    // route alone is not sufficient because a manifest written by an older version
+    // (before the name was reserved) could legitimately contain a user artifact
+    // family named "redirect"; requiring the path to match a current redirect
+    // candidate keeps such a retained real artifact in the occupied set so a newly
+    // configured redirect cannot overwrite it.
+    //
+    // Output paths owned by a *real* (non-redirect) output in this build: the
+    // merged pages, this build's artifacts, and the (already merged) public assets.
+    const realOwnerOutputPaths = new Set([
+        ...pages.map((page) => outputPathFor(page.path, trailingSlash)),
+        ...builtArtifacts.map((artifact) => artifact.outputPath),
+        ...publicAssets.map(publicAssetOutputPath),
+    ]);
+    const redirectCandidateOutputPaths = redirectOutputPathSet(config.publishing?.redirectHtml ? config.publishing.redirects : undefined, trailingSlash);
+    const occupiedOutputPaths = new Set([
+        ...realOwnerOutputPaths,
+        ...(config.partial
+            ? previousManifest.artifacts.flatMap((artifact) => {
+                const outputPath = outputPathForArtifact(artifact.path);
+                const isPriorRedirectStub = artifact.route === REDIRECT_ARTIFACT_ROUTE &&
+                    redirectCandidateOutputPaths.has(outputPath);
+                return isPriorRedirectStub ? [] : [outputPath];
+            })
+            : []),
+    ]);
+    const redirectHtmlFiles = config.publishing?.redirectHtml && config.publishing.redirects?.length
+        ? planRedirectHtmlFiles(config.publishing.redirects, config.site.baseUrl, trailingSlash, occupiedOutputPaths)
+        : [];
+    const redirectArtifacts = redirectHtmlFiles.map(redirectArtifact);
+    const changedArtifacts = [...builtArtifacts, ...redirectArtifacts];
+    // Redirect stubs are keyed by their (unique) output path, so an unchanged
+    // redirect config re-plans the same stub every build and `mergePartialArtifacts`
+    // replaces the previous entry in place (no duplication). Stale redirect stubs
+    // whose source was removed are handled by removeStaleGeneratedOutputs on a full
+    // rebuild exactly like any other generated output; partial rebuilds defer disk
+    // cleanup for all output kinds.
+    //
+    // The one case the plain merge would mishandle is a path that hosted a retained
+    // artifact in the previous manifest but is now owned by a real page/artifact in
+    // this build: keeping the retained entry would leave a duplicate `outputPath`.
+    // Drop retained artifacts whose output path is now a real owner so the manifest
+    // never lists two outputs for the same path.
+    const mergeBaseArtifacts = config.partial
+        ? previousManifest.artifacts.filter((artifact) => !realOwnerOutputPaths.has(outputPathForArtifact(artifact.path)))
+        : previousManifest.artifacts;
+    const artifacts = config.partial
+        ? mergePartialArtifacts(mergeBaseArtifacts, changedArtifacts)
+        : changedArtifacts;
+    // The synthetic not-found page is included in `pages`/`pagesWritten` (so it is
+    // registered in the manifest) but excluded from route-family reporting below,
+    // which iterates `pageResults`, so it never appears as a phantom route.
+    const pagesWritten = allPageResults.reduce((total, result) => total + result.pagesWritten, 0);
+    // Redirect HTML stubs are (re)written on every build (writePublishingManifests
+    // writes each planned file unconditionally), so each planned stub counts as one
+    // artifact write. Folding them into artifactsWritten/artifactWrites keeps the
+    // build report and data-flow family summaries honest instead of reporting the
+    // tracked "redirect" family as fully skipped.
+    const artifactsWritten = artifactResults.reduce((total, result) => total + result.artifactsWritten, 0) +
+        redirectArtifacts.length;
+    const routeWrites = countWrites(pageResults, (result) => result.page.route, (result) => result.pagesWritten);
+    const artifactWrites = countWrites(artifactResults, (result) => result.artifact.route, (result) => result.artifactsWritten);
+    if (redirectArtifacts.length > 0) {
+        artifactWrites.redirect = (artifactWrites.redirect ?? 0) + redirectArtifacts.length;
+    }
+    const manifest = {
+        version: 1,
+        pages,
+        artifacts,
+    };
+    const staleOutputsRemoved = config.partial
+        ? 0
+        : (await removeStaleGeneratedOutputs(config.outDir, previousManifest, manifest)) +
+            (await removeStalePublicAssetOutputs(config.outDir, previousReport?.publicAssets ?? [], currentPublicAssets));
+    const sitemapFiles = sitemapFilesFor(manifest, config.sitemap);
+    const sitemapRendered = previousManifest.pages.length === 0 || !sameSitemapEntries(previousManifest.pages, pages);
+    const manifestEntriesReused = reusesManifestEntries(previousManifest, manifest);
+    const canReusePreviousReport = previousReport !== undefined &&
+        config.validation === undefined &&
+        previousReport.validation.configPath === undefined &&
+        previousReport.validation.configHash === undefined &&
+        manifestEntriesReused &&
+        pagesWritten === 0 &&
+        artifactsWritten === 0 &&
+        staleOutputsRemoved === 0;
+    const report = canReusePreviousReport
+        ? unchangedBuildReportFromPrevious(previousReport, {
+            pagesWritten,
+            artifactsWritten,
+            publicAssetsCopied,
+            publicAssetsSkipped,
+            publicAssets,
+            staleOutputsRemoved,
+            sitemapRendered,
+            sitemapFiles,
+            routeWrites,
+            artifactWrites,
+        })
+        : createReport(manifest, pagesWritten, artifactsWritten, publicAssetsCopied, publicAssetsSkipped, publicAssets, staleOutputsRemoved, sitemapRendered, sitemapFiles, routeWrites, artifactWrites, allPageResults.map((result) => result.validationPage), config.validation, config.buildFingerprint, config.renderFingerprint, fragmentDefaultFallbackText, fragmentClientPublicPath);
+    const missingPreviousManifest = previousManifest.pages.length === 0 && previousManifest.artifacts.length === 0;
+    const missingBuildReport = previousReport === undefined;
+    const dataFlowSummaryReportPath = join(config.outDir, ".stoneage/data-flow-summary.json");
+    const dataFlowDependenciesReportPath = join(config.outDir, ".stoneage/data-flow-dependencies.json");
+    const legacyDataFlowReportPath = join(config.outDir, ".stoneage/data-flow.json");
+    const missingDataFlowReport = (await isMissingFile(dataFlowSummaryReportPath)) ||
+        (await isMissingFile(dataFlowDependenciesReportPath));
+    const shouldWriteSitemaps = sitemapRendered || config.sitemap?.maxUrlsPerFile !== undefined;
+    const shouldWriteBuildReportsWithoutComparisons = pagesWritten > 0 ||
+        artifactsWritten > 0 ||
+        publicAssetsCopied > 0 ||
+        publicAssetsSkipped > 0 ||
+        staleOutputsRemoved > 0 ||
+        missingPreviousManifest ||
+        missingBuildReport ||
+        shouldWriteSitemaps;
+    const validationReportChanged = !shouldWriteBuildReportsWithoutComparisons &&
+        !canReusePreviousReport &&
+        previousReport !== undefined &&
+        stableJson(previousReport.validation) !== stableJson(report.validation);
+    const manifestChanged = !shouldWriteBuildReportsWithoutComparisons &&
+        !missingPreviousManifest &&
+        !manifestEntriesReused &&
+        stableJson(previousManifest) !== stableJson(manifest);
+    const shouldWriteBuildReports = shouldWriteBuildReportsWithoutComparisons || manifestChanged || validationReportChanged;
+    if (shouldWriteBuildReports) {
+        const canReuseDataFlowDependenciesReport = !missingDataFlowReport &&
+            canReusePreviousDataFlowDependencies(previousPages, previousArtifacts, pageResults, artifactResults);
+        const dataFlowSummaryReport = createDataFlowSummaryReport(manifest, routeWrites, artifactWrites);
+        const dataFlowDependenciesReport = canReuseDataFlowDependenciesReport
+            ? undefined
+            : createDataFlowDependenciesReport(manifest);
+        if (shouldWriteSitemaps) {
+            await writeSitemaps(config.outDir, manifest, config.site.baseUrl, trailingSlash, config.sitemap);
+        }
+        if (config.prefetch?.serviceWorker) {
+            await writePrefetchAssets(config.outDir, config.prefetch);
+        }
+        const manifestPath = join(config.outDir, ".stoneage/manifest.json");
+        const reportPath = join(config.outDir, ".stoneage/report.json");
+        const metadataWrites = [
+            writeJsonAndCache(manifestReadCache, manifestPath, compactManifest(manifest), manifest),
+            writeJsonAndCache(buildReportReadCache, reportPath, report, report),
+            writeJson(dataFlowSummaryReportPath, dataFlowSummaryReport),
+            rm(legacyDataFlowReportPath, { force: true }),
+        ];
+        if (dataFlowDependenciesReport) {
+            metadataWrites.push(writeJson(dataFlowDependenciesReportPath, dataFlowDependenciesReport));
+        }
+        await Promise.all(metadataWrites);
+    }
+    else if (missingDataFlowReport) {
+        const dataFlowSummaryReport = createDataFlowSummaryReport(manifest, routeWrites, artifactWrites);
+        const dataFlowDependenciesReport = createDataFlowDependenciesReport(manifest);
+        await writeJson(dataFlowSummaryReportPath, dataFlowSummaryReport);
+        await writeJson(dataFlowDependenciesReportPath, dataFlowDependenciesReport);
+        await rm(legacyDataFlowReportPath, { force: true });
+    }
+    if (config.publishing) {
+        await writePublishingManifests(config.outDir, config.publishing, config.site.baseUrl, trailingSlash, manifest, redirectHtmlFiles, staticAssets.headers);
+    }
+    return {
+        pagesWritten,
+        artifactsWritten,
+        publicAssetsCopied,
+        publicAssetsSkipped,
+        manifest,
+        report,
+    };
+}
+async function buildNotFoundPage(config, notFound, trailingSlash, previousPages, sharedPageFingerprintHash, compareExistingGeneratedOutput, fragmentDefaultFallbackText, fragmentClientScripts, assets) {
+    const metadata = {
+        ...resolvePageMetadata(undefined, undefined, notFound.metadata),
+        // A 404 page must never be indexed or advertised in the sitemap.
+        noindex: true,
+        sitemap: false,
+    };
+    // `/404.html` names a concrete file, so its canonical URL must not gain the
+    // trailing slash that `absoluteUrl` would append under trailingSlash "always".
+    const canonical = metadata.canonical ?? `${config.site.baseUrl.replace(/\/$/, "")}${notFoundPath}`;
+    const absoluteOutputPath = join(config.outDir, notFoundOutputPath);
+    const dependencies = await hashDependencies([
+        {
+            key: internalPageFingerprintKey,
+            hash: pageFingerprintHash(notFoundRouteName, notFoundPath, notFoundOutputPath, canonical, metadata, sharedPageFingerprintHash),
+        },
+    ]);
+    const previousPage = previousPages.get(notFoundPath);
+    if (previousPage && sameDependencies(previousPage.dependencies, dependencies)) {
+        return {
+            page: previousPage,
+            validationPage: validationPageFor(notFoundPath, canonical, metadata, config.site),
+            pagesWritten: 0,
+        };
+    }
+    const body = await withDeferredFragmentDefaults({ defaultFallbackText: fragmentDefaultFallbackText }, () => notFound.render());
+    const html = renderDocument(config.site, metadata, canonical, body, assets, config.prefetch, trailingSlash, fragmentClientScripts);
+    await writeText(absoluteOutputPath, html, {
+        compareExisting: compareExistingGeneratedOutput,
+    });
+    return {
+        page: {
+            route: notFoundRouteName,
+            path: notFoundPath,
+            outputPath: notFoundOutputPath,
+            dependencies,
+            links: extractInternalLinks(html, trailingSlash),
+            htmlBytes: Buffer.byteLength(html),
+            sitemap: false,
+        },
+        validationPage: validationPageFor(notFoundPath, canonical, metadata, config.site),
+        pagesWritten: 1,
+    };
+}
+function mergePartialPages(previousPages, changedPages) {
+    const changedByPath = new Map(changedPages.map((page) => [page.path, page]));
+    const merged = [];
+    for (const previousPage of previousPages) {
+        const changedPage = changedByPath.get(previousPage.path);
+        if (changedPage) {
+            merged.push(changedPage);
+            changedByPath.delete(previousPage.path);
+        }
+        else {
+            merged.push(previousPage);
+        }
+    }
+    merged.push(...changedByPath.values());
+    return merged;
+}
+function mergePartialArtifacts(previousArtifacts, changedArtifacts) {
+    const changedByPath = new Map(changedArtifacts.map((artifact) => [artifact.path, artifact]));
+    const merged = [];
+    for (const previousArtifact of previousArtifacts) {
+        const changedArtifact = changedByPath.get(previousArtifact.path);
+        if (changedArtifact) {
+            merged.push(changedArtifact);
+            changedByPath.delete(previousArtifact.path);
+        }
+        else {
+            merged.push(previousArtifact);
+        }
+    }
+    merged.push(...changedByPath.values());
+    return merged;
+}
+async function removeStaleGeneratedOutputs(outDir, previousManifest, manifest) {
+    const currentOutputPaths = new Set(generatedOutputPaths(manifest));
+    const staleOutputPaths = generatedOutputPaths(previousManifest).filter((outputPath) => !currentOutputPaths.has(outputPath));
+    const uniqueStaleOutputPaths = [...new Set(staleOutputPaths)];
+    await Promise.all(uniqueStaleOutputPaths.map((outputPath) => rm(join(outDir, outputPath), { force: true })));
+    return uniqueStaleOutputPaths.length;
+}
+async function removeStalePublicAssetOutputs(outDir, previousPublicAssets, publicAssets) {
+    const currentOutputPaths = new Set(publicAssets.map(publicAssetOutputPath));
+    const staleOutputPaths = previousPublicAssets.flatMap((publicPath) => {
+        const outputPath = safeReportedPublicAssetOutputPath(publicPath);
+        return outputPath && !currentOutputPaths.has(outputPath) ? [outputPath] : [];
+    });
+    const uniqueStaleOutputPaths = [...new Set(staleOutputPaths)];
+    await Promise.all(uniqueStaleOutputPaths.map((outputPath) => rm(join(outDir, outputPath), { force: true })));
+    return uniqueStaleOutputPaths.length;
+}
+function generatedOutputPaths(manifest) {
+    return [
+        ...manifest.pages.map((page) => page.outputPath),
+        ...manifest.artifacts.map((artifact) => artifact.outputPath),
+    ];
+}
+function managedPublicAssetPaths(assets) {
+    return assets.map((asset) => `/${publicAssetOutputPath(asset.publicPath)}`);
+}
+function mergePublicAssets(previousPublicAssets, publicAssets) {
+    return [...new Set([...previousPublicAssets, ...publicAssets])];
+}
+function publicAssetOutputPath(publicPath) {
+    const [path] = publicPath.split(/[?#]/, 1);
+    return posix.normalize(`/${path ?? ""}`).replace(/^\/+/, "");
+}
+function safeReportedPublicAssetOutputPath(publicPath) {
+    const [path = ""] = publicPath.split(/[?#]/, 1);
+    if (!path || path.endsWith("/") || path.split("/").includes("..")) {
+        return undefined;
+    }
+    const outputPath = publicAssetOutputPath(path);
+    return outputPath ? outputPath : undefined;
+}
+function countWrites(items, routeOf, writesOf) {
+    const writes = {};
+    for (const item of items) {
+        const count = writesOf(item);
+        if (count === 0) {
+            continue;
+        }
+        const route = routeOf(item);
+        writes[route] = (writes[route] ?? 0) + count;
+    }
+    return writes;
+}
+function validateOutputPlan(pages, artifacts, hasNotFoundPage) {
+    assertUniquePlanPaths(pages, (page) => page.path, (page) => `page route ${page.routeName} at ${page.path}`, "Duplicate page path");
+    assertUniquePlanPaths(artifacts, (artifact) => artifact.path, (artifact) => `artifact route ${artifact.routeName} at ${artifact.path}`, "Duplicate artifact path");
+    assertUniquePlanPaths([
+        ...pages.map((page) => ({
+            kind: "page",
+            routeName: page.routeName,
+            path: page.path,
+            outputPath: page.outputPath,
+        })),
+        ...artifacts.map((artifact) => ({
+            kind: "artifact",
+            routeName: artifact.routeName,
+            path: artifact.path,
+            outputPath: artifact.outputPath,
+        })),
+        // The built-in not-found page writes a fixed file at the output root; a
+        // user page or artifact that targets the same file would silently clobber
+        // it, so include it in the output-path collision check.
+        ...(hasNotFoundPage
+            ? [
+                {
+                    kind: "not-found page",
+                    routeName: notFoundRouteName,
+                    path: notFoundPath,
+                    outputPath: notFoundOutputPath,
+                },
+            ]
+            : []),
+    ], (item) => item.outputPath, (item) => `${item.kind} route ${item.routeName} at ${item.path}`, "Output path collision");
+}
+function validateParamMatchers(kind, familyName, params, matchers) {
+    for (const [name, matcher] of Object.entries(matchers ?? {})) {
+        if (!matcher) {
+            continue;
+        }
+        const value = params[name];
+        if (value === undefined || value === null) {
+            throw new Error(`${kind} family ${familyName} is missing param for matcher: ${name}`);
+        }
+        const stringValue = String(value);
+        if (!matcher(stringValue)) {
+            throw new Error(`${kind} family ${familyName} param ${name} value ${JSON.stringify(stringValue)} failed its matcher.`);
+        }
+    }
+}
+function assertUniquePlanPaths(items, keyOf, labelOf, errorPrefix) {
+    const seen = new Map();
+    for (const item of items) {
+        const key = keyOf(item);
+        const existing = seen.get(key);
+        if (existing) {
+            throw new Error(`${errorPrefix}: ${key} is produced by ${labelOf(existing)} and ${labelOf(item)}.`);
+        }
+        seen.set(key, item);
+    }
+}
+function resolvePageMetadata(routeDefaults, pathDefaults, pageMetadata) {
+    return {
+        title: "",
+        description: "",
+        ...(routeDefaults ?? {}),
+        ...(pathDefaults ?? {}),
+        ...(pageMetadata ?? {}),
+    };
+}
+function pageFingerprintHash(route, path, outputPath, canonical, metadata, sharedPageFingerprintHash, declaredLinks) {
+    const parts = [
+        route,
+        path,
+        outputPath,
+        canonical,
+        pageMetadataFingerprint(metadata),
+        sharedPageFingerprintHash,
+    ];
+    if (declaredLinks !== undefined) {
+        parts.push(stablePrimitiveArrayFingerprint(declaredLinks));
+    }
+    return hashText(parts.join("\0"));
+}
+function normalizeDeclaredInternalLinks(links, trailingSlash) {
+    if (areDeclaredInternalLinksNormalized(links, trailingSlash)) {
+        return [...links];
+    }
+    const normalized = new Set();
+    for (const href of links) {
+        if (!href.startsWith("/") || href.startsWith("//")) {
+            continue;
+        }
+        normalized.add(normalizeInternalHref(href, trailingSlash));
+    }
+    return [...normalized].sort();
+}
+function areDeclaredInternalLinksNormalized(links, trailingSlash) {
+    let previous = "";
+    for (let index = 0; index < links.length; index += 1) {
+        const link = links[index];
+        if (!isNormalizedInternalHref(link, trailingSlash)) {
+            return false;
+        }
+        if (index > 0 && previous >= link) {
+            return false;
+        }
+        previous = link;
+    }
+    return true;
+}
+function isNormalizedInternalHref(href, trailingSlash) {
+    if (!href.startsWith("/") || href.startsWith("//") || /[?#]/.test(href)) {
+        return false;
+    }
+    if (href.includes("//")) {
+        return false;
+    }
+    if (href === "/") {
+        return true;
+    }
+    if (hasPathExtension(href)) {
+        return !href.endsWith("/");
+    }
+    return trailingSlash === "never" ? !href.endsWith("/") : href.endsWith("/");
+}
+const pageMetadataFingerprintKeys = [
+    "assets",
+    "canonical",
+    "description",
+    "head",
+    "islands",
+    "noindex",
+    "ogDescription",
+    "ogImage",
+    "ogImageHeight",
+    "ogImageWidth",
+    "ogTitle",
+    "ogType",
+    "openGraph",
+    "prefetch",
+    "sitemap",
+    "title",
+    "twitter",
+];
+const pageMetadataFingerprintKeySet = new Set(pageMetadataFingerprintKeys);
+function pageMetadataFingerprint(metadata) {
+    const extraKeys = [];
+    for (const key in metadata) {
+        if (Object.prototype.hasOwnProperty.call(metadata, key) &&
+            !pageMetadataFingerprintKeySet.has(key)) {
+            extraKeys.push(key);
+        }
+    }
+    if (extraKeys.length === 0) {
+        return pageMetadataFingerprintForKeys(metadata, pageMetadataFingerprintKeys);
+    }
+    return pageMetadataFingerprintForKeys(metadata, [...pageMetadataFingerprintKeys, ...extraKeys].sort((left, right) => left.localeCompare(right)));
+}
+function pageMetadataFingerprintForKeys(metadata, keys) {
+    const metadataRecord = metadata;
+    const parts = [];
+    for (const key of keys) {
+        if (!Object.prototype.hasOwnProperty.call(metadata, key)) {
+            continue;
+        }
+        parts.push(`${JSON.stringify(key)}:${pageMetadataFieldFingerprint(metadataRecord[key])}`);
+    }
+    return `{${parts.join(",")}}`;
+}
+function pageMetadataFieldFingerprint(value) {
+    if (isStablePrimitiveArray(value)) {
+        return stablePrimitiveArrayFingerprint(value);
+    }
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value);
+    }
+    return stableJson(value);
+}
+function stablePrimitiveArrayFingerprint(value) {
+    const parts = [];
+    for (const item of value) {
+        parts.push(JSON.stringify(item));
+    }
+    return `[${parts.join(",")}]`;
+}
+function isStablePrimitiveArray(value) {
+    return (Array.isArray(value) &&
+        value.every((item) => item === null || (typeof item !== "object" && typeof item !== "function")));
+}
+function artifactFingerprintHash(route, path, outputPath, renderFingerprint, fragmentDefaultFallbackText) {
+    return hashText([route, path, outputPath, renderFingerprint ?? "", fragmentDefaultFallbackText ?? ""].join("\0"));
+}
+async function mapConcurrent(items, concurrency, worker) {
+    const limit = Math.max(1, Math.floor(concurrency));
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    async function runWorker() {
+        while (nextIndex < items.length) {
+            const index = nextIndex;
+            nextIndex += 1;
+            results[index] = await worker(items[index]);
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => runWorker()));
+    return results;
+}
+async function readManifest(outDir) {
+    const path = join(outDir, ".stoneage/manifest.json");
+    const cached = await readGeneratedJsonCache(manifestReadCache, path);
+    if (cached) {
+        return cached;
+    }
+    try {
+        const raw = await readFile(path, "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed.version === 1 && Array.isArray(parsed.pages)) {
+            return await cacheGeneratedJson(manifestReadCache, path, {
+                ...parsed,
+                artifacts: parsed.artifacts ?? [],
+            });
+        }
+        if (parsed.version === 2 && Array.isArray(parsed.pages)) {
+            return await cacheGeneratedJson(manifestReadCache, path, expandManifestV2(parsed));
+        }
+        if (parsed.version === 3 && Array.isArray(parsed.pages)) {
+            return await cacheGeneratedJson(manifestReadCache, path, expandManifestV3(parsed));
+        }
+        if (parsed.version === 4 && Array.isArray(parsed.pages) && Array.isArray(parsed.strings)) {
+            return await cacheGeneratedJson(manifestReadCache, path, expandManifestV4(parsed));
+        }
+        if (parsed.version === 5 && Array.isArray(parsed.pages) && Array.isArray(parsed.strings)) {
+            return await cacheGeneratedJson(manifestReadCache, path, expandManifestV5(parsed));
+        }
+        if (parsed.version === 6 && Array.isArray(parsed.pages) && Array.isArray(parsed.strings)) {
+            return await cacheGeneratedJson(manifestReadCache, path, expandManifestV6(parsed));
+        }
+        if (parsed.version === 7 &&
+            Array.isArray(parsed.pages) &&
+            Array.isArray(parsed.artifacts) &&
+            Array.isArray(parsed.strings)) {
+            return await cacheGeneratedJson(manifestReadCache, path, expandManifestV7(parsed));
+        }
+        if (parsed.version === 8 &&
+            Array.isArray(parsed.pages) &&
+            Array.isArray(parsed.artifacts) &&
+            Array.isArray(parsed.strings)) {
+            return await cacheGeneratedJson(manifestReadCache, path, expandManifestV8(parsed));
+        }
+    }
+    catch {
+        // A missing or invalid cache is equivalent to a clean build.
+    }
+    return {
+        version: 1,
+        pages: [],
+        artifacts: [],
+    };
+}
+async function readBuildReport(outDir) {
+    const path = join(outDir, ".stoneage/report.json");
+    const cached = await readGeneratedJsonCache(buildReportReadCache, path);
+    if (cached) {
+        return cached;
+    }
+    try {
+        return await cacheGeneratedJson(buildReportReadCache, path, JSON.parse(await readFile(path, "utf8")));
+    }
+    catch (error) {
+        if (isMissingPath(error)) {
+            return undefined;
+        }
+        throw error;
+    }
+}
+async function readGeneratedJsonCache(cache, path) {
+    const cached = cache.get(path);
+    if (!cached) {
+        return undefined;
+    }
+    try {
+        const stats = await stat(path);
+        if (stats.mtimeMs === cached.mtimeMs && stats.size === cached.size) {
+            return cached.value;
+        }
+        cache.delete(path);
+        return undefined;
+    }
+    catch (error) {
+        if (isMissingPath(error)) {
+            cache.delete(path);
+            return undefined;
+        }
+        throw error;
+    }
+}
+async function cacheGeneratedJson(cache, path, value) {
+    const stats = await stat(path);
+    cache.set(path, {
+        mtimeMs: stats.mtimeMs,
+        size: stats.size,
+        value,
+    });
+    return value;
+}
+async function writeJsonAndCache(cache, path, persistedValue, expandedValue) {
+    await writeJson(path, persistedValue);
+    return await cacheGeneratedJson(cache, path, expandedValue);
+}
+function compactManifest(manifest) {
+    const strings = [];
+    const stringIds = new Map();
+    const intern = (value) => {
+        const current = stringIds.get(value);
+        if (current !== undefined) {
+            return current;
+        }
+        const next = strings.length;
+        strings.push(value);
+        stringIds.set(value, next);
+        return next;
+    };
+    return {
+        version: 8,
+        strings,
+        pages: manifest.pages.map((page) => {
+            const persisted = [
+                intern(page.route),
+                intern(page.path),
+                Object.entries(page.dependencies).map(([key, hash]) => [intern(key), hash]),
+                page.links.map((link) => intern(link)),
+                page.htmlBytes,
+            ];
+            if (!page.sitemap) {
+                persisted.push(0);
+            }
+            return persisted;
+        }),
+        artifacts: manifest.artifacts.map((artifact) => {
+            const persisted = [
+                intern(artifact.route),
+                intern(artifact.path),
+                Object.entries(artifact.dependencies).map(([key, hash]) => [intern(key), hash]),
+                artifact.bytes,
+            ];
+            const metadata = persistedArtifactMetadata(artifact);
+            if (metadata) {
+                persisted.push(metadata);
+            }
+            return persisted;
+        }),
+    };
+}
+function persistedArtifactMetadata(artifact) {
+    const metadata = {
+        ...(artifact.contentType ? { contentType: artifact.contentType } : {}),
+        ...(artifact.status !== undefined ? { status: artifact.status } : {}),
+        ...(artifact.headers ? { headers: artifact.headers } : {}),
+    };
+    return Object.keys(metadata).length > 0 ? metadata : undefined;
+}
+function expandManifestV2(manifest) {
+    return {
+        version: 1,
+        pages: manifest.pages.map(([route, path, outputPath, dependencies, links, htmlBytes]) => ({
+            route,
+            path,
+            outputPath,
+            dependencies,
+            links,
+            htmlBytes,
+            sitemap: true,
+        })),
+        artifacts: [],
+    };
+}
+function expandManifestV3(manifest) {
+    return {
+        version: 1,
+        pages: manifest.pages.map(([route, path, dependencies, links, htmlBytes]) => ({
+            route,
+            path,
+            outputPath: outputPathFor(path),
+            dependencies,
+            links,
+            htmlBytes,
+            sitemap: true,
+        })),
+        artifacts: [],
+    };
+}
+function expandManifestV4(manifest) {
+    const readString = (index) => manifest.strings[index] ?? "";
+    return {
+        version: 1,
+        pages: manifest.pages.map(([route, path, dependencies, links, htmlBytes]) => {
+            const pagePath = readString(path);
+            return {
+                route: readString(route),
+                path: pagePath,
+                outputPath: outputPathFor(pagePath),
+                dependencies: Object.fromEntries(dependencies.map(([key, hash]) => [readString(key), hash])),
+                links: links.map((link) => readString(link)),
+                htmlBytes,
+                sitemap: true,
+            };
+        }),
+        artifacts: [],
+    };
+}
+function expandManifestV5(manifest) {
+    const readString = (index) => manifest.strings[index] ?? "";
+    return {
+        version: 1,
+        pages: manifest.pages.map(([route, path, dependencies, links, htmlBytes, sitemap]) => {
+            const pagePath = readString(path);
+            return {
+                route: readString(route),
+                path: pagePath,
+                outputPath: outputPathFor(pagePath),
+                dependencies: Object.fromEntries(dependencies.map(([key, hash]) => [readString(key), hash])),
+                links: links.map((link) => readString(link)),
+                htmlBytes,
+                sitemap: sitemap === 1,
+            };
+        }),
+        artifacts: [],
+    };
+}
+function expandManifestV6(manifest) {
+    const readString = (index) => manifest.strings[index] ?? "";
+    return {
+        version: 1,
+        pages: manifest.pages.map(([route, path, dependencies, links, htmlBytes, sitemap]) => {
+            const pagePath = readString(path);
+            const pageRoute = readString(route);
+            return {
+                route: pageRoute,
+                path: pagePath,
+                // The synthetic not-found page is written to a fixed file at the output
+                // root, so its output path is not derived from `outputPathFor`.
+                outputPath: pageRoute === notFoundRouteName ? notFoundOutputPath : outputPathFor(pagePath),
+                dependencies: Object.fromEntries(dependencies.map(([key, hash]) => [readString(key), hash])),
+                links: links.map((link) => readString(link)),
+                htmlBytes,
+                sitemap: sitemap !== 0,
+            };
+        }),
+        artifacts: [],
+    };
+}
+function expandManifestV7(manifest) {
+    const expanded = expandManifestV6({
+        version: 6,
+        strings: manifest.strings,
+        pages: manifest.pages,
+    });
+    const readString = (index) => manifest.strings[index] ?? "";
+    return {
+        ...expanded,
+        artifacts: manifest.artifacts.map(([route, path, dependencies, bytes]) => {
+            const artifactPath = readString(path);
+            return {
+                route: readString(route),
+                path: artifactPath,
+                outputPath: outputPathForArtifact(artifactPath),
+                dependencies: Object.fromEntries(dependencies.map(([key, hash]) => [readString(key), hash])),
+                bytes,
+            };
+        }),
+    };
+}
+function expandManifestV8(manifest) {
+    const expanded = expandManifestV6({
+        version: 6,
+        strings: manifest.strings,
+        pages: manifest.pages,
+    });
+    const readString = (index) => manifest.strings[index] ?? "";
+    return {
+        ...expanded,
+        artifacts: manifest.artifacts.map(([route, path, dependencies, bytes, metadata]) => {
+            const artifactPath = readString(path);
+            return {
+                route: readString(route),
+                path: artifactPath,
+                outputPath: outputPathForArtifact(artifactPath),
+                dependencies: Object.fromEntries(dependencies.map(([key, hash]) => [readString(key), hash])),
+                bytes,
+                ...(metadata?.contentType ? { contentType: metadata.contentType } : {}),
+                ...(metadata?.status !== undefined ? { status: metadata.status } : {}),
+                ...(metadata?.headers ? { headers: metadata.headers } : {}),
+            };
+        }),
+    };
+}
+function hashDependencies(dependencies) {
+    const precomputed = hashPrecomputedDependencies(dependencies);
+    if (precomputed) {
+        return precomputed;
+    }
+    return hashDynamicDependencies(dependencies);
+}
+function hashPrecomputedDependencies(dependencies) {
+    const hashes = Object.create(null);
+    for (const dependency of dependencies) {
+        if (typeof dependency === "string" || !("hash" in dependency)) {
+            return undefined;
+        }
+        if (hashes[dependency.key] !== undefined) {
+            throw new Error(`Duplicate dependency key: ${JSON.stringify(dependency.key)}`);
+        }
+        hashes[dependency.key] = dependency.hash;
+    }
+    return hashes;
+}
+async function hashDynamicDependencies(dependencies) {
+    const hashes = {};
+    for (const dependency of dependencies) {
+        if (typeof dependency === "string") {
+            setDependencyHash(hashes, dependency, hashText(dependency));
+            continue;
+        }
+        if ("file" in dependency) {
+            const contents = await readFile(dependency.file);
+            setDependencyHash(hashes, dependency.key, hashText(contents));
+            continue;
+        }
+        if ("hash" in dependency) {
+            setDependencyHash(hashes, dependency.key, dependency.hash);
+            continue;
+        }
+        setDependencyHash(hashes, dependency.key, hashValue(dependency.value));
+    }
+    return hashes;
+}
+function setDependencyHash(hashes, key, hash) {
+    if (Object.prototype.hasOwnProperty.call(hashes, key)) {
+        throw new Error(`Duplicate dependency key: ${JSON.stringify(key)}`);
+    }
+    hashes[key] = hash;
+}
+export function hashValue(value) {
+    return hashText(stableJson(value));
+}
+function stableJson(value) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableJson(item)).join(",")}]`;
+    }
+    return `{${Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, item]) => `${JSON.stringify(key)}:${stableJson(item)}`)
+        .join(",")}}`;
+}
+function sameDependencies(left, right) {
+    let leftCount = 0;
+    for (const key in left) {
+        if (!Object.prototype.hasOwnProperty.call(left, key)) {
+            continue;
+        }
+        leftCount += 1;
+        if (left[key] !== right[key]) {
+            return false;
+        }
+    }
+    let rightCount = 0;
+    for (const key in right) {
+        if (Object.prototype.hasOwnProperty.call(right, key)) {
+            rightCount += 1;
+        }
+    }
+    return leftCount === rightCount;
+}
+function renderDocument(site, metadata, canonical, body, assets, prefetch, trailingSlash = "always", extraClientScripts = []) {
+    const title = renderTitle(metadata.title, site);
+    const description = metadata.description || site.description;
+    const ogTitle = metadata.ogTitle ?? metadata.title;
+    const ogDescription = metadata.ogDescription ?? description;
+    const shouldRenderOpenGraph = metadata.openGraph ?? openGraphEnabled(site);
+    const ogTitleMeta = shouldRenderOpenGraph
+        ? `<meta property="og:title" content="${escapeAttribute(ogTitle)}">`
+        : "";
+    const ogDescriptionMeta = shouldRenderOpenGraph
+        ? `<meta property="og:description" content="${escapeAttribute(ogDescription)}">`
+        : "";
+    const ogUrl = shouldRenderOpenGraph
+        ? `<meta property="og:url" content="${escapeAttribute(canonical)}">`
+        : "";
+    const ogSiteNameValue = siteOpenGraphMetadata(site).siteName;
+    const ogSiteName = shouldRenderOpenGraph && ogSiteNameValue
+        ? `<meta property="og:site_name" content="${escapeAttribute(ogSiteNameValue)}">`
+        : "";
+    const favicon = site.favicon
+        ? `<link rel="icon" href="${escapeAttribute(site.favicon)}">`
+        : "";
+    const robots = metadata.noindex ? '<meta name="robots" content="noindex">' : "";
+    const ogImageValue = metadata.ogImage ?? site.ogImage;
+    const ogImage = shouldRenderOpenGraph && ogImageValue
+        ? `<meta property="og:image" content="${escapeAttribute(ogImageValue)}">`
+        : "";
+    const ogImageWidth = metadata.ogImageWidth ?? site.ogImageWidth;
+    const ogImageWidthMeta = shouldRenderOpenGraph && ogImageWidth !== undefined
+        ? `<meta property="og:image:width" content="${escapeAttribute(String(ogImageWidth))}">`
+        : "";
+    const ogImageHeight = metadata.ogImageHeight ?? site.ogImageHeight;
+    const ogImageHeightMeta = shouldRenderOpenGraph && ogImageHeight !== undefined
+        ? `<meta property="og:image:height" content="${escapeAttribute(String(ogImageHeight))}">`
+        : "";
+    const ogType = shouldRenderOpenGraph && metadata.ogType
+        ? `<meta property="og:type" content="${escapeAttribute(metadata.ogType)}">`
+        : "";
+    const twitterMeta = renderTwitterMetadata(site.twitter, metadata.twitter);
+    const customHead = [...(site.head ?? []), ...(metadata.head ?? [])].map(renderHeadTag).join("");
+    const pageClientAssets = resolvePageClientAssets(assets, metadata);
+    const stylesheetLinks = (assets?.stylesheets ?? [])
+        .concat(pageClientAssets.stylesheets)
+        .map((stylesheet) => `<link rel="stylesheet" href="${escapeAttribute(stylesheetHref(stylesheet))}">`)
+        .join("");
+    const clientScripts = renderClientScripts([
+        ...extraClientScripts,
+        ...pageClientAssets.scripts,
+    ]);
+    const prefetchUrls = normalizePrefetchUrls(metadata.prefetch ?? [], trailingSlash);
+    const prefetchLinks = prefetch?.linkRel === false
+        ? ""
+        : prefetchUrls
+            .map((href) => `<link rel="prefetch" href="${escapeAttribute(href)}">`)
+            .join("");
+    const serviceWorkerPrefetch = prefetch?.serviceWorker
+        ? renderServiceWorkerPrefetch(prefetchUrls, prefetch)
+        : "";
+    return `<!doctype html><html lang="${escapeAttribute(site.lang ?? "en")}"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>${escapeHtml(title)}</title><meta name="description" content="${escapeAttribute(description)}"><link rel="canonical" href="${escapeAttribute(canonical)}">${robots}${favicon}${ogTitleMeta}${ogDescriptionMeta}${ogUrl}${ogSiteName}${ogType}${ogImage}${ogImageWidthMeta}${ogImageHeightMeta}${twitterMeta}${customHead}${stylesheetLinks}${clientScripts}${prefetchLinks}${serviceWorkerPrefetch}<body>${body}`;
+}
+function renderTitle(pageTitle, site) {
+    return site.titleTemplate
+        ? site.titleTemplate.replaceAll("%s", pageTitle)
+        : `${pageTitle} | ${site.title}`;
+}
+function openGraphEnabled(site) {
+    return site.openGraph === false ? false : true;
+}
+function siteOpenGraphMetadata(site) {
+    return typeof site.openGraph === "object" ? site.openGraph : {};
+}
+function renderTwitterMetadata(siteTwitter, pageTwitter) {
+    const twitter = { ...(siteTwitter ?? {}), ...(pageTwitter ?? {}) };
+    return [
+        twitter.card ? renderMetaName("twitter:card", twitter.card) : "",
+        twitter.site ? renderMetaName("twitter:site", twitter.site) : "",
+        twitter.creator ? renderMetaName("twitter:creator", twitter.creator) : "",
+        twitter.title ? renderMetaName("twitter:title", twitter.title) : "",
+        twitter.description ? renderMetaName("twitter:description", twitter.description) : "",
+        twitter.image ? renderMetaName("twitter:image", twitter.image) : "",
+    ].join("");
+}
+function renderMetaName(name, content) {
+    return `<meta name="${escapeAttribute(name)}" content="${escapeAttribute(content)}">`;
+}
+function renderHeadTag(tag) {
+    return `<${tag.tag}${renderHeadAttributes(tag.attrs)}>`;
+}
+function renderHeadAttributes(attrs) {
+    return Object.entries(attrs)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([name, value]) => {
+        if (value === false || value === null || value === undefined) {
+            return "";
+        }
+        return value === true ? ` ${name}` : ` ${name}="${escapeAttribute(String(value))}"`;
+    })
+        .join("");
+}
+function resolvePageClientAssets(assets, metadata) {
+    const ids = [...(metadata.assets ?? []), ...(metadata.islands ?? [])];
+    if (ids.length === 0) {
+        return {
+            stylesheets: [],
+            scripts: [],
+        };
+    }
+    return resolveClientAssets(assets?.client ?? {}, ids);
+}
+function stylesheetHref(stylesheet) {
+    return typeof stylesheet === "string" ? stylesheet : stylesheet.href;
+}
+function renderClientScripts(scripts) {
+    return scripts.map((script) => `<script${renderScriptAttributes(script)}></script>`).join("");
+}
+function renderScriptAttributes(script) {
+    let output = script.module ? ' type="module"' : "";
+    output += ` src="${escapeAttribute(script.src)}"`;
+    if (script.defer) {
+        output += " defer";
+    }
+    if (script.async) {
+        output += " async";
+    }
+    for (const [name, value] of Object.entries(script.attributes ?? {}).sort(([left], [right]) => left.localeCompare(right))) {
+        if (value === false || value === null || value === undefined) {
+            continue;
+        }
+        output += value === true ? ` ${name}` : ` ${name}="${escapeAttribute(String(value))}"`;
+    }
+    return output;
+}
+function normalizePrefetchUrls(urls, trailingSlash) {
+    return [
+        ...new Set(urls.map((url) => url.startsWith("/") && !url.startsWith("//")
+            ? normalizeInternalHref(url, trailingSlash)
+            : url)),
+    ];
+}
+function renderServiceWorkerPrefetch(urls, prefetch) {
+    if (urls.length === 0) {
+        return "";
+    }
+    const scriptPath = prefetch.scriptPath ?? "/stoneage-prefetch.js";
+    const prefetchUrls = [...new Set(urls)].join(" ");
+    return `<script src="${escapeAttribute(scriptPath)}" data-prefetch="${escapeAttribute(prefetchUrls)}"></script>`;
+}
+async function writePrefetchAssets(outDir, prefetch) {
+    const scriptPath = prefetch.scriptPath ?? "/stoneage-prefetch.js";
+    const workerPath = prefetch.workerPath ?? "/stoneage-prefetch-sw.js";
+    const cacheName = prefetch.cacheName ?? "stoneage-prefetch-v1";
+    await Promise.all([
+        writeText(join(outDir, publicOutputPathForAsset(scriptPath)), renderPrefetchScript(workerPath)),
+        writeText(join(outDir, publicOutputPathForAsset(workerPath)), renderPrefetchWorker(cacheName)),
+    ]);
+}
+function renderPrefetchScript(workerPath) {
+    return `const scripts=document.currentScript?[document.currentScript]:document.querySelectorAll("script[data-prefetch]");const urls=[...scripts].flatMap((script)=>(script.dataset.prefetch||"").split(/\\s+/).filter(Boolean));if(urls.length>0&&"serviceWorker"in navigator){navigator.serviceWorker.register("${escapeJavaScriptString(workerPath)}").then((registration)=>navigator.serviceWorker.ready.then(()=>{const worker=registration.active||navigator.serviceWorker.controller;if(worker)worker.postMessage({type:"STONEAGE_PREFETCH",urls});})).catch(()=>{});}`;
+}
+function renderPrefetchWorker(cacheName) {
+    return `const CACHE_NAME="${escapeJavaScriptString(cacheName)}";self.addEventListener("message",(event)=>{const data=event.data;if(!data||data.type!=="STONEAGE_PREFETCH"||!Array.isArray(data.urls))return;event.waitUntil(caches.open(CACHE_NAME).then((cache)=>Promise.all(data.urls.filter((url)=>typeof url==="string"&&url.startsWith("/")).map((url)=>cache.add(url).catch(()=>undefined)))));});`;
+}
+async function writePublishingManifests(outDir, publishing, baseUrl, trailingSlash, manifest, redirectHtmlFiles, staticAssetHeaders = []) {
+    const redirects = normalizePublishingRedirects(publishing.redirects ?? [], trailingSlash);
+    if (publishing.robots !== undefined && publishing.robots !== false) {
+        await writeText(join(outDir, "robots.txt"), renderRobotsTxt(publishing.robots, baseUrl, trailingSlash));
+    }
+    if (redirects.length > 0) {
+        await writeJson(join(outDir, "redirects.json"), {
+            redirects,
+        });
+    }
+    for (const file of redirectHtmlFiles) {
+        await writeText(join(outDir, file.outputPath), file.html);
+    }
+    let headers = [];
+    if (publishing.headers === false) {
+        await rm(join(outDir, "headers.json"), { force: true });
+    }
+    else {
+        headers = await writeArtifactHeadersManifest(outDir, manifest, staticAssetHeaders);
+    }
+    await writeNativePublishingArtifacts(outDir, publishing, redirects, headers);
+}
+async function writeArtifactHeadersManifest(outDir, manifest, staticAssetHeaders = []) {
+    const headers = [
+        ...manifest.artifacts
+            .map((artifact) => {
+            const artifactHeaders = artifactPublishingHeaders(artifact);
+            return Object.keys(artifactHeaders).length > 0
+                ? { path: artifact.path, headers: artifactHeaders }
+                : undefined;
+        })
+            .filter((entry) => entry !== undefined),
+        ...staticAssetHeaders,
+    ];
+    const outputPath = join(outDir, "headers.json");
+    if (headers.length === 0) {
+        await rm(outputPath, { force: true });
+        return headers;
+    }
+    await writeJson(outputPath, { headers });
+    return headers;
+}
+function normalizePublishingRedirects(redirects, trailingSlash) {
+    return redirects.map((redirect) => ({
+        from: normalizeRedirectPath(redirect.from, trailingSlash),
+        to: normalizeRedirectPath(redirect.to, trailingSlash),
+        status: redirect.status ?? 301,
+    }));
+}
+async function writeNativePublishingArtifacts(outDir, publishing, redirects, headers) {
+    if (publishing.nativeRedirects === undefined || publishing.nativeRedirects === false) {
+        return;
+    }
+    if (publishing.nativeRedirects !== "netlify") {
+        throw new Error(`Unsupported native redirects format: ${publishing.nativeRedirects}`);
+    }
+    if (redirects.length > 0) {
+        await writeText(join(outDir, "_redirects"), renderNetlifyRedirects(redirects));
+    }
+    else {
+        await rm(join(outDir, "_redirects"), { force: true });
+    }
+    if (publishing.headers !== false && headers.length > 0) {
+        await writeText(join(outDir, "_headers"), renderNetlifyHeaders(headers));
+    }
+    else {
+        await rm(join(outDir, "_headers"), { force: true });
+    }
+}
+function artifactPublishingHeaders(artifact) {
+    return {
+        ...(artifact.contentType ? { "content-type": artifact.contentType } : {}),
+        ...(artifact.headers ?? {}),
+    };
+}
+function renderRobotsTxt(robots, baseUrl, trailingSlash) {
+    const lines = [];
+    for (const rule of robots.rules ?? []) {
+        for (const userAgent of Array.isArray(rule.userAgent) ? rule.userAgent : [rule.userAgent]) {
+            lines.push(`User-agent: ${userAgent}`);
+        }
+        for (const allow of rule.allow ?? []) {
+            lines.push(`Allow: ${allow}`);
+        }
+        for (const disallow of rule.disallow ?? []) {
+            lines.push(`Disallow: ${disallow}`);
+        }
+        if (rule.crawlDelay !== undefined) {
+            lines.push(`Crawl-delay: ${rule.crawlDelay}`);
+        }
+    }
+    const sitemapUrls = robots.sitemap === false
+        ? []
+        : Array.isArray(robots.sitemap)
+            ? robots.sitemap
+            : [`${baseUrl.replace(/\/$/, "")}/sitemap.xml`];
+    for (const sitemap of sitemapUrls) {
+        lines.push(`Sitemap: ${sitemap}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+function normalizeRedirectPath(value, trailingSlash) {
+    return value.startsWith("/") && !value.startsWith("//") ? normalizePath(value, trailingSlash) : value;
+}
+function isInternalRedirectPath(value) {
+    return value.startsWith("/") && !value.startsWith("//");
+}
+// Reserved artifact `route` used to mark generated redirect HTML stubs in the
+// manifest. It is rejected as a user artifact/route family name (see
+// assertReservedRouteUnused) so prior redirect stubs can be identified by route
+// without clashing with a real user family.
+const REDIRECT_ARTIFACT_ROUTE = "redirect";
+const reservedGeneratedArtifactRoutes = new Set([
+    REDIRECT_ARTIFACT_ROUTE,
+    fragmentClientRouteName,
+]);
+// Reject a user artifact family whose name would collide with the reserved
+// redirect-stub route. Without this, a retained user artifact named "redirect"
+// could not be distinguished from a generated redirect stub during partial-merge
+// collision handling.
+function assertReservedRouteUnused(kind, name) {
+    if (reservedGeneratedArtifactRoutes.has(name)) {
+        throw new Error(`${kind} family name "${name}" is reserved for generated StoneAge artifacts; choose a different name.`);
+    }
+}
+// Register a planned redirect HTML stub as a manifest artifact so it rides the
+// existing orphan-detection, stale-cleanup, and partial-merge machinery. The
+// stored `path` is `/<outputPath>` because the compacted manifest does not
+// persist `outputPath`; the validator reconstructs it from `path` by stripping
+// the leading slash (see outputPathForArtifactPath in cli.ts). `contentType` is
+// intentionally omitted so redirect stubs behave like generated HTML pages and
+// do not emit spurious entries in headers.json.
+function redirectArtifact(file) {
+    return {
+        route: REDIRECT_ARTIFACT_ROUTE,
+        path: `/${file.outputPath}`,
+        outputPath: file.outputPath,
+        dependencies: {},
+        bytes: Buffer.byteLength(file.html),
+    };
+}
+// Output paths a redirect HTML stub *could* occupy, derived purely from the
+// publishing config using the same internal-`from` derivation as
+// planRedirectHtmlFiles. Used (together with the reserved route) to recognise a
+// redirect's own previously-registered stub when re-planning on a partial
+// rebuild, so it is not treated as an occupied path.
+function redirectOutputPathSet(redirects, trailingSlash) {
+    const outputPaths = new Set();
+    for (const redirect of redirects ?? []) {
+        if (!isInternalRedirectPath(redirect.from)) {
+            continue;
+        }
+        outputPaths.add(outputPathFor(normalizeRedirectPath(redirect.from, trailingSlash), trailingSlash));
+    }
+    return outputPaths;
+}
+function planRedirectHtmlFiles(redirects, baseUrl, trailingSlash, occupied) {
+    const taken = new Set(occupied);
+    const planned = [];
+    for (const redirect of redirects) {
+        if (!isInternalRedirectPath(redirect.from)) {
+            // `from` points outside the site (absolute URL or protocol-relative);
+            // a static page cannot be written for it, so leave it to the manifest.
+            console.warn(`StoneAge: skipping redirect HTML for non-internal source "${redirect.from}".`);
+            continue;
+        }
+        const from = normalizeRedirectPath(redirect.from, trailingSlash);
+        const outputPath = outputPathFor(from, trailingSlash);
+        if (taken.has(outputPath)) {
+            // A real page, artifact, or public asset already owns this path; never
+            // overwrite it.
+            console.warn(`StoneAge: skipping redirect HTML for "${from}" because a page or asset already exists at that path.`);
+            continue;
+        }
+        taken.add(outputPath);
+        const target = normalizeRedirectPath(redirect.to, trailingSlash);
+        const canonical = isInternalRedirectPath(redirect.to)
+            ? absoluteUrl(baseUrl, redirect.to, trailingSlash)
+            : redirect.to;
+        planned.push({ outputPath, html: renderRedirectHtml(target, canonical) });
+    }
+    return planned;
+}
+function renderRedirectHtml(target, canonical) {
+    const href = escapeAttribute(target);
+    return [
+        "<!doctype html>",
+        '<html lang="en">',
+        "<head>",
+        '<meta charset="utf-8">',
+        `<meta http-equiv="refresh" content="0; url=${href}">`,
+        `<link rel="canonical" href="${escapeAttribute(canonical)}">`,
+        '<meta name="robots" content="noindex">',
+        "<title>Redirecting…</title>",
+        "</head>",
+        "<body>",
+        `<p>Redirecting to <a href="${href}">${escapeHtml(target)}</a></p>`,
+        "</body>",
+        "</html>",
+        "",
+    ].join("\n");
+}
+async function writeSitemaps(outDir, manifest, baseUrl, trailingSlash = "always", sitemap) {
+    const pageUrls = sitemapPageUrls(manifest, baseUrl, trailingSlash);
+    const maxUrlsPerFile = readSitemapMaxUrlsPerFile(sitemap);
+    if (maxUrlsPerFile === undefined || pageUrls.length <= maxUrlsPerFile) {
+        await writeText(join(outDir, "sitemap.xml"), renderSitemapUrlSet(pageUrls));
+        await removeStaleSplitSitemaps(outDir, []);
+        return;
+    }
+    const chunks = chunkArray(pageUrls, maxUrlsPerFile);
+    const files = chunks.map((_, index) => `sitemap-${index + 1}.xml`);
+    await Promise.all(chunks.map((urls, index) => writeText(join(outDir, files[index]), renderSitemapUrlSet(urls))));
+    await writeText(join(outDir, "sitemap.xml"), renderSitemapIndex(files.map((file) => absoluteArtifactUrl(baseUrl, `/${file}`))));
+    await removeStaleSplitSitemaps(outDir, files);
+}
+function sitemapFilesFor(manifest, sitemap) {
+    const urlCount = manifest.pages.filter((page) => page.sitemap).length;
+    const maxUrlsPerFile = readSitemapMaxUrlsPerFile(sitemap);
+    if (maxUrlsPerFile === undefined || urlCount <= maxUrlsPerFile) {
+        return ["sitemap.xml"];
+    }
+    return [
+        "sitemap.xml",
+        ...Array.from({ length: Math.ceil(urlCount / maxUrlsPerFile) }, (_, index) => `sitemap-${index + 1}.xml`),
+    ];
+}
+function readSitemapMaxUrlsPerFile(sitemap) {
+    const maxUrlsPerFile = sitemap?.maxUrlsPerFile;
+    if (maxUrlsPerFile === undefined) {
+        return undefined;
+    }
+    if (!Number.isInteger(maxUrlsPerFile) || maxUrlsPerFile < 1) {
+        throw new Error("sitemap.maxUrlsPerFile must be a positive integer.");
+    }
+    return maxUrlsPerFile;
+}
+function sitemapPageUrls(manifest, baseUrl, trailingSlash) {
+    return manifest.pages
+        .filter((page) => page.sitemap)
+        .map((page) => absoluteUrl(baseUrl, page.path, trailingSlash));
+}
+function renderSitemapUrlSet(urls) {
+    const entries = urls.map((url) => `<url><loc>${escapeHtml(url)}</loc></url>`).join("");
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">${entries}</urlset>
+`;
+}
+function renderSitemapIndex(urls) {
+    const entries = urls
+        .map((url) => `<sitemap><loc>${escapeHtml(url)}</loc></sitemap>`)
+        .join("");
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">${entries}</sitemapindex>
+`;
+}
+function createReport(manifest, pagesWritten, artifactsWritten, publicAssetsCopied, publicAssetsSkipped, publicAssets, staleOutputsRemoved, sitemapRendered, sitemapFiles, routeWrites, artifactWrites, validationPages, validation, buildFingerprint, renderFingerprint, fragmentDefaultFallbackText, fragmentClientPublicPath) {
+    const existingPaths = new Set([
+        ...manifest.pages.map((page) => page.path),
+        ...manifest.artifacts.map((artifact) => artifact.path),
+    ]);
+    const routeFamilies = {};
+    const artifactFamilies = {};
+    const missingLinks = [];
+    for (const page of manifest.pages) {
+        if (page.route !== notFoundRouteName) {
+            routeFamilies[page.route] = (routeFamilies[page.route] ?? 0) + 1;
+        }
+        for (const link of page.links) {
+            if (!existingPaths.has(link)) {
+                missingLinks.push(`${page.path} -> ${link}`);
+            }
+        }
+    }
+    for (const artifact of manifest.artifacts) {
+        artifactFamilies[artifact.route] = (artifactFamilies[artifact.route] ?? 0) + 1;
+    }
+    return {
+        ...(buildFingerprint === undefined ? {} : { buildFingerprint }),
+        ...(renderFingerprint === undefined ? {} : { renderFingerprint }),
+        ...(fragmentDefaultFallbackText === undefined ? {} : { fragmentDefaultFallbackText }),
+        ...(fragmentClientPublicPath === undefined ? {} : { fragmentClientPublicPath }),
+        pageCount: manifest.pages.length,
+        pagesWritten,
+        artifactCount: manifest.artifacts.length,
+        artifactsWritten,
+        publicAssetsCopied,
+        publicAssetsSkipped,
+        publicAssets,
+        staleOutputsRemoved,
+        sitemapRendered,
+        sitemapFiles,
+        routeFamilies,
+        routeWrites,
+        artifactFamilies,
+        artifactWrites,
+        missingLinks,
+        largestHtml: largestOutputs(manifest.pages, (page) => page.htmlBytes),
+        largestArtifacts: largestOutputs(manifest.artifacts, (artifact) => artifact.bytes),
+        validation: createValidationReport(manifest, validationPages, validation),
+    };
+}
+function largestOutputs(outputs, bytesOf, limit = 20) {
+    const largest = [];
+    for (const output of outputs) {
+        const bytes = bytesOf(output);
+        let insertAt = largest.length;
+        while (insertAt > 0 && bytes > largest[insertAt - 1].bytes) {
+            insertAt -= 1;
+        }
+        if (insertAt >= limit) {
+            continue;
+        }
+        largest.splice(insertAt, 0, { output, bytes });
+        if (largest.length > limit) {
+            largest.length = limit;
+        }
+    }
+    return largest.map(({ output, bytes }) => ({ path: output.path, bytes }));
+}
+function createDataFlowReport(manifest, routeWrites, artifactWrites) {
+    return {
+        ...createDataFlowSummaryReport(manifest, routeWrites, artifactWrites),
+        dependencies: dependencySummaries(manifest),
+    };
+}
+function createDataFlowSummaryReport(manifest, routeWrites, artifactWrites) {
+    return {
+        version: 1,
+        outputs: {
+            pages: manifest.pages.length,
+            artifacts: manifest.artifacts.length,
+            total: manifest.pages.length + manifest.artifacts.length,
+        },
+        routeFamilies: familySummaries(manifest.pages.filter((page) => page.route !== notFoundRouteName), (page) => page.route, (page) => page.htmlBytes, routeWrites),
+        artifactFamilies: familySummaries(manifest.artifacts, (artifact) => artifact.route, (artifact) => artifact.bytes, artifactWrites),
+    };
+}
+function createDataFlowDependenciesReport(manifest) {
+    return {
+        version: 1,
+        dependencies: dependencySummaries(manifest),
+    };
+}
+function canReusePreviousDataFlowDependencies(previousPages, previousArtifacts, pageResults, artifactResults) {
+    for (const result of pageResults) {
+        if (result.pagesWritten === 0) {
+            continue;
+        }
+        const previousPage = previousPages.get(result.page.path);
+        if (previousPage === undefined ||
+            previousPage.route !== result.page.route ||
+            !samePublicDependencyKeys(previousPage.dependencies, result.page.dependencies)) {
+            return false;
+        }
+    }
+    for (const result of artifactResults) {
+        if (result.artifactsWritten === 0) {
+            continue;
+        }
+        const previousArtifact = previousArtifacts.get(result.artifact.path);
+        if (previousArtifact === undefined ||
+            previousArtifact.route !== result.artifact.route ||
+            !samePublicDependencyKeys(previousArtifact.dependencies, result.artifact.dependencies)) {
+            return false;
+        }
+    }
+    return true;
+}
+function samePublicDependencyKeys(left, right) {
+    const leftKeys = publicDependencyKeys(left);
+    const rightKeys = publicDependencyKeys(right);
+    if (leftKeys.length !== rightKeys.length) {
+        return false;
+    }
+    const leftKeySet = new Set(leftKeys);
+    return rightKeys.every((key) => leftKeySet.has(key));
+}
+function familySummaries(outputs, routeOf, bytesOf, writes) {
+    const summaries = new Map();
+    for (const output of outputs) {
+        const name = routeOf(output);
+        const summary = summaries.get(name) ??
+            {
+                name,
+                outputs: 0,
+                written: writes[name] ?? 0,
+                skipped: 0,
+                bytes: 0,
+            };
+        summary.outputs += 1;
+        summary.bytes += bytesOf(output);
+        summaries.set(name, summary);
+    }
+    return [...summaries.values()]
+        .map((summary) => ({
+        ...summary,
+        skipped: Math.max(0, summary.outputs - summary.written),
+    }))
+        .sort((left, right) => left.name.localeCompare(right.name));
+}
+function dependencySummaries(manifest) {
+    const summaries = new Map();
+    for (const page of manifest.pages) {
+        for (const key of publicDependencyKeys(page.dependencies)) {
+            const summary = dependencySummaryFor(summaries, key);
+            summary.outputs += 1;
+            summary.pages += 1;
+            summary.routes[page.route] = (summary.routes[page.route] ?? 0) + 1;
+        }
+    }
+    for (const artifact of manifest.artifacts) {
+        for (const key of publicDependencyKeys(artifact.dependencies)) {
+            const summary = dependencySummaryFor(summaries, key);
+            summary.outputs += 1;
+            summary.artifacts += 1;
+            summary.artifactRoutes[artifact.route] =
+                (summary.artifactRoutes[artifact.route] ?? 0) + 1;
+        }
+    }
+    return [...summaries.values()].sort((left, right) => right.outputs - left.outputs || left.key.localeCompare(right.key));
+}
+function publicDependencyKeys(dependencies) {
+    const keys = [];
+    for (const key in dependencies) {
+        if (Object.prototype.hasOwnProperty.call(dependencies, key) &&
+            !key.startsWith("\0stoneage:")) {
+            keys.push(key);
+        }
+    }
+    return keys;
+}
+function dependencySummaryFor(summaries, key) {
+    const existing = summaries.get(key);
+    if (existing) {
+        return existing;
+    }
+    const summary = {
+        key,
+        outputs: 0,
+        pages: 0,
+        artifacts: 0,
+        routes: {},
+        artifactRoutes: {},
+    };
+    summaries.set(key, summary);
+    return summary;
+}
+function validationPageFor(path, canonical, metadata, site) {
+    return {
+        path,
+        title: metadata.title,
+        description: metadata.description,
+        canonical,
+        favicon: site.favicon ?? "",
+        ogImage: metadata.ogImage ?? site.ogImage ?? "",
+        twitterImage: metadata.twitter?.image ?? site.twitter?.image ?? "",
+    };
+}
+function createValidationReport(manifest, validationPages, validation) {
+    const issues = [];
+    const requiredMetadata = validation?.requiredMetadata ?? ["title", "description", "canonical"];
+    for (const page of validationPages) {
+        if (requiredMetadata.includes("title") && page.title.trim() === "") {
+            issues.push({
+                code: "metadata.missing_title",
+                path: page.path,
+                message: `${page.path} is missing a title.`,
+            });
+        }
+        if (requiredMetadata.includes("description") && page.description.trim() === "") {
+            issues.push({
+                code: "metadata.missing_description",
+                path: page.path,
+                message: `${page.path} is missing a description.`,
+            });
+        }
+        if (requiredMetadata.includes("canonical") && page.canonical.trim() === "") {
+            issues.push({
+                code: "metadata.missing_canonical",
+                path: page.path,
+                message: `${page.path} is missing a canonical URL.`,
+            });
+        }
+        if (requiredMetadata.includes("favicon") && page.favicon.trim() === "") {
+            issues.push({
+                code: "metadata.missing_favicon",
+                path: page.path,
+                message: `${page.path} is missing a favicon.`,
+            });
+        }
+        if (requiredMetadata.includes("ogImage") && page.ogImage.trim() === "") {
+            issues.push({
+                code: "metadata.missing_og_image",
+                path: page.path,
+                message: `${page.path} is missing an Open Graph image.`,
+            });
+        }
+        if (requiredMetadata.includes("twitterImage") && page.twitterImage.trim() === "") {
+            issues.push({
+                code: "metadata.missing_twitter_image",
+                path: page.path,
+                message: `${page.path} is missing a Twitter image.`,
+            });
+        }
+    }
+    const canonicalPaths = new Map();
+    for (const page of validationPages) {
+        const canonical = page.canonical.trim();
+        if (canonical === "") {
+            continue;
+        }
+        canonicalPaths.set(canonical, [...(canonicalPaths.get(canonical) ?? []), page.path]);
+    }
+    for (const [canonical, paths] of canonicalPaths) {
+        if (paths.length < 2) {
+            continue;
+        }
+        for (const path of paths) {
+            issues.push({
+                code: "canonical.duplicate",
+                path,
+                message: `${path} shares canonical URL ${canonical} with ${paths.length - 1} other page(s).`,
+            });
+        }
+    }
+    const maxHtmlBytes = validation?.budgets?.maxHtmlBytes;
+    if (maxHtmlBytes !== undefined) {
+        for (const page of manifest.pages) {
+            if (page.htmlBytes > maxHtmlBytes) {
+                issues.push({
+                    code: "budget.html",
+                    path: page.path,
+                    bytes: page.htmlBytes,
+                    limit: maxHtmlBytes,
+                    message: `${page.path} is ${page.htmlBytes} bytes, exceeding the ${maxHtmlBytes} byte HTML budget.`,
+                });
+            }
+        }
+    }
+    // Count-based page budgets ignore the synthetic not-found page so it does not
+    // push a site over its budget or appear as a phantom route family.
+    const budgetPages = manifest.pages.filter((page) => page.route !== notFoundRouteName);
+    const maxPages = validation?.budgets?.maxPages;
+    if (maxPages !== undefined && budgetPages.length > maxPages) {
+        issues.push({
+            code: "budget.pages",
+            path: ".",
+            bytes: budgetPages.length,
+            limit: maxPages,
+            message: `Generated page count is ${budgetPages.length}, exceeding the ${maxPages} page budget.`,
+        });
+    }
+    const maxArtifacts = validation?.budgets?.maxArtifacts;
+    if (maxArtifacts !== undefined && manifest.artifacts.length > maxArtifacts) {
+        issues.push({
+            code: "budget.artifacts",
+            path: ".",
+            bytes: manifest.artifacts.length,
+            limit: maxArtifacts,
+            message: `Generated artifact count is ${manifest.artifacts.length}, exceeding the ${maxArtifacts} artifact budget.`,
+        });
+    }
+    for (const issue of familyCountBudgetIssues(pageFamilyCounts(budgetPages), validation?.budgets?.maxRouteFamilyPages, "budget.route_family_pages", "pages", "page route family")) {
+        issues.push(issue);
+    }
+    for (const issue of familyCountBudgetIssues(artifactFamilyCounts(manifest.artifacts), validation?.budgets?.maxArtifactFamilyOutputs, "budget.artifact_family_outputs", "artifacts", "artifact family output")) {
+        issues.push(issue);
+    }
+    const maxDependencyFanout = validation?.budgets?.maxDependencyFanout;
+    if (maxDependencyFanout !== undefined) {
+        for (const dependency of dependencySummaries(manifest)) {
+            if (dependency.outputs > maxDependencyFanout) {
+                issues.push({
+                    code: "budget.dependency_fanout",
+                    dependency: dependency.key,
+                    outputs: dependency.outputs,
+                    limit: maxDependencyFanout,
+                    message: `${dependency.key} fans out to ${dependency.outputs} outputs, exceeding the ${maxDependencyFanout} output dependency fanout budget.`,
+                });
+            }
+        }
+    }
+    const validationConfigHash = validation?.configHash ?? (validation ? hashValue(validation) : undefined);
+    return {
+        ok: issues.length === 0,
+        ...(validation?.configPath ? { configPath: validation.configPath } : {}),
+        ...(validationConfigHash ? { configHash: validationConfigHash } : {}),
+        issues,
+    };
+}
+function pageFamilyCounts(pages) {
+    return familyCounts(pages, (page) => page.route);
+}
+function artifactFamilyCounts(artifacts) {
+    return familyCounts(artifacts, (artifact) => artifact.route);
+}
+function familyCounts(outputs, familyOf) {
+    const counts = {};
+    for (const output of outputs) {
+        const family = familyOf(output);
+        counts[family] = (counts[family] ?? 0) + 1;
+    }
+    return counts;
+}
+function familyCountBudgetIssues(counts, limits, code, outputLabel, budgetLabel) {
+    if (!limits) {
+        return [];
+    }
+    return Object.entries(limits)
+        .flatMap(([family, limit]) => {
+        const count = counts[family] ?? 0;
+        return count > limit
+            ? [
+                {
+                    code,
+                    path: family,
+                    bytes: count,
+                    limit,
+                    message: `${family} generated ${count} ${outputLabel}, exceeding the ${limit} ${budgetLabel} budget.`,
+                },
+            ]
+            : [];
+    })
+        .sort((left, right) => (right.bytes ?? 0) - (left.bytes ?? 0) ||
+        (left.path ?? "").localeCompare(right.path ?? ""));
+}
+function sameSitemapEntries(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    for (let index = 0; index < left.length; index += 1) {
+        const leftPage = left[index];
+        const rightPage = right[index];
+        if (leftPage.path !== rightPage.path || leftPage.sitemap !== rightPage.sitemap) {
+            return false;
+        }
+    }
+    return true;
+}
+function reusesManifestEntries(previous, current) {
+    return (reusesArrayEntries(previous.pages, current.pages) &&
+        reusesArrayEntries(previous.artifacts, current.artifacts));
+}
+function reusesArrayEntries(previous, current) {
+    if (previous.length !== current.length) {
+        return false;
+    }
+    for (let index = 0; index < previous.length; index += 1) {
+        if (previous[index] !== current[index]) {
+            return false;
+        }
+    }
+    return true;
+}
+function unchangedBuildReportFromPrevious(previous, changes) {
+    return {
+        ...previous,
+        ...changes,
+    };
+}
+function sameStringList(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    return left.every((value, index) => value === right[index]);
+}
+function extractInternalLinks(html, trailingSlash = "always") {
+    const links = new Set();
+    const linkPattern = /<a\b[^>]*\bhref="([^"]+)"/g;
+    let match;
+    while ((match = linkPattern.exec(html)) !== null) {
+        const href = match[1];
+        if (!href.startsWith("/") || href.startsWith("//")) {
+            continue;
+        }
+        links.add(normalizeInternalHref(href, trailingSlash));
+    }
+    return [...links].sort();
+}
+function normalizeInternalHref(href, trailingSlash) {
+    return hasPathExtension(href) ? normalizeArtifactPath(href) : normalizePath(href, trailingSlash);
+}
+function hasPathExtension(path) {
+    const [pathname] = path.split(/[?#]/, 1);
+    const lastSegment = pathname.split("/").pop() ?? "";
+    return /\.[A-Za-z0-9]+$/.test(lastSegment);
+}
+function outputPathFor(path, trailingSlash = "always") {
+    const normalized = normalizePath(path, trailingSlash);
+    if (normalized === "/") {
+        return "index.html";
+    }
+    if (trailingSlash === "never") {
+        return `${normalized.slice(1)}.html`;
+    }
+    return join(normalized.slice(1), "index.html");
+}
+function outputPathForArtifact(path) {
+    return normalizeArtifactPath(path).slice(1);
+}
+function normalizePath(path, trailingSlash = "always") {
+    const [pathname] = path.split(/[?#]/, 1);
+    if (pathname === "/") {
+        return pathname;
+    }
+    const withoutTrailingSlash = pathname.replace(/\/+$/, "");
+    return trailingSlash === "never" ? withoutTrailingSlash : `${withoutTrailingSlash}/`;
+}
+function normalizeArtifactPath(path) {
+    const [pathname] = path.split(/[?#]/, 1);
+    const normalized = pathname.startsWith("/") ? pathname : `/${pathname}`;
+    if (normalized === "/") {
+        throw new Error("Artifact path cannot be the site root.");
+    }
+    if (normalized.endsWith("/")) {
+        throw new Error("Artifact path cannot end with a slash.");
+    }
+    return normalized.replaceAll(/\/+/g, "/");
+}
+function normalizeSvgAssetDir(dir) {
+    const [pathname] = dir.split(/[?#]/, 1);
+    if (!pathname.startsWith("/")) {
+        throw new Error(`SVG asset dir must be an absolute site path. Received ${JSON.stringify(dir)}.`);
+    }
+    const normalized = pathname.replaceAll(/\/+/g, "/").replace(/\/+$/, "");
+    if (normalized === "") {
+        throw new Error("SVG asset dir cannot be the site root.");
+    }
+    return normalized;
+}
+function normalizeSvgAssetContent(svg, familyName) {
+    const normalized = svg.replaceAll("\r\n", "\n").replaceAll("\r", "\n").replace(/\n$/, "");
+    if (normalized.trim() === "" || !normalized.trimStart().startsWith("<svg")) {
+        throw new Error(`SVG asset family ${familyName} rendered non-SVG content.`);
+    }
+    return normalized;
+}
+function svgAssetContentHash(svg) {
+    return createHash("sha256").update(svg).digest("hex").slice(0, 16);
+}
+function normalizeFragmentCandidatePath(path) {
+    const [pathname] = path.split(/[?#]/, 1);
+    const normalized = pathname.startsWith("/") ? pathname : `/${pathname}`;
+    const collapsed = normalized.replaceAll(/\/+/g, "/").replace(/\/+$/, "");
+    if (collapsed === "" || collapsed === "/") {
+        throw new Error("Fragment path cannot be the site root.");
+    }
+    if (collapsed === "/_fragments" || collapsed.startsWith("/_fragments/")) {
+        return collapsed;
+    }
+    return `/_fragments${collapsed}`;
+}
+function absoluteArtifactUrl(baseUrl, path) {
+    return `${baseUrl.replace(/\/$/, "")}${normalizeArtifactPath(path)}`;
+}
+function absoluteUrl(baseUrl, path, trailingSlash = "always") {
+    return `${baseUrl.replace(/\/$/, "")}${normalizePath(path, trailingSlash)}`;
+}
+function chunkArray(items, size) {
+    const chunks = [];
+    for (let index = 0; index < items.length; index += size) {
+        chunks.push(items.slice(index, index + size));
+    }
+    return chunks;
+}
+async function writeText(path, contents, options = {}) {
+    if (options.compareExisting !== false) {
+        try {
+            const current = await readFile(path, "utf8");
+            if (current === contents) {
+                return;
+            }
+        }
+        catch (error) {
+            if (!isMissingPath(error)) {
+                throw error;
+            }
+        }
+    }
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, contents);
+}
+async function isMissingFile(path) {
+    try {
+        await readFile(path);
+        return false;
+    }
+    catch (error) {
+        if (isMissingPath(error)) {
+            return true;
+        }
+        throw error;
+    }
+}
+async function writeJson(path, value) {
+    await writeText(path, `${JSON.stringify(value)}\n`);
+}
+async function writeBytes(path, contents, options = {}) {
+    if (options.compareExisting !== false) {
+        try {
+            const current = await readFile(path);
+            if (Buffer.compare(current, contents) === 0) {
+                return;
+            }
+        }
+        catch (error) {
+            if (!isMissingPath(error)) {
+                throw error;
+            }
+        }
+    }
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, contents);
+}
+function artifactContent(content) {
+    if (!isArtifactResponse(content)) {
+        return { body: content, metadata: {} };
+    }
+    return {
+        body: content.body,
+        metadata: artifactMetadata(content),
+    };
+}
+function artifactMetadata(response) {
+    return {
+        ...(response.contentType ? { contentType: response.contentType } : {}),
+        ...(response.status !== undefined ? { status: response.status } : {}),
+        ...(response.headers ? { headers: response.headers } : {}),
+    };
+}
+function isArtifactResponse(content) {
+    return (typeof content === "object" &&
+        content !== null &&
+        !Buffer.isBuffer(content) &&
+        !(content instanceof Uint8Array) &&
+        "body" in content);
+}
+function normalizeArtifactStatus(status) {
+    if (status === undefined) {
+        return 200;
+    }
+    if (!Number.isInteger(status) || status < 100 || status > 599) {
+        throw new Error(`Artifact response status must be an integer from 100 to 599. Received ${status}.`);
+    }
+    return status;
+}
+function normalizeArtifactHeaders(headers = {}) {
+    return Object.fromEntries(Object.entries(headers)
+        .filter(([name]) => name.trim() !== "")
+        .map(([name, value]) => [name.toLowerCase(), String(value)])
+        .sort(([left], [right]) => left.localeCompare(right)));
+}
+function toBuffer(content) {
+    return Buffer.isBuffer(content) ? content : Buffer.from(content);
+}
+async function removeStaleSplitSitemaps(outDir, keepFiles) {
+    const keep = new Set(keepFiles);
+    let entries;
+    try {
+        entries = await readdir(outDir);
+    }
+    catch (error) {
+        if (isMissingPath(error)) {
+            return;
+        }
+        throw error;
+    }
+    await Promise.all(entries
+        .filter((entry) => /^sitemap-\d+\.xml$/.test(entry) && !keep.has(entry))
+        .map((entry) => rm(join(outDir, entry), { force: true })));
+}
+function hashText(value) {
+    return createHash("sha256").update(value).digest().subarray(0, 16).toString("base64url");
+}
+function escapeHtml(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;");
+}
+function escapeAttribute(value) {
+    return escapeHtml(value).replaceAll('"', "&quot;");
+}
+function escapeJavaScriptString(value) {
+    return value.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+}
+function isMissingPath(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}