@a11yst/core 1.0.0

package/dist/execute-audit.js

@@ -0,0 +1,646 @@
+import { basename, isAbsolute, resolve } from "node:path";
+import { createArtifactWriter, appendGitHubStepSummary } from "@a11yst/artifacts";
+import { runWebAudit, runFlowAudit, sortFindings, } from "@a11yst/browser";
+import { productMetadata } from "@a11yst/types";
+import { aggregateSummary, buildProfileSummary, buildFlowSummary, emptySeverityCounts, sortRunResults } from "./aggregate.js";
+import { createAuditPlan } from "./create-audit-plan.js";
+import { prepareAuditConfig } from "./resolve-project-routes.js";
+import { applyBaselineComparison } from "./baseline-comparison.js";
+import { applySourceAnalysis } from "./apply-source-analysis.js";
+import { applyPolicyEvaluation } from "./policy-evaluation.js";
+import { shouldGenerateSarifForAuditResult, } from "./generate-sarif-report.js";
+import { shouldGenerateJunitForAuditResult, } from "./generate-junit-report.js";
+import { generateMarkdownContentFromAuditResult, shouldGenerateMarkdownForAuditResult, } from "./generate-markdown-report.js";
+import { shouldGenerateGitHubAnnotationsForAuditResult, } from "./generate-github-annotations-report.js";
+import { emitReportArtifact } from "./emit-report.js";
+import { buildReportManifestEntry, buildJunitReportReference, buildMarkdownReportReference, buildGitHubAnnotationsReportReference, buildGitHubStepSummaryReference, buildSarifReportReference, mergeReportReferences, } from "./report-manifest.js";
+import { selectRuns, skipReasonForRun, UnknownProfileError, UnknownProjectError, UnknownFlowError, isRouteRun, isFlowCheckpointRun } from "./select-runs.js";
+const LIMITATIONS = [
+    "Automated checks do not establish accessibility conformance.",
+    "Automated checks cover only part of accessibility. Manual review and testing with disabled users remain necessary.",
+];
+function buildEnvironment(headed) {
+    return {
+        product: productMetadata.name,
+        productVersion: productMetadata.version,
+        nodeVersion: process.version,
+        browser: "chromium",
+        headed: headed ?? false,
+    };
+}
+function diagnosticForSkippedRun(run, reason) {
+    return {
+        code: "PROFILE_NOT_ENABLED",
+        severity: "info",
+        message: reason,
+        path: `runs.${run.id}`,
+    };
+}
+function skippedRunResult(run) {
+    const reason = skipReasonForRun(run) ?? "This run is not executed in this phase.";
+    return {
+        runId: run.id,
+        projectName: run.projectName,
+        platform: run.platform,
+        framework: run.framework,
+        routeId: run.routeId,
+        routeName: run.routeName,
+        route: run.route?.path,
+        url: run.baseUrl,
+        profile: run.profile,
+        viewport: run.viewport,
+        status: "skipped",
+        startedAt: new Date().toISOString(),
+        durationMs: 0,
+        findings: [],
+        diagnostics: [diagnosticForSkippedRun(run, reason)],
+        skipReason: reason,
+        ...(run.adapter !== undefined ? { adapter: run.adapter } : {}),
+    };
+}
+function groupRunsByProject(runs) {
+    const groups = new Map();
+    for (const run of runs) {
+        const existing = groups.get(run.projectName);
+        if (existing) {
+            existing.push(run);
+        }
+        else {
+            groups.set(run.projectName, [run]);
+        }
+    }
+    return groups;
+}
+/** Resolve the artifact root without depending on the process working directory. */
+export function resolveAuditOutputDirectory(config, outputDir) {
+    const configured = outputDir ?? config.outputDir;
+    return isAbsolute(configured) ? resolve(configured) : resolve(config.configDir, configured);
+}
+function findingLogicalId(finding) {
+    return finding.id || finding.fingerprint.slice(0, 16) || finding.ruleId || "unknown";
+}
+function sanitizeFlowSegment(value) {
+    return value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "item";
+}
+export function createFlowEvidenceSink(writer, projectName) {
+    return {
+        writeFlowTrace: async ({ flowId, profile, viewportName, data }) => {
+            const bundlePath = writer.relativePath("evidence", sanitizeFlowSegment(projectName), "flows", sanitizeFlowSegment(flowId), sanitizeFlowSegment(profile), sanitizeFlowSegment(viewportName), "flow-trace.json");
+            await writer.writeJson(bundlePath, data);
+            return bundlePath;
+        },
+        writeStepScreenshot: async ({ flowId, profile, viewportName, stepIndex, action, data }) => {
+            const bundlePath = writer.relativePath("evidence", sanitizeFlowSegment(projectName), "flows", sanitizeFlowSegment(flowId), sanitizeFlowSegment(profile), sanitizeFlowSegment(viewportName), "steps", `${String(stepIndex + 1).padStart(3, "0")}-${sanitizeFlowSegment(action)}`, "page.png");
+            await writer.writeBuffer(bundlePath, data);
+            return bundlePath;
+        },
+        writeCheckpointScreenshot: async ({ flowId, checkpointId, profile, viewportName, data }) => {
+            const bundlePath = writer.relativePath("evidence", sanitizeFlowSegment(projectName), "flows", sanitizeFlowSegment(flowId), sanitizeFlowSegment(profile), sanitizeFlowSegment(viewportName), "checkpoints", sanitizeFlowSegment(checkpointId), "page.png");
+            await writer.writeBuffer(bundlePath, data);
+            return bundlePath;
+        },
+    };
+}
+/**
+ * Adapt an artifact writer to the browser's immediate evidence persistence API.
+ * Filenames use finding identities only and never include target selectors.
+ */
+export function createArtifactEvidenceSink(writer) {
+    return {
+        writeRunScreenshot: ({ run, data }) => writer.writeEvidence({
+            projectName: run.projectName,
+            routeId: run.routeId ?? "route",
+            profile: run.profile,
+            viewportName: run.viewport?.name ?? "default",
+            filename: "page.png",
+            data,
+        }),
+        writeFindingScreenshot: ({ run, finding, targetIndex, data }) => writer.writeEvidence({
+            projectName: run.projectName,
+            routeId: run.routeId ?? "route",
+            profile: run.profile,
+            viewportName: run.viewport?.name ?? "default",
+            filename: `finding-${findingLogicalId(finding)}-${targetIndex}.png`,
+            data,
+        }),
+    };
+}
+function buildManifest(config, result, writer, reportGenerated, sarifEntry, junitEntry, markdownEntry, githubAnnotationsEntry, githubStepSummaryWritten) {
+    const manifest = {
+        schemaVersion: "1",
+        auditId: writer.auditId,
+        createdAt: writer.createdAt,
+        status: result.status,
+        productVersion: productMetadata.version,
+        ...(config.configPath ? { configPath: basename(config.configPath) } : {}),
+        projectRoot: ".",
+        resultsPath: "results.json",
+        ...(reportGenerated ? { reportPath: "report/index.html" } : {}),
+        ...(writer.screenshotCount > 0 ? { evidenceDirectory: "evidence" } : {}),
+        projects: result.plan.projects.map((project) => ({
+            name: project.name,
+            platform: project.platform,
+            framework: project.framework,
+        })),
+        artifactCounts: {
+            screenshots: writer.screenshotCount,
+            findings: result.findings.length,
+            runs: result.runs.length,
+        },
+    };
+    const reports = buildReportManifestEntry(reportGenerated, reportGenerated ? "report/index.html" : undefined, sarifEntry, junitEntry, markdownEntry, githubAnnotationsEntry, githubStepSummaryWritten);
+    if (reports) {
+        manifest.reports = reports;
+    }
+    if (result.policyEvaluation) {
+        manifest.policy = {
+            status: result.policyEvaluation.status,
+            policyEnabled: result.policyEvaluation.policyEnabled,
+            totalBreaches: result.policyEvaluation.summary.totalBreaches,
+        };
+    }
+    return manifest;
+}
+function relativeArtifactReferences(writer, reportGenerated, sarifBundlePath, junitBundlePath, markdownBundlePath, githubAnnotationsBundlePath) {
+    return {
+        outputDirectory: ".",
+        manifestPath: "manifest.json",
+        resultsPath: "results.json",
+        latestPath: "../../latest.json",
+        ...(writer.screenshotCount > 0 ? { evidenceDirectory: "evidence" } : {}),
+        ...(reportGenerated ? { reportPath: "report/index.html" } : {}),
+        ...(sarifBundlePath ? { sarifPath: sarifBundlePath } : {}),
+        ...(junitBundlePath ? { junitPath: junitBundlePath } : {}),
+        ...(markdownBundlePath ? { markdownPath: markdownBundlePath } : {}),
+        ...(githubAnnotationsBundlePath ? { githubAnnotationsPath: githubAnnotationsBundlePath } : {}),
+    };
+}
+function removeUndefinedProperties(value) {
+    if (Array.isArray(value)) {
+        for (const entry of value)
+            removeUndefinedProperties(entry);
+        return;
+    }
+    if (!value || typeof value !== "object")
+        return;
+    for (const [key, entry] of Object.entries(value)) {
+        if (entry === undefined) {
+            delete value[key];
+        }
+        else {
+            removeUndefinedProperties(entry);
+        }
+    }
+}
+/**
+ * Build a `"failed"` result for global operational failures (unknown
+ * `--project` selection, ...) that happen before any run could be attempted.
+ */
+function buildGlobalFailure(plan, startedAt, environment, diagnostic) {
+    return {
+        schemaVersion: "1",
+        status: "failed",
+        summary: {
+            status: "failed",
+            startedAt,
+            durationMs: Math.max(0, Date.now() - new Date(startedAt).getTime()),
+            plannedRuns: 0,
+            completedRuns: 0,
+            skippedRuns: 0,
+            failedRuns: 0,
+            findingCount: 0,
+            findingsBySeverity: emptySeverityCounts(),
+        },
+        plan,
+        runs: [],
+        findings: [],
+        diagnostics: [...plan.diagnostics, diagnostic],
+        limitations: [...LIMITATIONS],
+        environment,
+    };
+}
+/**
+ * Execute a full audit for a resolved configuration: build the plan, select
+ * which planned runs are actually executable in this phase, run web audits
+ * through `@a11yst/browser`, and aggregate everything into a single
+ * serialisable `AuditExecutionResult`.
+ *
+ * Never throws for per-run failures (navigation errors, dev server issues,
+ * a missing browser, ...) — those are captured as `"failed"` runs and
+ * reflected in `summary.status`. It only returns early with a `"failed"`
+ * result (no runs attempted) for a global configuration/selection error,
+ * e.g. an unknown `--project` name.
+ */
+export async function executeAudit(config, options = {}) {
+    const startedAt = new Date().toISOString();
+    const progress = options.progress;
+    const preparedConfig = await prepareAuditConfig(config, progress);
+    const plan = createAuditPlan(preparedConfig);
+    const environment = buildEnvironment(options.headed);
+    const writeArtifacts = options.writeArtifacts ?? true;
+    let writer;
+    if (writeArtifacts) {
+        try {
+            writer = createArtifactWriter({
+                outputDir: resolveAuditOutputDirectory(config, options.outputDir),
+                auditId: options.artifactAuditId,
+                now: options.artifactNow,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to create audit artifact bundle: ${message}`, { cause: error });
+        }
+    }
+    let result;
+    let selection;
+    try {
+        selection = selectRuns(plan, {
+            projectNames: options.projectNames,
+            profileNames: options.profileNames,
+            flowNames: options.flowNames,
+            routesOnly: options.routesOnly,
+            flowsOnly: options.flowsOnly,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const code = error instanceof UnknownProjectError
+            ? "UNKNOWN_PROJECT"
+            : error instanceof UnknownProfileError
+                ? "UNKNOWN_PROFILE"
+                : error instanceof UnknownFlowError
+                    ? "UNKNOWN_FLOW"
+                    : "AUDIT_SELECTION_FAILED";
+        result = buildGlobalFailure(plan, startedAt, environment, {
+            code,
+            severity: "error",
+            message,
+        });
+    }
+    if (selection) {
+        const { executable, skipped } = selection;
+        const skippedResults = skipped.map(skippedRunResult);
+        const completedResults = [];
+        const runDiagnostics = [];
+        const flowExecutions = [];
+        const totalExecutableRuns = executable.length;
+        let completedExecutableRuns = 0;
+        const screenshots = writeArtifacts
+            ? (options.screenshots ?? config.evidence?.screenshots ?? true)
+            : false;
+        const fullPage = options.fullPageScreenshots ?? config.evidence?.fullPage ?? false;
+        for (const [projectName, runsForProject] of groupRunsByProject(executable)) {
+            const project = plan.projects.find((candidate) => candidate.name === projectName);
+            if (!project || project.platform !== "web") {
+                continue;
+            }
+            const routeRuns = runsForProject.filter((run) => isRouteRun(run));
+            const flowRuns = runsForProject.filter((run) => isFlowCheckpointRun(run));
+            const sharedEvidence = {
+                screenshots,
+                fullPage,
+                ...(screenshots && writer
+                    ? { sink: createArtifactEvidenceSink(writer) }
+                    : {}),
+                ...(writer
+                    ? {
+                        writeStructuredEvidence: async ({ run, filename, data, }) => writer.writeEvidence({
+                            projectName: run.projectName,
+                            routeId: run.routeId ?? run.flowId ?? "route",
+                            profile: run.profile,
+                            viewportName: run.viewport?.name ?? "default",
+                            filename,
+                            data: Buffer.from(`${JSON.stringify(data, null, 2)}\n`, "utf8"),
+                        }),
+                        ...(flowRuns.length > 0
+                            ? { writeFlowEvidence: createFlowEvidenceSink(writer, project.name) }
+                            : {}),
+                    }
+                    : {}),
+            };
+            if (routeRuns.length > 0) {
+                const batch = await runWebAudit({
+                    project,
+                    runs: routeRuns,
+                    configDir: config.configDir,
+                    evidence: sharedEvidence,
+                    options: {
+                        headed: options.headed,
+                        navigationTimeoutMs: options.navigationTimeoutMs,
+                        noStartServer: options.noStartServer,
+                        signal: options.signal,
+                        progress,
+                        runProgressOffset: completedExecutableRuns,
+                        runProgressTotal: totalExecutableRuns,
+                    },
+                });
+                completedResults.push(...batch.runs);
+                runDiagnostics.push(...batch.diagnostics);
+                completedExecutableRuns += routeRuns.length;
+            }
+            if (flowRuns.length > 0) {
+                const batch = await runFlowAudit({
+                    project,
+                    runs: flowRuns,
+                    configDir: config.configDir,
+                    evidence: sharedEvidence,
+                    options: {
+                        headed: options.headed,
+                        navigationTimeoutMs: options.navigationTimeoutMs,
+                        stepTimeoutMs: options.stepTimeoutMs,
+                        noStartServer: options.noStartServer,
+                        signal: options.signal,
+                        progress,
+                        runProgressOffset: completedExecutableRuns,
+                        runProgressTotal: totalExecutableRuns,
+                    },
+                });
+                completedResults.push(...batch.runs);
+                runDiagnostics.push(...batch.diagnostics);
+                flowExecutions.push(...batch.flowExecutions);
+                completedExecutableRuns += flowRuns.length;
+            }
+        }
+        const runs = sortRunResults([...completedResults, ...skippedResults]);
+        const findings = sortFindings(runs.flatMap((run) => run.findings));
+        const summary = aggregateSummary(runs, startedAt);
+        const diagnostics = [...plan.diagnostics, ...runDiagnostics];
+        result = {
+            schemaVersion: "1",
+            status: summary.status,
+            summary,
+            plan,
+            runs,
+            findings,
+            diagnostics,
+            limitations: [...LIMITATIONS],
+            profileSummary: buildProfileSummary(runs),
+            flowSummary: buildFlowSummary(plan, runs),
+            ...(flowExecutions.length > 0 ? { flowExecutions } : {}),
+            environment,
+        };
+    }
+    if (!result) {
+        throw new Error("Audit execution did not produce a result.");
+    }
+    result = await applySourceAnalysis(config, result, progress);
+    const baselineApplied = await applyBaselineComparison(config, result, {
+        noBaseline: options.noBaseline,
+        baselinePath: options.baselinePath,
+        explicitBaselineRequired: options.explicitBaselineRequired,
+    });
+    result = baselineApplied.result;
+    const resolvedPolicy = options.ciPolicy ?? config.ci;
+    result = {
+        ...result,
+        policyEvaluation: applyPolicyEvaluation(result, resolvedPolicy, baselineApplied),
+    };
+    if (!writer) {
+        return result;
+    }
+    result.auditId = writer.auditId;
+    let reportGenerated = false;
+    let sarifBundlePath;
+    let sarifManifestEntry;
+    let sarifExternalPath;
+    let junitBundlePath;
+    let junitManifestEntry;
+    let junitExternalPath;
+    let markdownBundlePath;
+    let markdownManifestEntry;
+    let markdownExternalPath;
+    let githubAnnotationsBundlePath;
+    let githubAnnotationsManifestEntry;
+    let githubAnnotationsExternalPath;
+    let githubStepSummaryWritten = false;
+    let markdownContentForSummary;
+    const sarifEnabled = options.sarif?.enabled ?? false;
+    const shouldGenerateSarif = sarifEnabled && shouldGenerateSarifForAuditResult(result);
+    const junitEnabled = options.junit?.enabled ?? false;
+    const shouldGenerateJunit = junitEnabled && shouldGenerateJunitForAuditResult(result);
+    const markdownEnabled = options.markdown?.enabled ?? true;
+    const shouldGenerateMarkdown = markdownEnabled && shouldGenerateMarkdownForAuditResult(result);
+    const githubAnnotationsEnabled = options.githubAnnotations?.enabled ?? false;
+    const shouldGenerateGitHubAnnotations = githubAnnotationsEnabled && shouldGenerateGitHubAnnotationsForAuditResult(result);
+    const githubStepSummaryEnabled = options.githubStepSummary ?? false;
+    const shouldWriteStepSummary = githubStepSummaryEnabled && shouldGenerateMarkdownForAuditResult(result);
+    const willGenerateReports = (options.html ?? true) ||
+        shouldGenerateSarif ||
+        shouldGenerateJunit ||
+        shouldGenerateMarkdown ||
+        shouldGenerateGitHubAnnotations ||
+        shouldWriteStepSummary;
+    if (willGenerateReports) {
+        progress?.start("Generating reports…");
+    }
+    if (options.html ?? true) {
+        result.artifacts = relativeArtifactReferences(writer, true);
+        try {
+            await emitReportArtifact({
+                format: "html",
+                result,
+                bundleDirectory: writer.runDirectory,
+                auditId: writer.auditId,
+            });
+            reportGenerated = true;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            result.diagnostics.push({
+                code: "REPORT_GENERATION_FAILED",
+                severity: "error",
+                message: `Could not generate the HTML report: ${message}`,
+            });
+            if (result.status !== "failed") {
+                result.status = "completed-with-errors";
+                result.summary.status = "completed-with-errors";
+            }
+        }
+    }
+    if (shouldGenerateSarif) {
+        try {
+            const externalPath = options.sarifExternalOutputPath
+                ?? (options.sarif?.outputPath
+                    ? resolve(config.configDir, options.sarif.outputPath)
+                    : undefined);
+            const sarifReport = await emitReportArtifact({
+                format: "sarif",
+                result,
+                bundleDirectory: writer.runDirectory,
+                ...(externalPath ? { externalOutputPath: externalPath } : {}),
+            });
+            sarifBundlePath = sarifReport.bundlePath;
+            sarifManifestEntry = sarifReport.manifestEntry;
+            sarifExternalPath = sarifReport.externalPath;
+            result.reports = mergeReportReferences(result.reports, buildSarifReportReference(sarifReport.resultReference));
+        }
+        catch (error) {
+            await writer.cleanupPartial().catch(() => {
+                // Keep the original SARIF failure as the operational error.
+            });
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to generate SARIF report: ${message}`, { cause: error });
+        }
+    }
+    if (shouldGenerateJunit) {
+        try {
+            const externalPath = options.junitExternalOutputPath
+                ?? (options.junit?.outputPath
+                    ? resolve(config.configDir, options.junit.outputPath)
+                    : undefined);
+            const junitReport = await emitReportArtifact({
+                format: "junit",
+                result,
+                bundleDirectory: writer.runDirectory,
+                ...(externalPath ? { externalOutputPath: externalPath } : {}),
+                policy: resolvedPolicy,
+            });
+            junitBundlePath = junitReport.bundlePath;
+            junitManifestEntry = junitReport.manifestEntry;
+            junitExternalPath = junitReport.externalPath;
+            result.reports = mergeReportReferences(result.reports, buildJunitReportReference(junitReport.resultReference));
+        }
+        catch (error) {
+            await writer.cleanupPartial().catch(() => {
+                // Keep the original JUnit failure as the operational error.
+            });
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to generate JUnit report: ${message}`, { cause: error });
+        }
+    }
+    if (shouldGenerateMarkdown) {
+        try {
+            const externalPath = options.markdownExternalOutputPath
+                ?? (options.markdown?.outputPath
+                    ? resolve(config.configDir, options.markdown.outputPath)
+                    : undefined);
+            const markdownReport = await emitReportArtifact({
+                format: "markdown",
+                result,
+                bundleDirectory: writer.runDirectory,
+                ...(externalPath ? { externalOutputPath: externalPath } : {}),
+                policy: resolvedPolicy,
+                artifactReportPaths: {
+                    ...(reportGenerated ? { html: "report/index.html" } : {}),
+                    ...(sarifBundlePath ? { sarif: sarifBundlePath } : {}),
+                    ...(junitBundlePath ? { junit: junitBundlePath } : {}),
+                },
+            });
+            markdownBundlePath = markdownReport.bundlePath;
+            markdownManifestEntry = markdownReport.manifestEntry;
+            markdownExternalPath = markdownReport.externalPath;
+            markdownContentForSummary = markdownReport.serialized;
+            result.reports = mergeReportReferences(result.reports, buildMarkdownReportReference(markdownReport.resultReference));
+        }
+        catch (error) {
+            await writer.cleanupPartial().catch(() => { });
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to generate Markdown report: ${message}`, { cause: error });
+        }
+    }
+    if (shouldGenerateGitHubAnnotations) {
+        try {
+            const externalPath = options.githubAnnotationsExternalOutputPath
+                ?? (options.githubAnnotations?.outputPath
+                    ? resolve(config.configDir, options.githubAnnotations.outputPath)
+                    : undefined);
+            const githubReport = await emitReportArtifact({
+                format: "github-annotations",
+                result,
+                bundleDirectory: writer.runDirectory,
+                ...(externalPath ? { externalOutputPath: externalPath } : {}),
+                policy: resolvedPolicy,
+            });
+            githubAnnotationsBundlePath = githubReport.bundlePath;
+            githubAnnotationsManifestEntry = githubReport.manifestEntry;
+            githubAnnotationsExternalPath = githubReport.externalPath;
+            result.reports = mergeReportReferences(result.reports, buildGitHubAnnotationsReportReference(githubReport.resultReference));
+        }
+        catch (error) {
+            await writer.cleanupPartial().catch(() => { });
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to generate GitHub annotations: ${message}`, { cause: error });
+        }
+    }
+    if (shouldWriteStepSummary) {
+        const stepSummaryPath = options.githubStepSummaryPath?.trim();
+        if (!stepSummaryPath) {
+            await writer.cleanupPartial().catch(() => { });
+            throw new Error("GITHUB_STEP_SUMMARY is not set. Export GITHUB_STEP_SUMMARY in the GitHub Actions runner or omit --github-step-summary.");
+        }
+        try {
+            const markdown = markdownContentForSummary ??
+                generateMarkdownContentFromAuditResult(result, resolvedPolicy);
+            await appendGitHubStepSummary(stepSummaryPath, markdown);
+            githubStepSummaryWritten = true;
+            result.reports = mergeReportReferences(result.reports, buildGitHubStepSummaryReference());
+        }
+        catch (error) {
+            await writer.cleanupPartial().catch(() => { });
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to write GitHub step summary: ${message}`, { cause: error });
+        }
+    }
+    if (willGenerateReports) {
+        const reportLabels = [];
+        if (reportGenerated) {
+            reportLabels.push("HTML");
+        }
+        if (markdownBundlePath) {
+            reportLabels.push("Markdown");
+        }
+        if (sarifBundlePath) {
+            reportLabels.push("SARIF");
+        }
+        if (junitBundlePath) {
+            reportLabels.push("JUnit");
+        }
+        reportLabels.push("JSON");
+        progress?.succeed(reportLabels.join(" · "));
+    }
+    result.artifacts = relativeArtifactReferences(writer, reportGenerated, sarifBundlePath, junitBundlePath, markdownBundlePath, githubAnnotationsBundlePath);
+    const sarifExternalPathForOutput = sarifExternalPath;
+    const junitExternalPathForOutput = junitExternalPath;
+    const markdownExternalPathForOutput = markdownExternalPath;
+    const githubAnnotationsExternalPathForOutput = githubAnnotationsExternalPath;
+    const persistedResult = structuredClone(result);
+    removeUndefinedProperties(persistedResult);
+    const manifest = buildManifest(config, persistedResult, writer, reportGenerated, sarifManifestEntry, junitManifestEntry, markdownManifestEntry, githubAnnotationsManifestEntry, githubStepSummaryWritten);
+    try {
+        const artifactReferences = await writer.finalize({
+            result: persistedResult,
+            manifest,
+            baselineComparison: baselineApplied.artifact,
+        });
+        result.artifacts = artifactReferences;
+        if (sarifExternalPathForOutput) {
+            result.sarifExternalPath =
+                sarifExternalPathForOutput;
+        }
+        if (junitExternalPathForOutput) {
+            result.junitExternalPath =
+                junitExternalPathForOutput;
+        }
+        if (markdownExternalPathForOutput) {
+            result.markdownExternalPath =
+                markdownExternalPathForOutput;
+        }
+        if (githubAnnotationsExternalPathForOutput) {
+            result.githubAnnotationsExternalPath = githubAnnotationsExternalPathForOutput;
+        }
+        if (githubStepSummaryWritten) {
+            result.githubStepSummaryWritten =
+                true;
+        }
+        return result;
+    }
+    catch (error) {
+        await writer.cleanupPartial().catch(() => {
+            // Keep the original persistence failure as the operational error.
+        });
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to finalize audit artifact bundle: ${message}`, { cause: error });
+    }
+}
+//# sourceMappingURL=execute-audit.js.map