@t09tanaka/stoneage 0.1.0

package/dist/cli.js

@@ -0,0 +1,3077 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { realpathSync } from "node:fs";
+import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, join, posix, relative, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { loadValidationConfig, notFoundOutputPath, notFoundRouteName, } from "./core.js";
+import { benchmarkExampleSite } from "./example.js";
+import { renderNetlifyHeaders, renderNetlifyRedirects, writeDeployArtifacts, } from "./deploy.js";
+import { auditSvelteKitPublicSurface, emitSvelteKitMigrationStubs } from "./migration.js";
+import { compressPublicOutput } from "./optimize.js";
+import { countConverterUnavailable, optimizeImages, } from "./images.js";
+import { startDevServer } from "./dev.js";
+import { stoneAgeAgentSkill } from "./agent-skill.js";
+const countOptions = new Map([
+    ["--members", "members"],
+    ["--sessions", "sessions"],
+    ["--conversations", "conversations"],
+    ["--bills", "bills"],
+]);
+const benchmarkSizeMetrics = [
+    { name: "totalOutputBytes", read: (report) => readBenchmarkNumber(report, ["totalOutputBytes"]) },
+    { name: "publicOutputBytes", read: (report) => readBenchmarkNumber(report, ["publicOutputBytes"]) },
+    { name: "htmlOutputBytes", read: (report) => readBenchmarkNumber(report, ["htmlOutputBytes"]) },
+    { name: "cssOutputBytes", read: (report) => readBenchmarkNumber(report, ["cssOutputBytes"]) },
+    { name: "jsOutputBytes", read: (report) => readBenchmarkNumber(report, ["jsOutputBytes"]) },
+    { name: "imageOutputBytes", read: (report) => readBenchmarkNumber(report, ["imageOutputBytes"]) },
+    { name: "dataOutputBytes", read: (report) => readBenchmarkNumber(report, ["dataOutputBytes"]) },
+    { name: "averageHtmlBytes", read: (report) => readBenchmarkNumber(report, ["averageHtmlBytes"]) },
+    { name: "p95HtmlBytes", read: (report) => readBenchmarkNumber(report, ["p95HtmlBytes"]) },
+];
+export function parseArgs(args) {
+    const remaining = [...args];
+    let command = "benchmark";
+    if (remaining[0] === "help" ||
+        remaining[0] === "--help" ||
+        remaining[0] === "-h" ||
+        remaining[0] === "benchmark" ||
+        remaining[0] === "validate" ||
+        remaining[0] === "inspect" ||
+        remaining[0] === "plan" ||
+        remaining[0] === "optimize" ||
+        remaining[0] === "optimize-images" ||
+        remaining[0] === "deploy" ||
+        remaining[0] === "dev" ||
+        remaining[0] === "agent-skill" ||
+        remaining[0] === "audit-sveltekit" ||
+        remaining[0] === "build" ||
+        remaining[0] === "test") {
+        const rawCommand = remaining.shift();
+        command = rawCommand === "--help" || rawCommand === "-h"
+            ? "help"
+            : rawCommand;
+    }
+    if (command === "build" || command === "test") {
+        return parseTsxCommand(command, remaining);
+    }
+    const counts = {};
+    let outDir = "example/dist";
+    let trailingSlash;
+    let includePublicDataExports = false;
+    let compareTo;
+    let maxSizeRegressionPercent;
+    let comparisonReportPath;
+    let json = false;
+    let reportPath;
+    let requirePrecompressed = false;
+    let dependency;
+    let routesDir;
+    let paramsDir;
+    let migrationPlan = false;
+    let emitStubsDir;
+    let provider = "netlify";
+    let providerExplicit = false;
+    let cname;
+    let host;
+    let port;
+    let buildCommand;
+    let debounceMs;
+    let printAgentSkill = false;
+    let validationConfigPath;
+    let writeValidationConfigPath;
+    const dependencies = [];
+    const watchPaths = [];
+    const budgets = {};
+    let imageSourceDir;
+    const imageWidths = [];
+    const imageFormats = [];
+    while (remaining.length > 0) {
+        const option = remaining.shift();
+        if (!option) {
+            break;
+        }
+        if (option === "--out-dir") {
+            outDir = readValue(option, remaining);
+            continue;
+        }
+        if (command === "benchmark" && option === "--trailing-slash") {
+            trailingSlash = readTrailingSlash(option, remaining);
+            continue;
+        }
+        if (command === "benchmark" && option === "--public-data-exports") {
+            includePublicDataExports = true;
+            continue;
+        }
+        if (command === "benchmark" && option === "--compare-to") {
+            compareTo = readValue(option, remaining);
+            continue;
+        }
+        if (command === "benchmark" && option === "--max-size-regression-percent") {
+            maxSizeRegressionPercent = readNonNegativeNumber(option, remaining);
+            continue;
+        }
+        if (command === "benchmark" && option === "--comparison-report") {
+            comparisonReportPath = readValue(option, remaining);
+            continue;
+        }
+        if (command === "validate" && option === "--max-html-bytes") {
+            budgets.maxHtmlBytes = readPositiveInteger(option, remaining);
+            continue;
+        }
+        if (command === "validate" && option === "--max-pages") {
+            budgets.maxPages = readPositiveInteger(option, remaining);
+            continue;
+        }
+        if (command === "validate" && option === "--max-artifacts") {
+            budgets.maxArtifacts = readPositiveInteger(option, remaining);
+            continue;
+        }
+        if (command === "validate" && option === "--max-css-bytes") {
+            budgets.maxCssBytes = readPositiveInteger(option, remaining);
+            continue;
+        }
+        if (command === "validate" && option === "--max-js-bytes") {
+            budgets.maxJsBytes = readPositiveInteger(option, remaining);
+            continue;
+        }
+        if (command === "validate" && option === "--max-public-file-bytes") {
+            budgets.maxPublicFileBytes = readPositiveInteger(option, remaining);
+            continue;
+        }
+        if (command === "validate" && option === "--max-total-public-bytes") {
+            budgets.maxTotalPublicBytes = readPositiveInteger(option, remaining);
+            continue;
+        }
+        if (command === "validate" && option === "--max-image-bytes") {
+            budgets.maxImageBytes = readPositiveInteger(option, remaining);
+            continue;
+        }
+        if (command === "validate" && option === "--max-brotli-bytes") {
+            budgets.maxBrotliBytes = readPositiveInteger(option, remaining);
+            continue;
+        }
+        if (command === "validate" && option === "--max-gzip-bytes") {
+            budgets.maxGzipBytes = readPositiveInteger(option, remaining);
+            continue;
+        }
+        if (command === "validate" && option === "--max-dependency-fanout") {
+            budgets.maxDependencyFanout = readPositiveInteger(option, remaining);
+            continue;
+        }
+        if (command === "validate" && option === "--require-precompressed") {
+            requirePrecompressed = true;
+            continue;
+        }
+        if ((command === "deploy" || command === "validate") && option === "--provider") {
+            provider = readDeployProvider(option, remaining);
+            providerExplicit = true;
+            continue;
+        }
+        if (command === "deploy" && option === "--cname") {
+            cname = readValue(option, remaining);
+            continue;
+        }
+        if (command === "dev" && option === "--host") {
+            host = readValue(option, remaining);
+            continue;
+        }
+        if (command === "dev" && option === "--port") {
+            port = readNonNegativeInteger(option, remaining);
+            continue;
+        }
+        if (command === "dev" && option === "--watch") {
+            watchPaths.push(readValue(option, remaining));
+            continue;
+        }
+        if (command === "dev" && option === "--build-command") {
+            buildCommand = readValue(option, remaining);
+            continue;
+        }
+        if (command === "dev" && option === "--debounce-ms") {
+            debounceMs = readNonNegativeInteger(option, remaining);
+            continue;
+        }
+        if (command === "agent-skill" && option === "--print") {
+            printAgentSkill = true;
+            continue;
+        }
+        if ((command === "validate" ||
+            command === "inspect" ||
+            command === "plan" ||
+            command === "audit-sveltekit") &&
+            option === "--json") {
+            json = true;
+            continue;
+        }
+        if ((command === "validate" || command === "audit-sveltekit") && option === "--report") {
+            reportPath = readValue(option, remaining);
+            continue;
+        }
+        if (command === "validate" && option === "--validation-config") {
+            validationConfigPath = readValue(option, remaining);
+            continue;
+        }
+        if (command === "validate" && option === "--write-validation-config") {
+            writeValidationConfigPath = readValue(option, remaining);
+            continue;
+        }
+        if (command === "audit-sveltekit" && option === "--routes-dir") {
+            routesDir = readValue(option, remaining);
+            continue;
+        }
+        if (command === "audit-sveltekit" && option === "--params-dir") {
+            paramsDir = readValue(option, remaining);
+            continue;
+        }
+        if (command === "audit-sveltekit" && option === "--migration-plan") {
+            migrationPlan = true;
+            continue;
+        }
+        if (command === "audit-sveltekit" && option === "--emit-stubs") {
+            emitStubsDir = readValue(option, remaining);
+            migrationPlan = true;
+            continue;
+        }
+        if (command === "inspect" && option === "--dependency") {
+            dependency = readValue(option, remaining);
+            continue;
+        }
+        if (command === "plan" && option === "--dependency") {
+            dependencies.push(readValue(option, remaining));
+            continue;
+        }
+        if (command === "optimize-images" && option === "--source-dir") {
+            imageSourceDir = readValue(option, remaining);
+            continue;
+        }
+        if (command === "optimize-images" && option === "--width") {
+            imageWidths.push(readPositiveInteger(option, remaining));
+            continue;
+        }
+        if (command === "optimize-images" && option === "--format") {
+            imageFormats.push(readImageFormat(option, remaining));
+            continue;
+        }
+        const countKey = countOptions.get(option);
+        if (command === "benchmark" && countKey) {
+            counts[countKey] = readPositiveInteger(option, remaining);
+            continue;
+        }
+        throw new Error(`Unknown option: ${option}`);
+    }
+    if (command === "help") {
+        return { command };
+    }
+    if (command === "benchmark") {
+        if (comparisonReportPath && !compareTo) {
+            throw new Error("--comparison-report requires --compare-to");
+        }
+        return {
+            command,
+            outDir,
+            counts,
+            ...(trailingSlash === undefined ? {} : { trailingSlash }),
+            ...(includePublicDataExports ? { includePublicDataExports } : {}),
+            ...(compareTo ? { compareTo } : {}),
+            ...(maxSizeRegressionPercent === undefined ? {} : { maxSizeRegressionPercent }),
+            ...(comparisonReportPath ? { comparisonReportPath } : {}),
+        };
+    }
+    if (command === "validate") {
+        return {
+            command,
+            outDir,
+            ...(Object.keys(budgets).length > 0 ? { budgets } : {}),
+            ...(requirePrecompressed ? { requirePrecompressed } : {}),
+            ...(validationConfigPath ? { validationConfigPath } : {}),
+            ...(writeValidationConfigPath ? { writeValidationConfigPath } : {}),
+            ...(json ? { json } : {}),
+            ...(reportPath ? { reportPath } : {}),
+            ...(providerExplicit ? { provider } : {}),
+        };
+    }
+    if (command === "deploy") {
+        if (cname !== undefined && provider !== "github-pages") {
+            throw new Error("--cname is only supported with --provider github-pages");
+        }
+        return {
+            command,
+            outDir,
+            provider,
+            ...(cname !== undefined ? { cname } : {}),
+        };
+    }
+    if (command === "dev") {
+        return {
+            command,
+            outDir,
+            ...(host ? { host } : {}),
+            ...(port === undefined ? {} : { port }),
+            ...(watchPaths.length > 0 ? { watchPaths } : {}),
+            ...(buildCommand ? { buildCommand } : {}),
+            ...(debounceMs === undefined ? {} : { debounceMs }),
+        };
+    }
+    if (command === "agent-skill") {
+        if (!printAgentSkill) {
+            throw new Error("Missing required --print for agent-skill");
+        }
+        return {
+            command,
+            print: true,
+        };
+    }
+    if (command === "inspect") {
+        if (!dependency) {
+            throw new Error("Missing required --dependency for inspect");
+        }
+        return {
+            command,
+            outDir,
+            dependency,
+            ...(json ? { json } : {}),
+        };
+    }
+    if (command === "plan") {
+        if (dependencies.length === 0) {
+            throw new Error("Missing required --dependency for plan");
+        }
+        return {
+            command,
+            outDir,
+            dependencies,
+            ...(json ? { json } : {}),
+        };
+    }
+    if (command === "audit-sveltekit") {
+        if (!routesDir) {
+            throw new Error("Missing required --routes-dir for audit-sveltekit");
+        }
+        return {
+            command,
+            routesDir,
+            ...(paramsDir ? { paramsDir } : {}),
+            ...(json ? { json } : {}),
+            ...(migrationPlan ? { migrationPlan } : {}),
+            ...(emitStubsDir ? { emitStubsDir } : {}),
+            ...(reportPath ? { reportPath } : {}),
+        };
+    }
+    if (command === "optimize-images") {
+        if (!imageSourceDir) {
+            throw new Error("Missing required --source-dir for optimize-images");
+        }
+        return {
+            command,
+            outDir,
+            sourceDir: imageSourceDir,
+            widths: imageWidths.length > 0 ? imageWidths : [640, 1280],
+            formats: imageFormats.length > 0 ? imageFormats : ["webp"],
+        };
+    }
+    return { command, outDir };
+}
+function parseTsxCommand(command, remaining) {
+    const positionals = [];
+    let forwardedArgs = [];
+    while (remaining.length > 0) {
+        const arg = remaining.shift();
+        if (arg === undefined) {
+            break;
+        }
+        if (arg === "--") {
+            forwardedArgs = remaining.splice(0);
+            break;
+        }
+        positionals.push(arg);
+    }
+    if (command === "build") {
+        const [entry, ...extraPositionals] = positionals;
+        if (!entry) {
+            throw new Error("Missing required entry for build");
+        }
+        if (extraPositionals.length > 0) {
+            throw new Error(`Unexpected argument for build: ${extraPositionals[0]} (pass extra arguments after --)`);
+        }
+        return { command, entry, forwardedArgs };
+    }
+    return { command, forwardedArgs: [...positionals, ...forwardedArgs] };
+}
+export async function runCli(args = process.argv.slice(2)) {
+    const command = parseArgs(args);
+    if (command.command === "help") {
+        console.log(helpText());
+        return;
+    }
+    if (command.command === "build") {
+        const code = await runWithForcedJsx([command.entry, ...command.forwardedArgs]);
+        if (code !== 0) {
+            process.exitCode = code;
+        }
+        return;
+    }
+    if (command.command === "test") {
+        const code = await runWithForcedJsx(["--test", ...command.forwardedArgs]);
+        if (code !== 0) {
+            process.exitCode = code;
+        }
+        return;
+    }
+    if (command.command === "benchmark") {
+        const metrics = await benchmarkExampleSite({
+            outDir: command.outDir,
+            counts: command.counts,
+            trailingSlash: command.trailingSlash,
+            includePublicDataExports: command.includePublicDataExports,
+        });
+        console.log(`StoneAge benchmark complete`);
+        console.log(`Pages: ${metrics.pageCount}`);
+        console.log(`Full build: ${metrics.fullBuildMs.toFixed(1)}ms`);
+        console.log(`Incremental build: ${metrics.incrementalBuildMs.toFixed(1)}ms`);
+        console.log(`Normalized data snapshots: ${metrics.normalizedDataSnapshots}`);
+        console.log(`Normalized data rewrites: ${metrics.fullBuildNormalizedDataWrites}/${metrics.incrementalBuildNormalizedDataWrites}/${metrics.changedBuildNormalizedDataWrites}`);
+        console.log(`Output: ${metrics.totalOutputBytes} bytes`);
+        console.log(`Public data exports: ${metrics.dataOutputBytes} bytes`);
+        console.log(`Report: ${command.outDir}/.stoneage/benchmark.json`);
+        if (command.compareTo) {
+            const baseline = JSON.parse(await readFile(command.compareTo, "utf8"));
+            const comparison = {
+                ...compareBenchmarkMetrics(metrics, baseline, {
+                    maxSizeRegressionPercent: command.maxSizeRegressionPercent,
+                }),
+                baselinePath: command.compareTo,
+                currentReportPath: join(command.outDir, ".stoneage/benchmark.json"),
+            };
+            if (command.comparisonReportPath) {
+                await writeJson(command.comparisonReportPath, comparison);
+            }
+            console.log(`Benchmark comparison: ${comparison.ok ? "passed" : "failed"}`);
+            for (const regression of comparison.regressions) {
+                console.log(`- ${regression.metric}: ${regression.current} bytes, baseline ${regression.baseline} bytes, +${regression.delta} bytes (${formatRegressionPercent(regression.regressionPercent)}, limit ${regression.limitPercent}%)`);
+            }
+            if (!comparison.ok) {
+                process.exitCode = 1;
+            }
+        }
+        return;
+    }
+    if (command.command === "optimize") {
+        const metrics = await compressPublicOutput(command.outDir);
+        console.log("StoneAge optimization complete");
+        console.log(`Compressed files: ${metrics.filesCompressed}`);
+        console.log(`Original transfer: ${metrics.originalBytes} bytes`);
+        console.log(`Brotli transfer: ${metrics.brotliBytes} bytes`);
+        console.log(`Gzip transfer: ${metrics.gzipBytes} bytes`);
+        return;
+    }
+    if (command.command === "optimize-images") {
+        const sourceDir = resolve(command.sourceDir);
+        let sourceStats;
+        try {
+            sourceStats = await stat(sourceDir);
+        }
+        catch (error) {
+            if (isMissingPath(error)) {
+                throw new Error(`Source directory not found: ${command.sourceDir}`);
+            }
+            throw error;
+        }
+        if (!sourceStats.isDirectory()) {
+            throw new Error(`--source-dir is not a directory: ${command.sourceDir}`);
+        }
+        // Exclude the output directory from the scan so previously generated
+        // variants are not re-ingested as inputs when outDir lives under sourceDir.
+        const images = await collectImageInputs(sourceDir, sourceDir, resolve(command.outDir));
+        const result = await optimizeImages({
+            outDir: command.outDir,
+            images,
+            widths: command.widths,
+            formats: command.formats,
+            skipExisting: true,
+        });
+        const generatedBytes = result.generated.reduce((total, image) => total + image.bytes, 0);
+        const reused = result.skipped.filter((image) => image.reason === "existing-current");
+        console.log("StoneAge image optimization complete");
+        console.log(`Source images: ${images.length}`);
+        console.log(`Generated variants: ${result.generated.length}`);
+        console.log(`Reused variants: ${reused.length}`);
+        console.log(`Generated output: ${generatedBytes} bytes`);
+        const unoptimized = countConverterUnavailable(result);
+        if (unoptimized > 0) {
+            console.warn(`Skipped optimization for ${unoptimized} image${unoptimized === 1 ? "" : "s"} because sharp is unavailable.`);
+            console.warn("Image optimization requires the optional 'sharp' dependency. Install it with: npm install sharp");
+            console.warn("If sharp is already installed, its native binary may not support this platform; reinstall sharp for your OS/CPU.");
+        }
+        return;
+    }
+    if (command.command === "deploy") {
+        const result = await writeDeployArtifacts({
+            outDir: command.outDir,
+            provider: command.provider,
+            ...(command.cname !== undefined ? { cname: command.cname } : {}),
+        });
+        console.log("StoneAge deploy artifacts complete");
+        console.log(`Provider: ${result.provider}`);
+        console.log(`Files: ${result.files.length}`);
+        if (result.provider === "github-pages") {
+            console.log(`Artifacts: ${result.files.length > 0 ? result.files.join(", ") : "none"}`);
+        }
+        else {
+            console.log(`Redirects: ${result.redirects}`);
+            console.log(`Headers: ${result.headers}`);
+        }
+        return;
+    }
+    if (command.command === "dev") {
+        const server = await startDevServer({
+            outDir: command.outDir,
+            host: command.host,
+            port: command.port,
+            watchPaths: command.watchPaths ?? ["."],
+            buildCommand: command.buildCommand,
+            debounceMs: command.debounceMs,
+        });
+        console.log(`StoneAge dev server: ${server.url}`);
+        console.log(`Output: ${command.outDir}`);
+        if (command.buildCommand) {
+            console.log(`Build command: ${command.buildCommand}`);
+        }
+        return new Promise((resolve) => {
+            const close = async () => {
+                await server.close();
+                resolve();
+            };
+            process.once("SIGINT", close);
+            process.once("SIGTERM", close);
+        });
+    }
+    if (command.command === "agent-skill") {
+        console.log(stoneAgeAgentSkill);
+        return;
+    }
+    if (command.command === "audit-sveltekit") {
+        const report = await auditSvelteKitPublicSurface({
+            routesDir: command.routesDir,
+            paramsDir: command.paramsDir,
+            migrationPlan: command.migrationPlan || Boolean(command.emitStubsDir),
+        });
+        if (command.emitStubsDir) {
+            if (!report.migrationPlan) {
+                throw new Error("Missing migration plan for --emit-stubs");
+            }
+            await emitSvelteKitMigrationStubs(report.migrationPlan, command.emitStubsDir);
+        }
+        if (command.reportPath) {
+            await writeJson(command.reportPath, report);
+        }
+        if (command.json) {
+            console.log(JSON.stringify(report, null, 2));
+            return;
+        }
+        console.log("StoneAge SvelteKit audit complete");
+        console.log(`Pages: ${report.summary.pages}`);
+        console.log(`Endpoints: ${report.summary.endpoints}`);
+        console.log(`Dynamic routes: ${report.summary.dynamicRoutes}`);
+        console.log(`Warnings: ${report.summary.warnings}`);
+        if (command.emitStubsDir) {
+            console.log(`Migration stubs: ${command.emitStubsDir}`);
+        }
+        console.log("Endpoint kinds:");
+        for (const [kind, count] of Object.entries(report.summary.endpointKinds)) {
+            console.log(`- ${kind}: ${count}`);
+        }
+        for (const warning of report.warnings.slice(0, 10)) {
+            console.log(`- ${warning.code}: ${warning.message}`);
+        }
+        return;
+    }
+    if (command.command === "inspect") {
+        const summary = await inspectDependency(command.outDir, command.dependency);
+        if (command.json) {
+            console.log(JSON.stringify(summary, null, 2));
+            return;
+        }
+        console.log(`Dependency: ${summary.dependency}`);
+        console.log(`Pages: ${summary.pageCount}`);
+        for (const page of summary.pages) {
+            console.log(`- page ${page.route} ${page.path} (${page.outputPath})`);
+        }
+        console.log(`Artifacts: ${summary.artifactCount}`);
+        for (const artifact of summary.artifacts) {
+            console.log(`- artifact ${artifact.route} ${artifact.path} (${artifact.outputPath})`);
+        }
+        return;
+    }
+    if (command.command === "plan") {
+        const summary = await planDependencyRebuilds(command.outDir, command.dependencies);
+        if (command.json) {
+            console.log(JSON.stringify(summary, null, 2));
+            return;
+        }
+        console.log(`Dependencies: ${summary.dependencies.length}`);
+        for (const dependency of summary.dependencies) {
+            console.log(`- ${dependency}`);
+        }
+        console.log(`Outputs: ${summary.outputCount}`);
+        console.log(`Pages: ${summary.pageCount}`);
+        console.log(`Artifacts: ${summary.artifactCount}`);
+        for (const output of summary.outputs) {
+            const dependencies = Object.keys(output.dependencies).join(", ");
+            console.log(`- ${output.kind} ${output.path} (${output.outputPath}) [${dependencies}]`);
+        }
+        return;
+    }
+    const configOptions = command.validationConfigPath
+        ? await readValidationOptionsConfig(command.validationConfigPath)
+        : {};
+    const budgets = {
+        ...(configOptions.budgets ?? {}),
+        ...(command.budgets ?? {}),
+    };
+    const provider = command.provider ?? configOptions.provider;
+    const summary = await validateOutput(command.outDir, {
+        ...(Object.keys(budgets).length > 0 ? { budgets } : {}),
+        requirePrecompressed: command.requirePrecompressed ?? configOptions.requirePrecompressed,
+        ...(command.validationConfigPath ? { configPath: command.validationConfigPath } : {}),
+        ...(configOptions.configHash ? { configHash: configOptions.configHash } : {}),
+        ...(provider !== undefined ? { provider } : {}),
+    });
+    if (command.reportPath) {
+        await writeJson(command.reportPath, summary);
+    }
+    if (command.writeValidationConfigPath) {
+        await writeJson(command.writeValidationConfigPath, validationConfigFromSummary(summary));
+    }
+    if (command.json) {
+        console.log(JSON.stringify(summary, null, 2));
+        if (!summary.ok) {
+            process.exitCode = 1;
+        }
+        return;
+    }
+    console.log("StoneAge validation complete");
+    console.log(`Pages: ${summary.pageCount}`);
+    console.log(`Artifacts: ${summary.artifactCount}`);
+    console.log(`Public assets: ${summary.publicAssetCount}`);
+    console.log(`Public assets copied: ${summary.publicAssetsCopied}`);
+    console.log(`Public assets skipped: ${summary.publicAssetsSkipped}`);
+    console.log(`Stale outputs removed: ${summary.staleOutputsRemoved}`);
+    console.log(`Public files: ${summary.publicFileCount}`);
+    console.log(`Public file bytes: ${summary.publicFileBytes}`);
+    if (summary.transferSidecars.compressibleFiles > 0) {
+        console.log(`Compressible files: ${summary.transferSidecars.compressibleFiles}`);
+        console.log(`Brotli sidecars: ${summary.transferSidecars.brotliFiles}`);
+        console.log(`Gzip sidecars: ${summary.transferSidecars.gzipFiles}`);
+        console.log(`Missing Brotli sidecars: ${summary.transferSidecars.missingBrotliFiles.length}`);
+        console.log(`Missing Gzip sidecars: ${summary.transferSidecars.missingGzipFiles.length}`);
+        console.log(`Brotli sidecar bytes: ${summary.transferSidecars.brotliBytes}`);
+        console.log(`Gzip sidecar bytes: ${summary.transferSidecars.gzipBytes}`);
+    }
+    console.log(`Stylesheet assets: ${summary.stylesheetAssetCount}`);
+    console.log(`Stylesheet bytes: ${summary.stylesheetAssetBytes}`);
+    console.log(`Public CSS files: ${summary.publicCssFileCount}`);
+    console.log(`Public CSS bytes: ${summary.publicCssFileBytes}`);
+    console.log(`Public JavaScript files: ${summary.publicJavaScriptFileCount}`);
+    console.log(`Public JavaScript bytes: ${summary.publicJavaScriptFileBytes}`);
+    console.log(`Image assets: ${summary.imageAssetCount}`);
+    console.log(`Image bytes: ${summary.imageAssetBytes}`);
+    console.log(`Route families written: ${Object.keys(summary.routeWrites).length}`);
+    console.log(`Artifact families written: ${Object.keys(summary.artifactWrites).length}`);
+    console.log(`Missing links: ${summary.missingLinks.length}`);
+    console.log(`Sitemap URLs: ${summary.sitemapUrls}`);
+    console.log(`Sitemap files: ${summary.sitemapFiles.length}`);
+    console.log(`Sitemap file issues: ${summary.sitemapFileIssues.length}`);
+    console.log(`Sitemap drift: ${summary.sitemapDrift.missing.length} missing, ${summary.sitemapDrift.extra.length} extra`);
+    console.log(`Validation issues: ${summary.validationIssues.length}`);
+    console.log(`Budget failures: ${summary.budgetFailures.length}`);
+    console.log(`Public data exports: ${summary.publicDataExports}`);
+    if (summary.dataFlow) {
+        console.log(`Data-flow dependencies: ${summary.dataFlow.dependencyCount}`);
+        console.log(`Data-flow outputs: ${summary.dataFlow.outputs.total}`);
+    }
+    console.log(`Public data export issues: ${summary.publicDataExportIssues.length}`);
+    console.log(`Headers manifest issues: ${summary.headersManifestIssues.length}`);
+    console.log(`Redirect manifest issues: ${summary.redirectManifestIssues.length}`);
+    console.log(`Robots.txt issues: ${summary.robotsTxtIssues.length}`);
+    console.log(`Deploy artifact issues: ${summary.deployArtifactIssues.length}`);
+    console.log(`HTML metadata issues: ${summary.htmlMetadataIssues.length}`);
+    console.log(`Hydration payload issues: ${summary.hydrationPayloadIssues.length}`);
+    console.log(`Missing asset references: ${summary.missingAssetReferences.length}`);
+    console.log(`Prefetch reference issues: ${summary.prefetchReferenceIssues.length}`);
+    console.log(`Manifest output issues: ${summary.manifestOutputIssues.length}`);
+    console.log(`Orphan HTML issues: ${summary.orphanHtmlIssues.length}`);
+    console.log("Largest HTML:");
+    for (const item of summary.largestHtml.slice(0, 10)) {
+        console.log(`- ${item.path} (${item.bytes} bytes)`);
+    }
+    console.log("Largest artifacts:");
+    for (const item of summary.largestArtifacts.slice(0, 10)) {
+        console.log(`- ${item.path} (${item.bytes} bytes)`);
+    }
+    console.log("Largest public files:");
+    for (const item of summary.largestPublicFiles.slice(0, 10)) {
+        console.log(`- ${item.path} (${item.bytes} bytes, ${item.type})`);
+    }
+    console.log("Public file types:");
+    for (const item of summary.publicFileTypes.slice(0, 10)) {
+        console.log(`- ${item.type}: ${item.files} files, ${item.bytes} bytes`);
+    }
+    console.log("Largest stylesheets:");
+    for (const item of summary.largestStylesheets.slice(0, 10)) {
+        console.log(`- ${item.path} (${item.bytes} bytes, ${item.references} references)`);
+    }
+    console.log("Largest public CSS files:");
+    for (const item of summary.largestPublicCssFiles.slice(0, 10)) {
+        console.log(`- ${item.path} (${item.bytes} bytes, ${item.type})`);
+    }
+    console.log("Largest public JavaScript files:");
+    for (const item of summary.largestPublicJavaScriptFiles.slice(0, 10)) {
+        console.log(`- ${item.path} (${item.bytes} bytes, ${item.type})`);
+    }
+    console.log("Largest images:");
+    for (const item of summary.largestImages.slice(0, 10)) {
+        console.log(`- ${item.path} (${item.bytes} bytes, ${item.type})`);
+    }
+    for (const issue of summary.validationIssues.slice(0, 10)) {
+        console.log(`- ${issue.code}: ${issue.message}`);
+    }
+    if (!summary.ok) {
+        process.exitCode = 1;
+    }
+}
+async function writeJson(path, value) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+const validationConfigKeys = ["budgets", "requiredMetadata", "requirePrecompressed", "provider"];
+async function readValidationOptionsConfig(path) {
+    const raw = await readFile(path, "utf8");
+    const value = JSON.parse(raw);
+    if (!isRecord(value)) {
+        throw new Error(`Validation config must be a JSON object: ${path}`);
+    }
+    rejectUnknownKeys(value, validationConfigKeys, "Validation config", path);
+    const validation = await loadValidationConfig(path);
+    const requirePrecompressed = value.requirePrecompressed;
+    if (requirePrecompressed !== undefined && typeof requirePrecompressed !== "boolean") {
+        throw new Error(`Validation config requirePrecompressed must be a boolean: ${path}`);
+    }
+    const provider = value.provider;
+    if (provider !== undefined && provider !== "netlify" && provider !== "github-pages") {
+        throw new Error(`Validation config provider must be netlify or github-pages: ${path}`);
+    }
+    return {
+        configHash: createHash("sha256").update(raw).digest("hex"),
+        ...(validation.budgets ? { budgets: validation.budgets } : {}),
+        ...(requirePrecompressed === undefined ? {} : { requirePrecompressed }),
+        ...(provider === undefined ? {} : { provider }),
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function rejectUnknownKeys(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 validationConfigFromSummary(summary) {
+    const budgets = {};
+    const largestHtml = summary.largestHtml[0];
+    const largestPublicFile = summary.largestPublicFiles[0];
+    const largestCssFile = summary.largestPublicCssFiles[0];
+    const largestJavaScriptFile = summary.largestPublicJavaScriptFiles[0];
+    const largestDependencyFanout = summary.dataFlow?.largestDependencyFanout[0];
+    if (summary.pageCount > 0) {
+        budgets.maxPages = summary.pageCount;
+    }
+    if (summary.artifactCount > 0) {
+        budgets.maxArtifacts = summary.artifactCount;
+    }
+    const routeFamilyBudgets = positiveIntegerEntries(summary.routeFamilies);
+    if (Object.keys(routeFamilyBudgets).length > 0) {
+        budgets.maxRouteFamilyPages = routeFamilyBudgets;
+    }
+    const artifactFamilyBudgets = positiveIntegerEntries(summary.artifactFamilies);
+    if (Object.keys(artifactFamilyBudgets).length > 0) {
+        budgets.maxArtifactFamilyOutputs = artifactFamilyBudgets;
+    }
+    if (largestHtml && largestHtml.bytes > 0) {
+        budgets.maxHtmlBytes = largestHtml.bytes;
+    }
+    if (largestPublicFile && largestPublicFile.bytes > 0) {
+        budgets.maxPublicFileBytes = largestPublicFile.bytes;
+    }
+    if (largestCssFile && largestCssFile.bytes > 0) {
+        budgets.maxCssBytes = largestCssFile.bytes;
+    }
+    if (largestJavaScriptFile && largestJavaScriptFile.bytes > 0) {
+        budgets.maxJsBytes = largestJavaScriptFile.bytes;
+    }
+    if (summary.publicFileBytes > 0) {
+        budgets.maxTotalPublicBytes = summary.publicFileBytes;
+    }
+    if (summary.imageAssetBytes > 0) {
+        budgets.maxImageBytes = summary.imageAssetBytes;
+    }
+    if (largestDependencyFanout && largestDependencyFanout.outputs > 0) {
+        budgets.maxDependencyFanout = largestDependencyFanout.outputs;
+    }
+    return {
+        ...(summary.validationOptions?.provider !== undefined
+            ? { provider: summary.validationOptions.provider }
+            : {}),
+        ...(Object.keys(budgets).length > 0 ? { budgets } : {}),
+    };
+}
+function validationOptionsSummary(options) {
+    const summary = {};
+    if (options.configPath) {
+        summary.configPath = options.configPath;
+    }
+    if (options.configHash) {
+        summary.configHash = options.configHash;
+    }
+    if (options.budgets && Object.keys(options.budgets).length > 0) {
+        summary.budgets = options.budgets;
+    }
+    if (options.requirePrecompressed !== undefined) {
+        summary.requirePrecompressed = options.requirePrecompressed;
+    }
+    if (options.provider !== undefined) {
+        summary.provider = options.provider;
+    }
+    return Object.keys(summary).length > 0 ? { validationOptions: summary } : {};
+}
+function positiveIntegerEntries(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, count]) => Number.isInteger(count) && count > 0));
+}
+export function compareBenchmarkMetrics(current, baseline, options = {}) {
+    const maxSizeRegressionPercent = options.maxSizeRegressionPercent ?? 0;
+    const regressions = benchmarkSizeMetrics.flatMap((metric) => {
+        const baselineValue = metric.read(baseline);
+        const currentValue = metric.read(current);
+        if (currentValue <= baselineValue) {
+            return [];
+        }
+        const delta = currentValue - baselineValue;
+        const regressionPercent = baselineValue === 0 ? null : (delta / baselineValue) * 100;
+        const failed = regressionPercent === null || regressionPercent > maxSizeRegressionPercent;
+        return failed
+            ? [
+                {
+                    metric: metric.name,
+                    baseline: baselineValue,
+                    current: currentValue,
+                    delta,
+                    regressionPercent,
+                    limitPercent: maxSizeRegressionPercent,
+                },
+            ]
+            : [];
+    });
+    return {
+        ok: regressions.length === 0,
+        maxSizeRegressionPercent,
+        comparedMetrics: benchmarkSizeMetrics.length,
+        regressions,
+    };
+}
+function readBenchmarkNumber(report, path) {
+    let value = report;
+    for (const key of path) {
+        if (!isRecord(value)) {
+            throw new Error(`Benchmark report missing numeric metric: ${path.join(".")}`);
+        }
+        value = value[key];
+    }
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+        throw new Error(`Benchmark report missing numeric metric: ${path.join(".")}`);
+    }
+    return value;
+}
+function formatRegressionPercent(value) {
+    return value === null ? "new bytes" : `+${value.toFixed(1)}%`;
+}
+export async function inspectDependency(outDir, dependency) {
+    const manifest = await readRequiredGeneratedManifest(outDir);
+    const pages = manifest.pages
+        .flatMap((page) => {
+        const hash = page.dependencies[dependency];
+        return hash === undefined
+            ? []
+            : [
+                {
+                    route: page.route,
+                    path: page.path,
+                    outputPath: page.outputPath,
+                    hash,
+                },
+            ];
+    })
+        .sort(compareInspectEntries);
+    const artifacts = manifest.artifacts
+        .flatMap((artifact) => {
+        const hash = artifact.dependencies[dependency];
+        return hash === undefined
+            ? []
+            : [
+                {
+                    route: artifact.route,
+                    path: artifact.path,
+                    outputPath: artifact.outputPath,
+                    hash,
+                },
+            ];
+    })
+        .sort(compareInspectEntries);
+    return {
+        dependency,
+        pageCount: pages.length,
+        artifactCount: artifacts.length,
+        pages,
+        artifacts,
+    };
+}
+export async function planDependencyRebuilds(outDir, dependencies) {
+    const requestedDependencies = uniqueStrings(dependencies);
+    const manifest = await readRequiredGeneratedManifest(outDir);
+    const outputs = [
+        ...manifest.artifacts.flatMap((artifact) => planOutputFor("artifact", artifact, requestedDependencies)),
+        ...manifest.pages.flatMap((page) => planOutputFor("page", page, requestedDependencies)),
+    ].sort(comparePlanOutputs);
+    const uniqueOutputs = Array.from(new Map(outputs.map((output) => [output.outputPath, output])).values());
+    return {
+        dependencies: requestedDependencies,
+        outputCount: uniqueOutputs.length,
+        pageCount: uniqueOutputs.filter((output) => output.kind === "page").length,
+        artifactCount: uniqueOutputs.filter((output) => output.kind === "artifact").length,
+        outputs: uniqueOutputs,
+    };
+}
+function compareInspectEntries(left, right) {
+    return left.path.localeCompare(right.path) || left.route.localeCompare(right.route);
+}
+function comparePlanOutputs(left, right) {
+    return (left.kind.localeCompare(right.kind) ||
+        left.path.localeCompare(right.path) ||
+        left.route.localeCompare(right.route) ||
+        left.outputPath.localeCompare(right.outputPath));
+}
+export async function validateOutput(outDir, options = {}) {
+    const report = JSON.parse(await readFile(join(outDir, ".stoneage/report.json"), "utf8"));
+    const sitemap = await readOptionalText(join(outDir, "sitemap.xml"));
+    const manifest = await readGeneratedManifest(join(outDir, ".stoneage/manifest.json"));
+    const dataFlow = (await readSplitDataFlowReport(outDir)) ??
+        (await readDataFlowReport(join(outDir, ".stoneage/data-flow.json"))) ??
+        (manifest ? dataFlowReportFromManifest(manifest) : undefined);
+    const sitemapResult = sitemap
+        ? await readSitemapPaths(outDir, sitemap)
+        : { paths: [], files: [], issues: [] };
+    const sitemapDrift = manifest ? compareSitemapPaths(manifest.pages, sitemapResult.paths) : { missing: [], extra: [] };
+    const budgetFailures = [
+        ...outputCountBudgetFailures("pages", ".", report.pageCount, options.budgets?.maxPages),
+        ...outputCountBudgetFailures("artifacts", ".", report.artifactCount ?? 0, options.budgets?.maxArtifacts),
+        ...routeFamilyPageBudgetFailures(report.routeFamilies ?? {}, options.budgets?.maxRouteFamilyPages),
+        ...artifactFamilyOutputBudgetFailures(report.artifactFamilies ?? {}, options.budgets?.maxArtifactFamilyOutputs),
+        ...htmlBudgetFailures(report.largestHtml, options.budgets?.maxHtmlBytes),
+        ...(await assetBudgetFailures(outDir, "css", options.budgets?.maxCssBytes)),
+        ...(await assetBudgetFailures(outDir, "js", options.budgets?.maxJsBytes)),
+    ];
+    const publicDataExportTargets = await collectPublicDataExportTargets(outDir, manifest);
+    const publicDataExportIssues = await validatePublicDataExports(outDir, publicDataExportTargets);
+    const headersManifestIssues = manifest
+        ? await validateHeadersManifest(outDir, manifest, report.publicAssets ?? [])
+        : [];
+    const redirectManifestIssues = manifest ? await validateRedirectManifest(outDir, manifest) : [];
+    const robotsTxtIssues = await validateRobotsTxt(outDir);
+    const deployArtifactIssues = await validateDeployArtifacts(outDir, options.provider);
+    const htmlMetadataIssues = manifest ? await validateHtmlMetadata(outDir, manifest) : [];
+    const hydrationPayloadIssues = await validateHydrationPayloads(outDir);
+    const missingAssetReferences = await validateHtmlAssetReferences(outDir);
+    const publicFileInventory = await collectPublicFileInventory(outDir);
+    budgetFailures.push(...publicFileBudgetFailures(publicFileInventory, options.budgets?.maxPublicFileBytes), ...totalPublicBudgetFailures(publicFileInventory, options.budgets?.maxTotalPublicBytes), ...dependencyFanoutBudgetFailures(dataFlow, options.budgets?.maxDependencyFanout));
+    const shouldCheckTransferSidecars = shouldCheckPrecompressedSidecars(options);
+    const transferSidecars = shouldCheckTransferSidecars
+        ? await collectTransferSidecarMetrics(outDir)
+        : emptyTransferSidecarSummary();
+    budgetFailures.push(...compressedTransferBudgetFailures(transferSidecars, "brotli", options.budgets?.maxBrotliBytes), ...compressedTransferBudgetFailures(transferSidecars, "gzip", options.budgets?.maxGzipBytes));
+    const stylesheetAssets = await collectStylesheetAssetMetrics(outDir);
+    const publicCssFiles = collectPublicFileTypeMetrics(publicFileInventory.files, "css");
+    const publicJavaScriptFiles = collectPublicFileTypeMetrics(publicFileInventory.files, "js");
+    const imageAssets = collectImageAssetMetrics(publicFileInventory.files);
+    budgetFailures.push(...imageBudgetFailures(imageAssets, options.budgets?.maxImageBytes));
+    const prefetchReferenceIssues = manifest
+        ? await validateHtmlPrefetchReferences(outDir, manifest)
+        : [];
+    const manifestOutputIssues = manifest ? await validateManifestOutputs(outDir, manifest) : [];
+    const orphanHtmlIssues = manifest ? await validateOrphanHtmlOutputs(outDir, manifest) : [];
+    const dataFlowIssues = dataFlowReportIssues(dataFlow, options.budgets);
+    const validationIssues = dedupeIssues([
+        ...(report.validation?.issues ?? []),
+        ...missingManifestIssues(manifest),
+        ...sitemapDrift.missing.map((path) => ({
+            code: "sitemap.missing_url",
+            path,
+            message: `${path} is indexable but missing from sitemap.xml.`,
+        })),
+        ...sitemapDrift.extra.map((path) => ({
+            code: "sitemap.extra_url",
+            path,
+            message: `${path} is present in sitemap.xml but not in the generated manifest.`,
+        })),
+        ...budgetFailures.map((failure) => ({
+            code: budgetFailureCode(failure),
+            path: failure.path,
+            bytes: failure.bytes,
+            ...(failure.dependency ? { dependency: failure.dependency } : {}),
+            ...(failure.outputs !== undefined ? { outputs: failure.outputs } : {}),
+            limit: failure.limit,
+            message: budgetFailureMessage(failure),
+        })),
+        ...publicDataExportIssues,
+        ...headersManifestIssues,
+        ...redirectManifestIssues,
+        ...robotsTxtIssues,
+        ...deployArtifactIssues,
+        ...htmlMetadataIssues,
+        ...hydrationPayloadIssues,
+        ...missingAssetReferences,
+        ...prefetchReferenceIssues,
+        ...manifestOutputIssues,
+        ...orphanHtmlIssues,
+        ...precompressionIssues(transferSidecars, options.requirePrecompressed),
+        ...dataFlowIssues,
+        ...sitemapResult.issues,
+    ]);
+    const publicDataExports = publicDataExportTargets.length;
+    return {
+        ok: report.missingLinks.length === 0 && validationIssues.length === 0,
+        pageCount: report.pageCount,
+        artifactCount: report.artifactCount ?? 0,
+        publicAssetCount: report.publicAssets?.length ?? 0,
+        publicAssetsCopied: report.publicAssetsCopied ?? 0,
+        publicAssetsSkipped: report.publicAssetsSkipped ?? 0,
+        staleOutputsRemoved: report.staleOutputsRemoved ?? 0,
+        publicFileCount: publicFileInventory.files.length,
+        publicFileBytes: publicFileInventory.totalBytes,
+        transferSidecars,
+        stylesheetAssetCount: stylesheetAssets.items.length,
+        stylesheetAssetBytes: stylesheetAssets.totalBytes,
+        publicCssFileCount: publicCssFiles.items.length,
+        publicCssFileBytes: publicCssFiles.totalBytes,
+        publicJavaScriptFileCount: publicJavaScriptFiles.items.length,
+        publicJavaScriptFileBytes: publicJavaScriptFiles.totalBytes,
+        imageAssetCount: imageAssets.items.length,
+        imageAssetBytes: imageAssets.totalBytes,
+        missingLinks: report.missingLinks,
+        sitemapUrls: sitemapResult.paths.length,
+        sitemapFiles: report.sitemapFiles ?? sitemapResult.files,
+        sitemapFileIssues: sitemapResult.issues,
+        publicDataExports,
+        publicDataExportIssues,
+        headersManifestIssues,
+        redirectManifestIssues,
+        robotsTxtIssues,
+        deployArtifactIssues,
+        htmlMetadataIssues,
+        hydrationPayloadIssues,
+        missingAssetReferences,
+        prefetchReferenceIssues,
+        manifestOutputIssues,
+        orphanHtmlIssues,
+        largestHtml: report.largestHtml,
+        largestArtifacts: report.largestArtifacts ?? [],
+        largestPublicFiles: publicFileInventory.files.slice(0, 20),
+        publicFileTypes: publicFileInventory.types,
+        largestStylesheets: stylesheetAssets.items.slice(0, 20),
+        largestPublicCssFiles: publicCssFiles.items.slice(0, 20),
+        largestPublicJavaScriptFiles: publicJavaScriptFiles.items.slice(0, 20),
+        largestImages: imageAssets.items.slice(0, 20),
+        routeFamilies: report.routeFamilies,
+        routeWrites: report.routeWrites ?? {},
+        artifactFamilies: report.artifactFamilies ?? {},
+        artifactWrites: report.artifactWrites ?? {},
+        ...(dataFlow ? { dataFlow: summarizeDataFlow(dataFlow) } : {}),
+        ...validationOptionsSummary(options),
+        validationIssues,
+        budgetFailures,
+        sitemapDrift,
+    };
+}
+async function readRequiredGeneratedManifest(outDir) {
+    const manifest = await readGeneratedManifest(join(outDir, ".stoneage/manifest.json"));
+    if (!manifest) {
+        throw new Error(`Missing or unreadable generated manifest in ${outDir}.`);
+    }
+    return manifest;
+}
+function missingManifestIssues(manifest) {
+    return manifest
+        ? []
+        : [
+            {
+                code: "manifest.missing",
+                path: ".stoneage/manifest.json",
+                message: ".stoneage/manifest.json is missing. Run a StoneAge build before validating publish output.",
+            },
+        ];
+}
+async function readGeneratedManifest(path) {
+    const raw = await readOptionalText(path);
+    if (!raw) {
+        return undefined;
+    }
+    const parsed = JSON.parse(raw);
+    if (parsed.version === 1 && Array.isArray(parsed.pages)) {
+        return {
+            pages: parsed.pages.map((page) => ({
+                route: page.route ?? "",
+                path: page.path,
+                outputPath: page.outputPath ?? outputPathForManifestPage(page.route ?? "", page.path),
+                dependencies: page.dependencies ?? {},
+                bytes: page.htmlBytes ?? 0,
+                sitemap: page.sitemap !== false,
+            })),
+            artifacts: (parsed.artifacts ?? []).map((artifact) => ({
+                route: artifact.route ?? "",
+                path: artifact.path,
+                outputPath: artifact.outputPath ?? outputPathForArtifactPath(artifact.path),
+                dependencies: artifact.dependencies ?? {},
+                bytes: artifact.bytes ?? 0,
+            })),
+        };
+    }
+    if ((parsed.version === 6 || parsed.version === 7 || parsed.version === 8) &&
+        Array.isArray(parsed.pages) &&
+        Array.isArray(parsed.strings)) {
+        return {
+            pages: parsed.pages.map(([route, path, dependencies, , bytes, sitemap]) => {
+                const pagePath = parsed.strings[path] ?? "";
+                const pageRoute = parsed.strings[route] ?? "";
+                return {
+                    route: pageRoute,
+                    path: pagePath,
+                    outputPath: outputPathForManifestPage(pageRoute, pagePath),
+                    dependencies: readDependencies(parsed.strings, dependencies),
+                    bytes,
+                    sitemap: sitemap !== 0,
+                };
+            }),
+            artifacts: (parsed.artifacts ?? []).map(([route, path, dependencies, bytes, metadata]) => {
+                const artifactPath = parsed.strings[path] ?? "";
+                return {
+                    route: parsed.strings[route] ?? "",
+                    path: artifactPath,
+                    outputPath: outputPathForArtifactPath(artifactPath),
+                    dependencies: readDependencies(parsed.strings, dependencies),
+                    bytes,
+                    ...(metadata?.contentType ? { contentType: metadata.contentType } : {}),
+                    ...(metadata?.status !== undefined ? { status: metadata.status } : {}),
+                    ...(metadata?.headers ? { headers: metadata.headers } : {}),
+                };
+            }),
+        };
+    }
+    return undefined;
+}
+async function readDataFlowReport(path) {
+    const raw = await readOptionalText(path);
+    if (!raw) {
+        return undefined;
+    }
+    const parsed = JSON.parse(raw);
+    return parsed.version === 1 ? parsed : undefined;
+}
+async function readSplitDataFlowReport(outDir) {
+    const [summary, dependencies] = await Promise.all([
+        readDataFlowSummaryReport(join(outDir, ".stoneage/data-flow-summary.json")),
+        readDataFlowDependenciesReport(join(outDir, ".stoneage/data-flow-dependencies.json")),
+    ]);
+    if (!summary || !dependencies) {
+        return undefined;
+    }
+    return {
+        version: 1,
+        outputs: summary.outputs,
+        routeFamilies: summary.routeFamilies,
+        artifactFamilies: summary.artifactFamilies,
+        dependencies: dependencies.dependencies,
+    };
+}
+async function readDataFlowSummaryReport(path) {
+    const raw = await readOptionalText(path);
+    if (!raw) {
+        return undefined;
+    }
+    const parsed = JSON.parse(raw);
+    return parsed.version === 1 ? parsed : undefined;
+}
+async function readDataFlowDependenciesReport(path) {
+    const raw = await readOptionalText(path);
+    if (!raw) {
+        return undefined;
+    }
+    const parsed = JSON.parse(raw);
+    return parsed.version === 1 ? parsed : undefined;
+}
+function summarizeDataFlow(dataFlow) {
+    return {
+        outputs: dataFlow.outputs,
+        dependencyCount: dataFlow.dependencies.length,
+        largestDependencyFanout: dataFlow.dependencies.slice(0, 10),
+        routeFamilies: dataFlow.routeFamilies,
+        artifactFamilies: dataFlow.artifactFamilies,
+    };
+}
+function dataFlowReportFromManifest(manifest) {
+    return {
+        version: 1,
+        outputs: {
+            pages: manifest.pages.length,
+            artifacts: manifest.artifacts.length,
+            total: manifest.pages.length + manifest.artifacts.length,
+        },
+        routeFamilies: dataFlowFamiliesFromOutputs(manifest.pages, (page) => page.route, (page) => page.bytes),
+        artifactFamilies: dataFlowFamiliesFromOutputs(manifest.artifacts, (artifact) => artifact.route, (artifact) => artifact.bytes),
+        dependencies: dataFlowDependenciesFromManifest(manifest),
+    };
+}
+function dataFlowFamiliesFromOutputs(outputs, routeOf, bytesOf) {
+    const summaries = new Map();
+    for (const output of outputs) {
+        const name = routeOf(output);
+        const summary = summaries.get(name) ??
+            {
+                name,
+                outputs: 0,
+                written: 0,
+                skipped: 0,
+                bytes: 0,
+            };
+        summary.outputs += 1;
+        summary.skipped += 1;
+        summary.bytes += bytesOf(output);
+        summaries.set(name, summary);
+    }
+    return [...summaries.values()].sort((left, right) => left.name.localeCompare(right.name));
+}
+function dataFlowDependenciesFromManifest(manifest) {
+    const summaries = new Map();
+    for (const page of manifest.pages) {
+        for (const key of visibleDependencyKeys(page.dependencies)) {
+            const summary = dataFlowDependencySummaryFor(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 visibleDependencyKeys(artifact.dependencies)) {
+            const summary = dataFlowDependencySummaryFor(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 visibleDependencyKeys(dependencies) {
+    return Object.keys(dependencies).filter((key) => !key.startsWith("\0stoneage:")).sort();
+}
+function dataFlowDependencySummaryFor(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 readDependencies(strings, dependencies) {
+    return Object.fromEntries(dependencies.map(([key, hash]) => [strings[key] ?? "", hash]));
+}
+function planOutputFor(kind, output, requestedDependencies) {
+    const matchingDependencies = Object.fromEntries(requestedDependencies.flatMap((dependency) => {
+        const hash = output.dependencies[dependency];
+        return hash === undefined ? [] : [[dependency, hash]];
+    }));
+    return Object.keys(matchingDependencies).length === 0
+        ? []
+        : [
+            {
+                kind,
+                route: output.route,
+                path: output.path,
+                outputPath: output.outputPath,
+                dependencies: matchingDependencies,
+            },
+        ];
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values));
+}
+async function validateManifestOutputs(outDir, manifest) {
+    const outputs = [
+        ...manifest.pages.map((page) => ({
+            kind: "HTML",
+            path: page.outputPath,
+            expectedBytes: page.bytes,
+        })),
+        ...manifest.artifacts.map((artifact) => ({
+            kind: "artifact",
+            path: artifact.outputPath,
+            expectedBytes: artifact.bytes,
+        })),
+    ];
+    const issues = [];
+    issues.push(...duplicateManifestOutputIssues(outputs));
+    for (const output of outputs) {
+        let outputStat;
+        try {
+            outputStat = await stat(join(outDir, output.path));
+        }
+        catch (error) {
+            if (isMissingPath(error)) {
+                issues.push({
+                    code: "output.missing",
+                    path: output.path,
+                    message: `${output.kind} output ${output.path} is listed in the manifest but missing from disk.`,
+                });
+                continue;
+            }
+            throw error;
+        }
+        if (outputStat.size !== output.expectedBytes) {
+            issues.push({
+                code: "output.size_mismatch",
+                path: output.path,
+                bytes: outputStat.size,
+                limit: output.expectedBytes,
+                message: `${output.kind} output ${output.path} is ${outputStat.size} bytes, expected ${output.expectedBytes} bytes from the manifest.`,
+            });
+        }
+    }
+    return issues;
+}
+function duplicateManifestOutputIssues(outputs) {
+    const firstByPath = new Map();
+    const duplicatePaths = new Set();
+    for (const output of outputs) {
+        if (firstByPath.has(output.path)) {
+            duplicatePaths.add(output.path);
+            continue;
+        }
+        firstByPath.set(output.path, output);
+    }
+    return [...duplicatePaths].sort().map((path) => ({
+        code: "output.duplicate_path",
+        path,
+        message: `Manifest lists multiple generated outputs for ${path}.`,
+    }));
+}
+async function validateOrphanHtmlOutputs(outDir, manifest) {
+    const manifestHtml = new Set([...manifest.pages, ...manifest.artifacts]
+        .map((output) => output.outputPath)
+        .filter((path) => path.endsWith(".html")));
+    const files = await listPublicFiles(outDir);
+    return files
+        .filter((file) => file.endsWith(".html") && !manifestHtml.has(file))
+        .map((file) => ({
+        code: "output.orphan_html",
+        path: file,
+        message: `${file} is an HTML file in the public output directory but is not listed in the manifest.`,
+    }));
+}
+async function validateHeadersManifest(outDir, manifest, publicAssets = []) {
+    const raw = await readOptionalText(join(outDir, "headers.json"));
+    if (!raw) {
+        return [];
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        return [
+            {
+                code: "headers.invalid_json",
+                path: "headers.json",
+                message: `headers.json is not valid JSON: ${errorMessage(error)}.`,
+            },
+        ];
+    }
+    if (!isHeadersManifest(parsed)) {
+        return [
+            {
+                code: "headers.invalid_shape",
+                path: "headers.json",
+                message: "headers.json must contain a headers array with path and headers entries.",
+            },
+        ];
+    }
+    const issues = [];
+    const expected = expectedHeadersManifestEntries(manifest);
+    const managedPublicAssets = new Set(publicAssets);
+    const actual = new Map();
+    const duplicatePaths = new Set();
+    for (const entry of parsed.headers) {
+        if (actual.has(entry.path)) {
+            duplicatePaths.add(entry.path);
+            continue;
+        }
+        actual.set(entry.path, entry.headers);
+    }
+    for (const path of [...duplicatePaths].sort()) {
+        issues.push({
+            code: "headers.duplicate_path",
+            path,
+            message: `headers.json lists ${path} more than once.`,
+        });
+    }
+    for (const path of [...actual.keys()].sort()) {
+        if (!expected.has(path) && !managedPublicAssets.has(path)) {
+            issues.push({
+                code: "headers.unexpected_path",
+                path,
+                message: `headers.json includes ${path}, but no generated artifact or managed public asset declares response headers for that path.`,
+            });
+        }
+    }
+    for (const [path, expectedHeaders] of [...expected.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+        const actualHeaders = actual.get(path);
+        if (!actualHeaders) {
+            issues.push({
+                code: "headers.missing_path",
+                path,
+                message: `headers.json is missing response headers for generated artifact ${path}.`,
+            });
+            continue;
+        }
+        if (stableHeaderJson(actualHeaders) !== stableHeaderJson(expectedHeaders)) {
+            issues.push({
+                code: "headers.header_mismatch",
+                path,
+                message: `headers.json headers for ${path} do not match generated artifact response metadata.`,
+            });
+        }
+    }
+    return issues;
+}
+function expectedHeadersManifestEntries(manifest) {
+    const entries = new Map();
+    for (const artifact of manifest.artifacts) {
+        const headers = {
+            ...(artifact.contentType ? { "content-type": artifact.contentType } : {}),
+            ...(artifact.headers ?? {}),
+        };
+        if (Object.keys(headers).length > 0) {
+            entries.set(artifact.path, headers);
+        }
+    }
+    return entries;
+}
+function isHeadersManifest(value) {
+    if (!value || typeof value !== "object" || !("headers" in value)) {
+        return false;
+    }
+    const headers = value.headers;
+    return Array.isArray(headers) && headers.every(isHeadersManifestEntry);
+}
+function isHeadersManifestEntry(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const entry = value;
+    return (typeof entry.path === "string" &&
+        Boolean(entry.path) &&
+        isStringRecord(entry.headers));
+}
+function isStringRecord(value) {
+    return (value !== null &&
+        typeof value === "object" &&
+        !Array.isArray(value) &&
+        Object.values(value).every((item) => typeof item === "string"));
+}
+function stableHeaderJson(headers) {
+    return JSON.stringify(Object.fromEntries(Object.entries(headers).sort(([left], [right]) => left.localeCompare(right))));
+}
+async function validateRedirectManifest(outDir, manifest) {
+    const raw = await readOptionalText(join(outDir, "redirects.json"));
+    if (!raw) {
+        return [];
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        return [
+            {
+                code: "redirects.invalid_json",
+                path: "redirects.json",
+                message: `redirects.json is not valid JSON: ${errorMessage(error)}.`,
+            },
+        ];
+    }
+    if (!isRedirectsManifest(parsed)) {
+        return [
+            {
+                code: "redirects.invalid_shape",
+                path: "redirects.json",
+                message: "redirects.json must contain a redirects array with from, to, and status entries.",
+            },
+        ];
+    }
+    const issues = [];
+    const generatedTargets = new Set([
+        ...manifest.pages.map((page) => page.path),
+        ...manifest.artifacts.map((artifact) => artifact.path),
+    ]);
+    const fromPaths = new Set();
+    const duplicateFromPaths = new Set();
+    for (const redirect of parsed.redirects) {
+        if (fromPaths.has(redirect.from)) {
+            duplicateFromPaths.add(redirect.from);
+        }
+        fromPaths.add(redirect.from);
+        if (!isRedirectStatus(redirect.status)) {
+            issues.push({
+                code: "redirects.invalid_status",
+                path: redirect.from,
+                message: `${redirect.from} has unsupported redirect status ${redirect.status}.`,
+            });
+        }
+        if (isLocalPublicPath(redirect.from) && generatedTargets.has(redirect.from)) {
+            issues.push({
+                code: "redirects.from_collides_output",
+                path: redirect.from,
+                message: `${redirect.from} is both a redirect source and a generated output path.`,
+            });
+        }
+        const localTarget = localRedirectTarget(redirect.to);
+        if (localTarget && !generatedTargets.has(localTarget)) {
+            issues.push({
+                code: "redirects.missing_target",
+                path: redirect.from,
+                message: `${redirect.from} redirects to missing local target ${localTarget}.`,
+            });
+        }
+    }
+    for (const path of [...duplicateFromPaths].sort()) {
+        issues.push({
+            code: "redirects.duplicate_from",
+            path,
+            message: `redirects.json lists redirect source ${path} more than once.`,
+        });
+    }
+    return issues;
+}
+function isRedirectsManifest(value) {
+    if (!value || typeof value !== "object" || !("redirects" in value)) {
+        return false;
+    }
+    const redirects = value.redirects;
+    return Array.isArray(redirects) && redirects.every(isRedirectManifestEntry);
+}
+function isRedirectManifestEntry(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const entry = value;
+    return (typeof entry.from === "string" &&
+        Boolean(entry.from) &&
+        typeof entry.to === "string" &&
+        Boolean(entry.to) &&
+        typeof entry.status === "number");
+}
+function isRedirectStatus(status) {
+    return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
+}
+function localRedirectTarget(value) {
+    if (!isLocalPublicPath(value)) {
+        return undefined;
+    }
+    const [path] = value.split(/[?#]/, 1);
+    return path || undefined;
+}
+function isLocalPublicPath(value) {
+    return value.startsWith("/") && !value.startsWith("//");
+}
+async function validateRobotsTxt(outDir) {
+    const raw = await readOptionalText(join(outDir, "robots.txt"));
+    if (!raw) {
+        return [];
+    }
+    const publicFiles = new Set(await listPublicFiles(outDir));
+    const issues = [];
+    for (const sitemap of readRobotsSitemaps(raw)) {
+        let parsed;
+        try {
+            parsed = new URL(sitemap);
+        }
+        catch {
+            issues.push({
+                code: "robots.invalid_sitemap_url",
+                path: "robots.txt",
+                message: `robots.txt contains invalid Sitemap URL ${JSON.stringify(sitemap)}.`,
+            });
+            continue;
+        }
+        const outputPath = parsed.pathname.replace(/^\/+/, "");
+        if (isGeneratedSitemapFile(outputPath) && !publicFiles.has(outputPath)) {
+            issues.push({
+                code: "robots.missing_sitemap",
+                path: outputPath,
+                message: `robots.txt references missing sitemap file ${outputPath}.`,
+            });
+        }
+    }
+    return issues;
+}
+function readRobotsSitemaps(robots) {
+    return robots
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .flatMap((line) => {
+        const match = line.match(/^sitemap:\s*(\S.*)$/i);
+        return match ? [match[1]] : [];
+    });
+}
+function isGeneratedSitemapFile(path) {
+    return path === "sitemap.xml" || /^sitemap-\d+\.xml$/.test(path);
+}
+async function validateDeployArtifacts(outDir, provider = "netlify") {
+    // GitHub Pages relies on redirect HTML stubs and CNAME, not Netlify
+    // _redirects/_headers, so skip the Netlify-specific artifact checks.
+    if (provider === "github-pages") {
+        return [];
+    }
+    const issues = [];
+    const redirectsArtifact = await readOptionalText(join(outDir, "_redirects"));
+    const headersArtifact = await readOptionalText(join(outDir, "_headers"));
+    const expectedRedirects = await expectedNetlifyRedirects(outDir);
+    const expectedHeaders = await expectedNetlifyHeaders(outDir);
+    if (redirectsArtifact === undefined) {
+        if (expectedRedirects.manifestExists && expectedRedirects.content !== undefined) {
+            issues.push({
+                code: "deploy.netlify_redirects_missing",
+                path: "_redirects",
+                message: "_redirects is missing for redirects.json. Run deploy --provider netlify.",
+            });
+        }
+    }
+    else {
+        if (expectedRedirects.content !== undefined && redirectsArtifact !== expectedRedirects.content) {
+            issues.push({
+                code: "deploy.netlify_redirects_mismatch",
+                path: "_redirects",
+                message: "_redirects does not match redirects.json. Run deploy --provider netlify again.",
+            });
+        }
+    }
+    if (headersArtifact === undefined) {
+        if (expectedHeaders.manifestExists && expectedHeaders.content !== undefined) {
+            issues.push({
+                code: "deploy.netlify_headers_missing",
+                path: "_headers",
+                message: "_headers is missing for headers.json. Run deploy --provider netlify.",
+            });
+        }
+    }
+    else {
+        if (expectedHeaders.content !== undefined && headersArtifact !== expectedHeaders.content) {
+            issues.push({
+                code: "deploy.netlify_headers_mismatch",
+                path: "_headers",
+                message: "_headers does not match headers.json. Run deploy --provider netlify again.",
+            });
+        }
+    }
+    return issues;
+}
+async function expectedNetlifyRedirects(outDir) {
+    const raw = await readOptionalText(join(outDir, "redirects.json"));
+    if (raw === undefined) {
+        return { manifestExists: false };
+    }
+    if (!raw) {
+        return { manifestExists: true, content: "" };
+    }
+    const parsed = parseOptionalJson(raw);
+    if (!isRedirectsManifest(parsed)) {
+        return { manifestExists: true };
+    }
+    return {
+        manifestExists: true,
+        content: parsed.redirects.length > 0 ? renderNetlifyRedirects(parsed.redirects) : "",
+    };
+}
+async function expectedNetlifyHeaders(outDir) {
+    const raw = await readOptionalText(join(outDir, "headers.json"));
+    if (raw === undefined) {
+        return { manifestExists: false };
+    }
+    if (!raw) {
+        return { manifestExists: true, content: "" };
+    }
+    const parsed = parseOptionalJson(raw);
+    if (!isHeadersManifest(parsed)) {
+        return { manifestExists: true };
+    }
+    return {
+        manifestExists: true,
+        content: parsed.headers.length > 0 ? renderNetlifyHeaders(parsed.headers) : "",
+    };
+}
+function parseOptionalJson(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+function outputPathForPagePath(path) {
+    if (path === "/") {
+        return "index.html";
+    }
+    if (path.endsWith("/")) {
+        return posix.join(path.slice(1), "index.html");
+    }
+    return `${path.replace(/^\/+/, "")}.html`;
+}
+function outputPathForManifestPage(route, path) {
+    // The synthetic not-found page is written to a fixed file at the output root,
+    // so its output path is not derived from the page-path output rules.
+    return route === notFoundRouteName ? notFoundOutputPath : outputPathForPagePath(path);
+}
+function outputPathForArtifactPath(path) {
+    return path.replace(/^\/+/, "");
+}
+async function readSitemapPaths(outDir, sitemap) {
+    if (!sitemap.includes("<sitemapindex")) {
+        const locs = extractSitemapLocPaths(sitemap);
+        return {
+            paths: locs.paths,
+            files: ["sitemap.xml"],
+            issues: [...locs.issues, ...duplicateSitemapUrlIssues(locs.paths)],
+        };
+    }
+    const files = ["sitemap.xml"];
+    const paths = [];
+    const indexLocs = extractSitemapLocPaths(sitemap);
+    const issues = [...indexLocs.issues];
+    for (const sitemapPath of indexLocs.paths) {
+        const file = sitemapPath.replace(/^\//, "");
+        files.push(file);
+        const child = await readOptionalText(join(outDir, file));
+        if (child) {
+            const childLocs = extractSitemapLocPaths(child);
+            paths.push(...childLocs.paths);
+            issues.push(...childLocs.issues);
+            continue;
+        }
+        issues.push({
+            code: "sitemap.missing_file",
+            path: file,
+            message: `Sitemap index references missing child sitemap ${file}.`,
+        });
+    }
+    return {
+        paths: paths.sort(),
+        files,
+        issues: [...issues, ...duplicateSitemapUrlIssues(paths)],
+    };
+}
+function extractSitemapLocPaths(sitemap) {
+    const paths = [];
+    const issues = [];
+    const locPattern = /<loc>([^<]+)<\/loc>/g;
+    let match;
+    while ((match = locPattern.exec(sitemap)) !== null) {
+        const loc = match[1];
+        let path = loc;
+        try {
+            path = new URL(loc, "https://stoneage.local").pathname;
+        }
+        catch {
+            // Preserve the original value in the path field when even fallback URL parsing fails.
+        }
+        try {
+            const absolute = new URL(loc);
+            paths.push(absolute.pathname);
+        }
+        catch {
+            paths.push(path);
+            issues.push({
+                code: "sitemap.invalid_url",
+                path,
+                message: `Sitemap loc ${JSON.stringify(loc)} must be an absolute URL.`,
+            });
+        }
+    }
+    return {
+        paths: paths.sort(),
+        issues,
+    };
+}
+function duplicateSitemapUrlIssues(paths) {
+    const counts = new Map();
+    for (const path of paths) {
+        counts.set(path, (counts.get(path) ?? 0) + 1);
+    }
+    return [...counts.entries()]
+        .filter(([, count]) => count > 1)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([path, count]) => ({
+        code: "sitemap.duplicate_url",
+        path,
+        message: `${path} appears ${count} times across generated sitemap files.`,
+    }));
+}
+function compareSitemapPaths(manifestPages, sitemapPaths) {
+    const expected = new Set(manifestPages.filter((page) => page.sitemap).map((page) => page.path));
+    const actual = new Set(sitemapPaths);
+    return {
+        missing: [...expected].filter((path) => !actual.has(path)).sort(),
+        extra: [...actual].filter((path) => !expected.has(path)).sort(),
+    };
+}
+function htmlBudgetFailures(largestHtml, limit) {
+    if (limit === undefined) {
+        return [];
+    }
+    return largestHtml
+        .filter((page) => page.bytes > limit)
+        .map((page) => ({
+        kind: "html",
+        path: page.path,
+        bytes: page.bytes,
+        limit,
+    }));
+}
+function outputCountBudgetFailures(kind, path, count, limit) {
+    if (limit === undefined || count <= limit) {
+        return [];
+    }
+    return [
+        {
+            kind,
+            path,
+            bytes: count,
+            limit,
+        },
+    ];
+}
+function routeFamilyPageBudgetFailures(routeFamilies, limits) {
+    if (!limits) {
+        return [];
+    }
+    return Object.entries(limits)
+        .flatMap(([route, limit]) => {
+        const count = routeFamilies[route] ?? 0;
+        return count > limit
+            ? [
+                {
+                    kind: "route-family-pages",
+                    path: route,
+                    bytes: count,
+                    limit,
+                },
+            ]
+            : [];
+    })
+        .sort((left, right) => right.bytes - left.bytes || left.path.localeCompare(right.path));
+}
+function artifactFamilyOutputBudgetFailures(artifactFamilies, limits) {
+    if (!limits) {
+        return [];
+    }
+    return Object.entries(limits)
+        .flatMap(([family, limit]) => {
+        const count = artifactFamilies[family] ?? 0;
+        return count > limit
+            ? [
+                {
+                    kind: "artifact-family-outputs",
+                    path: family,
+                    bytes: count,
+                    limit,
+                },
+            ]
+            : [];
+    })
+        .sort((left, right) => right.bytes - left.bytes || left.path.localeCompare(right.path));
+}
+async function assetBudgetFailures(outDir, kind, limit) {
+    if (limit === undefined) {
+        return [];
+    }
+    const files = await listPublicFiles(outDir);
+    const failures = [];
+    for (const file of files) {
+        if (!file.endsWith(`.${kind}`)) {
+            continue;
+        }
+        const fileStat = await stat(join(outDir, file));
+        if (fileStat.size > limit) {
+            failures.push({
+                kind,
+                path: file,
+                bytes: fileStat.size,
+                limit,
+            });
+        }
+    }
+    return failures;
+}
+function publicFileBudgetFailures(inventory, limit) {
+    if (limit === undefined) {
+        return [];
+    }
+    return inventory.files
+        .filter((file) => file.bytes > limit)
+        .map((file) => ({
+        kind: "public-file",
+        path: file.path,
+        bytes: file.bytes,
+        limit,
+    }));
+}
+function totalPublicBudgetFailures(inventory, limit) {
+    if (limit === undefined || inventory.totalBytes <= limit) {
+        return [];
+    }
+    return [
+        {
+            kind: "total-public",
+            path: ".",
+            bytes: inventory.totalBytes,
+            limit,
+        },
+    ];
+}
+function imageBudgetFailures(imageAssets, limit) {
+    if (limit === undefined || imageAssets.totalBytes <= limit) {
+        return [];
+    }
+    return [
+        {
+            kind: "image-total",
+            path: ".",
+            bytes: imageAssets.totalBytes,
+            limit,
+        },
+    ];
+}
+function compressedTransferBudgetFailures(transferSidecars, kind, limit) {
+    const bytes = kind === "brotli" ? transferSidecars.brotliBytes : transferSidecars.gzipBytes;
+    if (limit === undefined || bytes <= limit) {
+        return [];
+    }
+    return [
+        {
+            kind,
+            path: ".",
+            bytes,
+            limit,
+        },
+    ];
+}
+function dependencyFanoutBudgetFailures(dataFlow, limit) {
+    if (!dataFlow || limit === undefined) {
+        return [];
+    }
+    return dataFlow.dependencies
+        .filter((dependency) => dependency.outputs > limit)
+        .map((dependency) => ({
+        kind: "dependency-fanout",
+        path: dependency.key,
+        bytes: dependency.outputs,
+        dependency: dependency.key,
+        outputs: dependency.outputs,
+        limit,
+    }));
+}
+function dataFlowReportIssues(dataFlow, budgets) {
+    if (dataFlow || budgets?.maxDependencyFanout === undefined) {
+        return [];
+    }
+    return [
+        {
+            code: "data_flow.missing",
+            message: "Missing split data-flow reports (.stoneage/data-flow-summary.json and .stoneage/data-flow-dependencies.json) or legacy .stoneage/data-flow.json for dependency fanout budget validation.",
+        },
+    ];
+}
+function precompressionIssues(transferSidecars, required) {
+    if (!required) {
+        return [];
+    }
+    return [
+        ...transferSidecars.missingBrotliFiles.map((path) => ({
+            code: "precompression.brotli_missing",
+            path,
+            message: `${path} is missing a Brotli sidecar. Run optimize before publishing.`,
+        })),
+        ...transferSidecars.missingGzipFiles.map((path) => ({
+            code: "precompression.gzip_missing",
+            path,
+            message: `${path} is missing a Gzip sidecar. Run optimize before publishing.`,
+        })),
+    ];
+}
+function budgetFailureCode(failure) {
+    if (failure.kind === "dependency-fanout") {
+        return "budget.dependency_fanout";
+    }
+    if (failure.kind === "route-family-pages") {
+        return "budget.route_family_pages";
+    }
+    if (failure.kind === "artifact-family-outputs") {
+        return "budget.artifact_family_outputs";
+    }
+    if (failure.kind === "public-file") {
+        return "budget.public_file";
+    }
+    if (failure.kind === "total-public") {
+        return "budget.total_public";
+    }
+    if (failure.kind === "image-total") {
+        return "budget.image_total";
+    }
+    return `budget.${failure.kind}`;
+}
+function budgetFailureMessage(failure) {
+    if (failure.kind === "dependency-fanout") {
+        return `${failure.dependency} fans out to ${failure.outputs} outputs, exceeding the ${failure.limit} output dependency fanout budget.`;
+    }
+    if (failure.kind === "total-public") {
+        return `Public output is ${failure.bytes} bytes, exceeding the ${failure.limit} byte total public output budget.`;
+    }
+    if (failure.kind === "public-file") {
+        return `${failure.path} is ${failure.bytes} bytes, exceeding the ${failure.limit} byte public file budget.`;
+    }
+    if (failure.kind === "pages") {
+        return `Generated page count is ${failure.bytes}, exceeding the ${failure.limit} page budget.`;
+    }
+    if (failure.kind === "artifacts") {
+        return `Generated artifact count is ${failure.bytes}, exceeding the ${failure.limit} artifact budget.`;
+    }
+    if (failure.kind === "route-family-pages") {
+        return `${failure.path} generated ${failure.bytes} pages, exceeding the ${failure.limit} page route family budget.`;
+    }
+    if (failure.kind === "artifact-family-outputs") {
+        return `${failure.path} generated ${failure.bytes} artifacts, exceeding the ${failure.limit} artifact family output budget.`;
+    }
+    if (failure.kind === "image-total") {
+        return `Public images are ${failure.bytes} bytes, exceeding the ${failure.limit} byte image asset budget.`;
+    }
+    if (failure.kind === "brotli") {
+        return `Brotli sidecars are ${failure.bytes} bytes, exceeding the ${failure.limit} byte Brotli transfer budget.`;
+    }
+    if (failure.kind === "gzip") {
+        return `Gzip sidecars are ${failure.bytes} bytes, exceeding the ${failure.limit} byte Gzip transfer budget.`;
+    }
+    return `${failure.path} is ${failure.bytes} bytes, exceeding the ${failure.limit} byte ${failure.kind.toUpperCase()} budget.`;
+}
+async function validateHtmlAssetReferences(outDir) {
+    const files = await listPublicFiles(outDir);
+    const publicFiles = new Set(files);
+    const issues = [];
+    for (const file of files.filter((item) => item.endsWith(".html"))) {
+        const html = await readFile(join(outDir, file), "utf8");
+        for (const reference of extractHtmlAssetReferences(html, file)) {
+            if (!publicFiles.has(reference.outputPath)) {
+                issues.push({
+                    code: "asset.missing",
+                    path: file,
+                    message: `${file} references missing asset ${reference.href}.`,
+                });
+            }
+        }
+    }
+    return issues;
+}
+async function collectPublicFileInventory(outDir) {
+    const publicFiles = await listPublicFiles(outDir);
+    const files = [];
+    const types = new Map();
+    for (const path of publicFiles.filter((file) => !isPrecompressedSidecarPath(file))) {
+        const fileStat = await stat(join(outDir, path));
+        const type = publicFileType(path);
+        const bytes = fileStat.size;
+        files.push({ path, bytes, type });
+        const summary = types.get(type) ?? { type, files: 0, bytes: 0 };
+        summary.files += 1;
+        summary.bytes += bytes;
+        types.set(type, summary);
+    }
+    files.sort((left, right) => right.bytes - left.bytes || left.path.localeCompare(right.path));
+    const typeSummaries = [...types.values()].sort((left, right) => right.bytes - left.bytes || left.type.localeCompare(right.type));
+    return {
+        totalBytes: files.reduce((total, file) => total + file.bytes, 0),
+        files,
+        types: typeSummaries,
+    };
+}
+function collectImageAssetMetrics(files) {
+    const items = files.filter((file) => isImagePublicFileType(file.type));
+    return {
+        totalBytes: items.reduce((total, file) => total + file.bytes, 0),
+        items,
+    };
+}
+function collectPublicFileTypeMetrics(files, type) {
+    const items = files.filter((file) => file.type === type);
+    return {
+        totalBytes: items.reduce((total, file) => total + file.bytes, 0),
+        items,
+    };
+}
+async function collectTransferSidecarMetrics(outDir) {
+    const publicFiles = await listPublicFiles(outDir);
+    const publicFileSet = new Set(publicFiles);
+    const compressibleFiles = publicFiles
+        .filter((file) => !isPrecompressedSidecarPath(file) && isCompressiblePublicPath(file))
+        .sort();
+    const missingBrotliFiles = [];
+    const missingGzipFiles = [];
+    let originalBytes = 0;
+    let brotliBytes = 0;
+    let gzipBytes = 0;
+    let brotliFiles = 0;
+    let gzipFiles = 0;
+    for (const file of compressibleFiles) {
+        originalBytes += (await stat(join(outDir, file))).size;
+        const brotliPath = `${file}.br`;
+        const gzipPath = `${file}.gz`;
+        if (publicFileSet.has(brotliPath)) {
+            brotliFiles += 1;
+            brotliBytes += (await stat(join(outDir, brotliPath))).size;
+        }
+        else {
+            missingBrotliFiles.push(file);
+        }
+        if (publicFileSet.has(gzipPath)) {
+            gzipFiles += 1;
+            gzipBytes += (await stat(join(outDir, gzipPath))).size;
+        }
+        else {
+            missingGzipFiles.push(file);
+        }
+    }
+    return {
+        compressibleFiles: compressibleFiles.length,
+        brotliFiles,
+        gzipFiles,
+        originalBytes,
+        brotliBytes,
+        gzipBytes,
+        missingBrotliFiles,
+        missingGzipFiles,
+    };
+}
+function shouldCheckPrecompressedSidecars(options) {
+    return Boolean(options.requirePrecompressed ||
+        options.budgets?.maxBrotliBytes !== undefined ||
+        options.budgets?.maxGzipBytes !== undefined);
+}
+function emptyTransferSidecarSummary() {
+    return {
+        compressibleFiles: 0,
+        brotliFiles: 0,
+        gzipFiles: 0,
+        originalBytes: 0,
+        brotliBytes: 0,
+        gzipBytes: 0,
+        missingBrotliFiles: [],
+        missingGzipFiles: [],
+    };
+}
+async function collectStylesheetAssetMetrics(outDir) {
+    const files = await listPublicFiles(outDir);
+    const references = new Map();
+    for (const file of files.filter((item) => item.endsWith(".html"))) {
+        const html = await readFile(join(outDir, file), "utf8");
+        for (const outputPath of extractHtmlStylesheetOutputPaths(html, file)) {
+            references.set(outputPath, (references.get(outputPath) ?? 0) + 1);
+        }
+    }
+    const items = [];
+    for (const [path, referenceCount] of references) {
+        if (!isSafePublicOutputPath(path)) {
+            continue;
+        }
+        let fileStat;
+        try {
+            fileStat = await stat(join(outDir, path));
+        }
+        catch (error) {
+            if (isMissingPath(error)) {
+                continue;
+            }
+            throw error;
+        }
+        items.push({
+            path,
+            bytes: fileStat.size,
+            references: referenceCount,
+        });
+    }
+    items.sort((left, right) => right.bytes - left.bytes || left.path.localeCompare(right.path));
+    return {
+        totalBytes: items.reduce((total, item) => total + item.bytes, 0),
+        items,
+    };
+}
+async function validateHtmlPrefetchReferences(outDir, manifest) {
+    const files = await listPublicFiles(outDir);
+    const existingTargets = new Set([
+        ...manifest.pages.map((page) => page.path),
+        ...manifest.artifacts.map((artifact) => artifact.path),
+    ]);
+    const issues = [];
+    for (const file of files.filter((item) => item.endsWith(".html"))) {
+        const html = await readFile(join(outDir, file), "utf8");
+        for (const target of extractHtmlPrefetchTargets(html)) {
+            if (!existingTargets.has(target)) {
+                issues.push({
+                    code: "prefetch.missing_target",
+                    path: file,
+                    message: `${file} prefetches missing target ${target}.`,
+                });
+            }
+        }
+    }
+    return issues;
+}
+async function validateHydrationPayloads(outDir) {
+    const files = await listPublicFiles(outDir);
+    const issues = [];
+    for (const file of files.filter((item) => item.endsWith(".html"))) {
+        const html = await readFile(join(outDir, file), "utf8");
+        if (referencesRuntimeDataPayload(html)) {
+            issues.push({
+                code: "html.runtime_data_payload",
+                path: file,
+                message: `${file} references a runtime data payload such as __data.json. Generated pages should be readable as plain HTML.`,
+            });
+        }
+        if (containsHydrationPayload(html)) {
+            issues.push({
+                code: "html.hydration_payload",
+                path: file,
+                message: `${file} contains framework hydration payload markers. Move runtime page data into build-time rendering or explicit artifacts.`,
+            });
+        }
+    }
+    return issues;
+}
+async function validateHtmlMetadata(outDir, manifest) {
+    const issues = [];
+    const canonicalPages = new Map();
+    for (const page of manifest.pages) {
+        const file = page.outputPath;
+        let html;
+        try {
+            html = await readFile(join(outDir, file), "utf8");
+        }
+        catch (error) {
+            if (isMissingPath(error)) {
+                continue;
+            }
+            throw error;
+        }
+        if (!hasNonEmptyTitle(html)) {
+            issues.push({
+                code: "html.missing_title",
+                path: file,
+                message: `${file} is missing a non-empty <title> tag.`,
+            });
+        }
+        if (!hasMetaNameContent(html, "description")) {
+            issues.push({
+                code: "html.missing_description",
+                path: file,
+                message: `${file} is missing a non-empty meta description.`,
+            });
+        }
+        const canonicalHref = linkRelHref(html, "canonical");
+        if (!canonicalHref) {
+            issues.push({
+                code: "html.missing_canonical",
+                path: file,
+                message: `${file} is missing a canonical link.`,
+            });
+            continue;
+        }
+        let canonicalUrl;
+        try {
+            canonicalUrl = new URL(canonicalHref);
+        }
+        catch {
+            issues.push({
+                code: "html.canonical_not_absolute",
+                path: file,
+                message: `${file} canonical URL must be absolute: ${canonicalHref}.`,
+            });
+            continue;
+        }
+        if (canonicalUrl.protocol !== "https:" && canonicalUrl.protocol !== "http:") {
+            issues.push({
+                code: "html.canonical_not_absolute",
+                path: file,
+                message: `${file} canonical URL must use http or https: ${canonicalHref}.`,
+            });
+            continue;
+        }
+        const canonicalPath = canonicalUrl.pathname;
+        canonicalPages.set(canonicalUrl.href, [...(canonicalPages.get(canonicalUrl.href) ?? []), file]);
+        if (canonicalPath !== page.path) {
+            issues.push({
+                code: "html.canonical_path_mismatch",
+                path: file,
+                message: `${file} canonical path ${canonicalPath} does not match manifest path ${page.path}.`,
+            });
+        }
+    }
+    for (const [canonical, files] of canonicalPages) {
+        if (files.length < 2) {
+            continue;
+        }
+        for (const file of files) {
+            issues.push({
+                code: "html.canonical_duplicate",
+                path: file,
+                message: `${file} shares canonical URL ${canonical} with ${files.length - 1} other page(s).`,
+            });
+        }
+    }
+    return issues;
+}
+function referencesRuntimeDataPayload(html) {
+    const tagPattern = /<(a|link|script|img|source|iframe|form)\b([^>]*)>/gi;
+    let match;
+    while ((match = tagPattern.exec(html)) !== null) {
+        const attrs = parseTagAttributes(match[2]);
+        for (const attr of ["href", "src", "action"]) {
+            if (isRuntimeDataPayloadPath(attrs.get(attr))) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function isRuntimeDataPayloadPath(value) {
+    if (!value) {
+        return false;
+    }
+    const [path] = value.split(/[?#]/, 1);
+    return /(?:^|\/)__data\.json$/.test(path ?? "");
+}
+function containsHydrationPayload(html) {
+    const tagPattern = /<([a-z][a-z0-9:-]*)\b([^>]*)>/gi;
+    let match;
+    while ((match = tagPattern.exec(html)) !== null) {
+        const tag = match[1].toLowerCase();
+        const attrs = parseTagAttributes(match[2]);
+        const type = attrs.get("type")?.toLowerCase() ?? "";
+        if (attrs.has("data-sveltekit-fetched") ||
+            attrs.has("data-sveltekit-hydrate") ||
+            attrs.has("data-next-page") ||
+            attrs.has("data-nuxt-data")) {
+            return true;
+        }
+        if (tag === "script" &&
+            (attrs.get("id") === "__NEXT_DATA__" ||
+                attrs.get("id") === "__NUXT_DATA__" ||
+                (type === "application/json" &&
+                    (attrs.has("data-sveltekit-fetched") || attrs.has("data-sveltekit-hydrate"))))) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasNonEmptyTitle(html) {
+    const match = html.match(/<title\b[^>]*>(.*?)<\/title>/is);
+    return (match?.[1] ?? "").trim() !== "";
+}
+function hasMetaNameContent(html, expectedName) {
+    const tagPattern = /<meta\b([^>]*)>/gi;
+    let match;
+    while ((match = tagPattern.exec(html)) !== null) {
+        const attrs = parseTagAttributes(match[1]);
+        if (attrs.get("name")?.toLowerCase() === expectedName &&
+            (attrs.get("content") ?? "").trim() !== "") {
+            return true;
+        }
+    }
+    return false;
+}
+function linkRelHref(html, expectedRel) {
+    const tagPattern = /<link\b([^>]*)>/gi;
+    let match;
+    while ((match = tagPattern.exec(html)) !== null) {
+        const attrs = parseTagAttributes(match[1]);
+        const relTokens = new Set((attrs.get("rel") ?? "").toLowerCase().split(/\s+/).filter(Boolean));
+        const href = (attrs.get("href") ?? "").trim();
+        if (relTokens.has(expectedRel) && href !== "") {
+            return href;
+        }
+    }
+    return undefined;
+}
+function extractHtmlPrefetchTargets(html) {
+    const targets = new Set();
+    const tagPattern = /<(link|script)\b([^>]*)>/gi;
+    let match;
+    while ((match = tagPattern.exec(html)) !== null) {
+        const tag = match[1].toLowerCase();
+        const attrs = parseTagAttributes(match[2]);
+        if (tag === "link") {
+            const rel = attrs.get("rel")?.toLowerCase() ?? "";
+            const relTokens = new Set(rel.split(/\s+/).filter(Boolean));
+            if (relTokens.has("prefetch")) {
+                const target = localPrefetchTarget(attrs.get("href"));
+                if (target) {
+                    targets.add(target);
+                }
+            }
+            continue;
+        }
+        for (const value of (attrs.get("data-prefetch") ?? "").split(/\s+/).filter(Boolean)) {
+            const target = localPrefetchTarget(value);
+            if (target) {
+                targets.add(target);
+            }
+        }
+    }
+    return [...targets].sort();
+}
+function extractHtmlAssetReferences(html, htmlFile) {
+    const references = [];
+    const tagPattern = /<(link|script|img|source|video|meta)\b([^>]*)>/gi;
+    let match;
+    while ((match = tagPattern.exec(html)) !== null) {
+        const tag = match[1].toLowerCase();
+        const attrs = parseTagAttributes(match[2]);
+        if (tag === "link") {
+            const rel = attrs.get("rel")?.toLowerCase() ?? "";
+            const relTokens = new Set(rel.split(/\s+/).filter(Boolean));
+            const isAssetLink = relTokens.has("stylesheet") ||
+                relTokens.has("icon") ||
+                relTokens.has("apple-touch-icon") ||
+                relTokens.has("manifest") ||
+                relTokens.has("modulepreload") ||
+                relTokens.has("preload");
+            if (isAssetLink) {
+                pushAssetReference(references, htmlFile, attrs.get("href"));
+            }
+            continue;
+        }
+        if (tag === "meta") {
+            if (isSocialImageMeta(attrs)) {
+                pushAssetReference(references, htmlFile, attrs.get("content"));
+            }
+            continue;
+        }
+        if (tag === "script") {
+            pushAssetReference(references, htmlFile, attrs.get("src"));
+            continue;
+        }
+        if (tag === "video") {
+            pushAssetReference(references, htmlFile, attrs.get("poster"));
+            continue;
+        }
+        pushAssetReference(references, htmlFile, attrs.get("src"));
+        for (const candidate of parseSrcset(attrs.get("srcset"))) {
+            pushAssetReference(references, htmlFile, candidate);
+        }
+    }
+    return references;
+}
+function extractHtmlStylesheetOutputPaths(html, htmlFile) {
+    const outputPaths = new Set();
+    const tagPattern = /<link\b([^>]*)>/gi;
+    let match;
+    while ((match = tagPattern.exec(html)) !== null) {
+        const attrs = parseTagAttributes(match[1]);
+        const rel = attrs.get("rel")?.toLowerCase() ?? "";
+        const relTokens = new Set(rel.split(/\s+/).filter(Boolean));
+        if (!relTokens.has("stylesheet")) {
+            continue;
+        }
+        const outputPath = localAssetOutputPath(attrs.get("href"), htmlFile);
+        if (outputPath) {
+            outputPaths.add(outputPath);
+        }
+    }
+    return [...outputPaths];
+}
+function isSocialImageMeta(attrs) {
+    const property = attrs.get("property")?.toLowerCase();
+    const name = attrs.get("name")?.toLowerCase();
+    return (property === "og:image" ||
+        property === "og:image:url" ||
+        property === "og:image:secure_url" ||
+        name === "twitter:image" ||
+        name === "twitter:image:src");
+}
+function parseTagAttributes(raw) {
+    const attrs = new Map();
+    const attrPattern = /([A-Za-z_:][-A-Za-z0-9_:.]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+)))?/g;
+    let match;
+    while ((match = attrPattern.exec(raw)) !== null) {
+        attrs.set(match[1].toLowerCase(), match[2] ?? match[3] ?? match[4] ?? "");
+    }
+    return attrs;
+}
+function parseSrcset(srcset) {
+    if (!srcset) {
+        return [];
+    }
+    return srcset
+        .split(",")
+        .map((candidate) => candidate.trim().split(/\s+/, 1)[0])
+        .filter((candidate) => Boolean(candidate));
+}
+function pushAssetReference(references, htmlFile, href) {
+    const outputPath = localAssetOutputPath(href, htmlFile);
+    if (!href || !outputPath) {
+        return;
+    }
+    references.push({ href, outputPath });
+}
+function localAssetOutputPath(href, htmlFile) {
+    if (!href || isIgnoredAssetUrl(href)) {
+        return undefined;
+    }
+    const [path] = href.split(/[?#]/, 1);
+    if (!path || path.endsWith("/")) {
+        return undefined;
+    }
+    if (path.startsWith("/")) {
+        return path.replace(/^\/+/, "");
+    }
+    return posix.normalize(posix.join(posix.dirname(htmlFile), path));
+}
+function localPrefetchTarget(href) {
+    if (!href || isIgnoredAssetUrl(href)) {
+        return undefined;
+    }
+    const [path] = href.split(/[?#]/, 1);
+    if (!path || !path.startsWith("/") || path.startsWith("//")) {
+        return undefined;
+    }
+    return path;
+}
+function isIgnoredAssetUrl(href) {
+    return (href.startsWith("#") ||
+        href.startsWith("//") ||
+        /^(?:[a-z][a-z0-9+.-]*:)/i.test(href));
+}
+function isSafePublicOutputPath(path) {
+    return path !== "" && !path.split("/").includes("..");
+}
+function publicFileType(path) {
+    const extension = posix.extname(path).toLowerCase();
+    return extension ? extension.slice(1) : "none";
+}
+const imagePublicFileTypes = new Set(["avif", "gif", "ico", "jpeg", "jpg", "png", "svg", "webp"]);
+function isImagePublicFileType(type) {
+    return imagePublicFileTypes.has(type);
+}
+function isCompressiblePublicPath(path) {
+    return /\.(?:html|css|js|xml|json|csv|txt|svg)$/i.test(path);
+}
+function isPrecompressedSidecarPath(path) {
+    return /\.(?:br|gz)$/i.test(path);
+}
+async function listPublicFiles(outDir, dir = outDir) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch (error) {
+        if (isMissingPath(error)) {
+            return [];
+        }
+        throw error;
+    }
+    const files = [];
+    for (const entry of entries) {
+        if (entry.name === ".stoneage") {
+            continue;
+        }
+        const entryPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await listPublicFiles(outDir, entryPath)));
+            continue;
+        }
+        if (entry.isFile()) {
+            files.push(relative(outDir, entryPath).replaceAll("\\", "/"));
+        }
+    }
+    return files.sort();
+}
+function dedupeIssues(issues) {
+    const seen = new Set();
+    return issues.filter((issue) => {
+        const key = `${issue.code}\0${issue.path ?? ""}\0${issue.message}\0${issue.bytes ?? ""}\0${issue.limit ?? ""}`;
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+}
+async function readOptionalText(path) {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (isMissingPath(error)) {
+            return undefined;
+        }
+        throw error;
+    }
+}
+async function collectPublicDataExportTargets(outDir, manifest) {
+    const targets = new Map();
+    const dataDir = join(outDir, "data");
+    for (const file of await listPublicDataExportFiles(dataDir)) {
+        const outputPath = `data/${file}`;
+        const format = exportFormatForPath(outputPath);
+        if (format) {
+            targets.set(outputPath, { outputPath, publicPath: outputPath, format });
+        }
+    }
+    for (const artifact of manifest?.artifacts ?? []) {
+        const format = exportFormatForArtifact(artifact);
+        if (format) {
+            targets.set(artifact.outputPath, {
+                outputPath: artifact.outputPath,
+                publicPath: artifact.outputPath,
+                format,
+            });
+        }
+    }
+    return [...targets.values()].sort((left, right) => left.outputPath.localeCompare(right.outputPath));
+}
+async function validatePublicDataExports(outDir, targets) {
+    const issues = [];
+    for (const target of targets) {
+        const absolutePath = join(outDir, target.outputPath);
+        let contents;
+        try {
+            contents = await readFile(absolutePath, "utf8");
+        }
+        catch (error) {
+            if (isMissingPath(error)) {
+                continue;
+            }
+            throw error;
+        }
+        if (target.format === "json") {
+            try {
+                JSON.parse(contents);
+            }
+            catch (error) {
+                issues.push({
+                    code: "export.invalid_json",
+                    path: target.publicPath,
+                    message: `${target.publicPath} is not valid JSON: ${errorMessage(error)}.`,
+                });
+            }
+            continue;
+        }
+        const csvIssue = validateCsvExport(contents);
+        if (csvIssue) {
+            issues.push({
+                code: csvIssue.code,
+                path: target.publicPath,
+                message: `${target.publicPath} ${csvIssue.message}`,
+            });
+        }
+    }
+    return issues;
+}
+async function listPublicDataExportFiles(path, dir = path) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch (error) {
+        if (isMissingPath(error)) {
+            return [];
+        }
+        throw error;
+    }
+    const files = [];
+    for (const entry of entries) {
+        const entryPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await listPublicDataExportFiles(path, entryPath)));
+            continue;
+        }
+        if (entry.isFile() && /\.(csv|json)$/u.test(entry.name)) {
+            files.push(relative(path, entryPath).replaceAll("\\", "/"));
+        }
+    }
+    return files.sort();
+}
+async function collectImageInputs(sourceDir, dir = sourceDir, excludeDir) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch (error) {
+        if (isMissingPath(error)) {
+            return [];
+        }
+        throw error;
+    }
+    const images = [];
+    for (const entry of entries) {
+        const entryPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            // Skip the output directory so generated variants are not re-ingested as
+            // inputs on subsequent runs. Both paths are pre-resolved by the caller.
+            if (excludeDir && resolve(entryPath) === excludeDir) {
+                continue;
+            }
+            images.push(...(await collectImageInputs(sourceDir, entryPath, excludeDir)));
+            continue;
+        }
+        if (entry.isFile() && /\.(jpe?g|png|webp)$/iu.test(entry.name)) {
+            const relativePath = relative(sourceDir, entryPath).replaceAll("\\", "/");
+            images.push({
+                source: entryPath,
+                publicPath: `/${relativePath}`,
+            });
+        }
+    }
+    return images.sort((left, right) => left.publicPath.localeCompare(right.publicPath));
+}
+function exportFormatForArtifact(artifact) {
+    const contentType = artifact.contentType?.toLowerCase() ?? "";
+    if (contentType.split(";")[0]?.trim() === "application/json") {
+        return "json";
+    }
+    if (contentType.split(";")[0]?.trim() === "text/csv") {
+        return "csv";
+    }
+    return exportFormatForPath(artifact.outputPath);
+}
+function exportFormatForPath(path) {
+    if (path.endsWith(".json")) {
+        return "json";
+    }
+    if (path.endsWith(".csv")) {
+        return "csv";
+    }
+    return undefined;
+}
+function validateCsvExport(contents) {
+    if (contents.trim() === "") {
+        return {
+            code: "export.empty_csv",
+            message: "is empty.",
+        };
+    }
+    const parsed = parseCsvRows(contents);
+    if (typeof parsed === "string") {
+        return {
+            code: "export.invalid_csv",
+            message: parsed,
+        };
+    }
+    const rows = parsed.filter((row, index) => index === 0 || row.some((cell) => cell !== ""));
+    const expectedColumns = rows[0]?.length ?? 0;
+    if (expectedColumns === 0) {
+        return {
+            code: "export.empty_csv",
+            message: "does not contain a header row.",
+        };
+    }
+    for (let index = 1; index < rows.length; index += 1) {
+        const row = rows[index];
+        if (row.length !== expectedColumns) {
+            return {
+                code: "export.invalid_csv",
+                message: `row ${index + 1} has ${row.length} column(s), expected ${expectedColumns}.`,
+            };
+        }
+    }
+    return undefined;
+}
+function parseCsvRows(contents) {
+    const rows = [];
+    let row = [];
+    let cell = "";
+    let quoted = false;
+    for (let index = 0; index < contents.length; index += 1) {
+        const char = contents[index];
+        const next = contents[index + 1];
+        if (quoted) {
+            if (char === '"' && next === '"') {
+                cell += '"';
+                index += 1;
+                continue;
+            }
+            if (char === '"') {
+                quoted = false;
+                continue;
+            }
+            cell += char;
+            continue;
+        }
+        if (char === '"') {
+            if (cell !== "") {
+                return "has a quote inside an unquoted field.";
+            }
+            quoted = true;
+            continue;
+        }
+        if (char === ",") {
+            row.push(cell);
+            cell = "";
+            continue;
+        }
+        if (char === "\n") {
+            row.push(cell);
+            rows.push(row);
+            row = [];
+            cell = "";
+            continue;
+        }
+        if (char === "\r") {
+            continue;
+        }
+        cell += char;
+    }
+    if (quoted) {
+        return "has an unterminated quoted field.";
+    }
+    row.push(cell);
+    if (row.some((value) => value !== "") || contents.endsWith(",")) {
+        rows.push(row);
+    }
+    return rows;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function isMissingPath(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function readValue(option, args) {
+    const value = args.shift();
+    if (!value) {
+        throw new Error(`Missing value for ${option}`);
+    }
+    return value;
+}
+function readPositiveInteger(option, args) {
+    const raw = readValue(option, args);
+    const value = Number(raw);
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new Error(`Expected a positive integer for ${option}`);
+    }
+    return value;
+}
+function readNonNegativeNumber(option, args) {
+    const raw = readValue(option, args);
+    const value = Number(raw);
+    if (!Number.isFinite(value) || value < 0) {
+        throw new Error(`Expected a non-negative number for ${option}`);
+    }
+    return value;
+}
+function readNonNegativeInteger(option, args) {
+    const raw = readValue(option, args);
+    const value = Number(raw);
+    if (!Number.isInteger(value) || value < 0) {
+        throw new Error(`Expected a non-negative integer for ${option}`);
+    }
+    return value;
+}
+function readTrailingSlash(option, args) {
+    const value = readValue(option, args);
+    if (value !== "always" && value !== "never") {
+        throw new Error(`Expected always or never for ${option}`);
+    }
+    return value;
+}
+function readDeployProvider(option, args) {
+    const value = readValue(option, args);
+    if (value !== "netlify" && value !== "github-pages") {
+        throw new Error(`Expected netlify or github-pages for ${option}`);
+    }
+    return value;
+}
+function readImageFormat(option, args) {
+    const value = readValue(option, args);
+    if (value !== "webp" && value !== "avif" && value !== "jpeg" && value !== "png") {
+        throw new Error(`Expected webp, avif, jpeg, or png for ${option}`);
+    }
+    return value;
+}
+function helpText() {
+    return [
+        "Usage: stoneage <command> [options]",
+        "",
+        "Commands:",
+        "  build            Run a TSX/TS entry with the html() JSX factory forced",
+        "  test             Run TSX/TS tests with the html() JSX factory forced",
+        "  benchmark        Build and measure the example data site",
+        "  validate         Validate generated output before publishing",
+        "  inspect          List outputs that depend on one dependency key",
+        "  plan             Plan outputs affected by dependency keys",
+        "  optimize         Write precompressed public output sidecars",
+        "  optimize-images  Generate responsive image variants with sharp",
+        "  deploy           Emit provider-specific deploy artifacts",
+        "  dev              Serve generated output with hot reload",
+        "  agent-skill      Print a Codex skill for StoneAge projects",
+        "  audit-sveltekit  Audit a SvelteKit route tree for migration",
+        "",
+        "Common options:",
+        "  --out-dir <dir>  Generated output directory",
+        "  --json           Print machine-readable JSON where supported",
+        "  --help, -h       Print this help",
+        "",
+        "Build options:",
+        "  stoneage build <entry> [-- <args>]     Run <entry> with the html() JSX factory forced",
+        "",
+        "Test options:",
+        "  stoneage test [files...] [-- <args>]   Run node:test with the html() JSX factory forced",
+        "",
+        "Benchmark options:",
+        "  --compare-to <file>                    Compare size metrics with a previous benchmark JSON report",
+        "  --max-size-regression-percent <number> Allowed percentage growth for compared size metrics",
+        "  --comparison-report <file>             Write benchmark comparison JSON",
+        "",
+        "Validate options:",
+        "  --validation-config <file>             Load metadata, budget, and publish gate settings",
+        "  --write-validation-config <file>       Write a validation baseline from current output",
+        "  --require-precompressed                Fail when Brotli or Gzip sidecars are missing",
+        "  --provider <netlify|github-pages>      Validate deploy artifacts for the given provider",
+        "  --report <file>                        Write the validation summary JSON",
+        "",
+        "SvelteKit audit options:",
+        "  --routes-dir <dir>                     SvelteKit src/routes directory to audit",
+        "  --params-dir <dir>                     Optional SvelteKit params matcher directory",
+        "  --migration-plan                       Include StoneAge route and artifact plan suggestions",
+        "  --emit-stubs <dir>                     Write non-adapter migration scaffold files",
+        "  --report <file>                        Write the audit report JSON",
+        "",
+        "Optimize-images options:",
+        "  --source-dir <dir>                     Directory to scan for .jpg/.png/.webp source images (required)",
+        "  --width <px>                           Output width; repeat for multiple widths (default 640, 1280)",
+        "  --format <webp|avif|jpeg|png>          Output format; repeat for multiple formats (default webp)",
+        "                                         Requires the optional 'sharp' dependency (npm install sharp)",
+        "",
+        "Deploy options:",
+        "  --provider <netlify|github-pages>      Write provider-specific deploy artifacts",
+        "  --cname <domain>                       Custom domain for github-pages (writes CNAME)",
+        "",
+        "Dev options:",
+        "  --host <host>                          Hostname to bind, default 127.0.0.1",
+        "  --port <port>                          Port to bind, default 4321",
+        "  --watch <path>                         Path to watch; repeat for multiple paths",
+        "  --build-command <command>              Shell command to rebuild generated output before reload",
+        "  --debounce-ms <ms>                     Delay before rebuilding after file changes",
+        "",
+        "Agent skill options:",
+        "  --print                                Print the StoneAge agent skill Markdown",
+    ].join("\n");
+}
+const requireFromCli = createRequire(import.meta.url);
+/**
+ * Absolute path to the Node module registrar that installs the StoneAge JSX
+ * loader. Shipped alongside dist/ (see jsx-register.mjs / jsx-loader.mjs).
+ *
+ * dist/cli.js -> ../jsx-register.mjs (package root)
+ * src/cli.ts  -> ../jsx-register.mjs (repo root)
+ */
+function jsxRegisterPath() {
+    return join(dirname(fileURLToPath(import.meta.url)), "..", "jsx-register.mjs");
+}
+/**
+ * Resolve tsx's ESM loader entry (shipped as a dependency of this package).
+ * tsx handles module resolution (e.g. NodeNext ".js" -> ".ts") and ESM/CJS
+ * interop; the StoneAge JSX loader layered on top forces the html() factory.
+ */
+function resolveTsxLoader() {
+    try {
+        // Return a file:// URL (not a raw path) so `node --import` accepts it on
+        // every platform, including Windows where bare drive-letter paths are not
+        // valid module specifiers.
+        return pathToFileURL(requireFromCli.resolve("tsx/esm")).href;
+    }
+    catch {
+        throw new Error("Could not resolve 'tsx'. Reinstall @t09tanaka/stoneage so its dependencies are available.");
+    }
+}
+/**
+ * Run a Node child process with the StoneAge JSX loader + tsx loader installed
+ * so TSX/TS sources compile with jsxFactory=html (jsxFragmentFactory=Fragment),
+ * regardless of the consumer's own tsconfig (e.g. jsx:"react-jsx").
+ *
+ * The JSX registrar is imported before tsx so its load hook runs first and
+ * transforms .tsx/.jsx with the forced factory, while tsx resolves modules and
+ * compiles the remaining .ts sources.
+ */
+function runWithForcedJsx(nodeArgs) {
+    const child = spawn(process.execPath, [
+        "--import",
+        pathToFileURL(jsxRegisterPath()).href,
+        "--import",
+        resolveTsxLoader(),
+        ...nodeArgs,
+    ], { stdio: "inherit" });
+    return new Promise((resolveRun, rejectRun) => {
+        child.on("error", rejectRun);
+        child.on("exit", (code, signal) => {
+            if (signal) {
+                rejectRun(new Error(`process exited with ${signal}`));
+                return;
+            }
+            resolveRun(code ?? 0);
+        });
+    });
+}
+function isExecutedEntrypoint() {
+    const entrypoint = process.argv[1];
+    if (!entrypoint) {
+        return false;
+    }
+    try {
+        return realpathSync(entrypoint) === fileURLToPath(import.meta.url);
+    }
+    catch {
+        return false;
+    }
+}
+if (isExecutedEntrypoint()) {
+    runCli().catch((error) => {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    });
+}