@alwaysmeticulous/debug-workspace 2.261.0

package/dist/generate-debug-workspace.js

@@ -0,0 +1,1302 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDebugWorkspace = void 0;
+const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const common_1 = require("@alwaysmeticulous/common");
+const chalk_1 = __importDefault(require("chalk"));
+const debug_constants_1 = require("./debug-constants");
+const TEMPLATES_DIR = (0, path_1.join)(__dirname, "templates");
+const generateDebugWorkspace = (options) => {
+    var _a;
+    const { debugContext, workspaceDir } = options;
+    const claudeDir = (0, path_1.join)(workspaceDir, ".claude");
+    (0, fs_1.mkdirSync)(claudeDir, { recursive: true });
+    copyClaudeMd(workspaceDir, options.additionalTemplatesDir);
+    generateFilteredLogs(workspaceDir);
+    generateLogDiffs(debugContext, workspaceDir);
+    generateDiffSummaries(workspaceDir);
+    generatePrDiff(debugContext, workspaceDir);
+    generateParamsDiffs(debugContext, workspaceDir);
+    generateAssetsDiff(debugContext, workspaceDir);
+    generateTimelineSummaries(workspaceDir);
+    generateSessionSummaries(debugContext, workspaceDir);
+    prettifySnapshotAssets(workspaceDir);
+    const screenshotMap = buildScreenshotMap(debugContext, workspaceDir);
+    generateScreenshotContext(debugContext, workspaceDir, screenshotMap);
+    const replayComparison = buildReplayComparison(debugContext, workspaceDir);
+    const fileMetadata = collectFileMetadata(debugContext, workspaceDir);
+    const writeCtx = (_a = options.writeContextJson) !== null && _a !== void 0 ? _a : defaultWriteContextJson;
+    writeCtx(debugContext, workspaceDir, fileMetadata, options.projectRepoDir, screenshotMap, replayComparison);
+    copyClaudeSubdir(workspaceDir, "rules", options.additionalTemplatesDir);
+    copyClaudeSubdir(workspaceDir, "hooks", options.additionalTemplatesDir);
+    copyClaudeSubdir(workspaceDir, "agents", options.additionalTemplatesDir);
+    copySkills(workspaceDir, options.additionalTemplatesDir);
+    const settingsSrc = resolveTemplateFile("settings.json", options.additionalTemplatesDir);
+    if (settingsSrc) {
+        (0, fs_1.copyFileSync)(settingsSrc, (0, path_1.join)(claudeDir, "settings.json"));
+    }
+};
+exports.generateDebugWorkspace = generateDebugWorkspace;
+// ---------------------------------------------------------------------------
+// Template copying (with overlay support)
+// ---------------------------------------------------------------------------
+const resolveTemplateFile = (relativePath, additionalTemplatesDir) => {
+    if (additionalTemplatesDir) {
+        const overlayPath = (0, path_1.join)(additionalTemplatesDir, relativePath);
+        if ((0, fs_1.existsSync)(overlayPath)) {
+            return overlayPath;
+        }
+    }
+    const basePath = (0, path_1.join)(TEMPLATES_DIR, relativePath);
+    if ((0, fs_1.existsSync)(basePath)) {
+        return basePath;
+    }
+    return undefined;
+};
+const copyClaudeMd = (workspaceDir, additionalTemplatesDir) => {
+    const src = resolveTemplateFile("CLAUDE.md", additionalTemplatesDir);
+    if (src) {
+        (0, fs_1.copyFileSync)(src, (0, path_1.join)(workspaceDir, ".claude", "CLAUDE.md"));
+    }
+};
+const copyClaudeSubdir = (workspaceDir, subdir, additionalTemplatesDir) => {
+    const destDir = (0, path_1.join)(workspaceDir, ".claude", subdir);
+    let copied = false;
+    const baseSrcDir = (0, path_1.join)(TEMPLATES_DIR, subdir);
+    if ((0, fs_1.existsSync)(baseSrcDir)) {
+        const entries = (0, fs_1.readdirSync)(baseSrcDir).filter((f) => !(0, fs_1.statSync)((0, path_1.join)(baseSrcDir, f)).isDirectory());
+        if (entries.length > 0) {
+            (0, fs_1.mkdirSync)(destDir, { recursive: true });
+            for (const filename of entries) {
+                (0, fs_1.copyFileSync)((0, path_1.join)(baseSrcDir, filename), (0, path_1.join)(destDir, filename));
+            }
+            copied = true;
+        }
+    }
+    if (additionalTemplatesDir) {
+        const overlaySrcDir = (0, path_1.join)(additionalTemplatesDir, subdir);
+        if ((0, fs_1.existsSync)(overlaySrcDir)) {
+            const entries = (0, fs_1.readdirSync)(overlaySrcDir).filter((f) => !(0, fs_1.statSync)((0, path_1.join)(overlaySrcDir, f)).isDirectory());
+            if (entries.length > 0) {
+                if (!copied) {
+                    (0, fs_1.mkdirSync)(destDir, { recursive: true });
+                }
+                for (const filename of entries) {
+                    (0, fs_1.copyFileSync)((0, path_1.join)(overlaySrcDir, filename), (0, path_1.join)(destDir, filename));
+                }
+            }
+        }
+    }
+};
+const copySkills = (workspaceDir, additionalTemplatesDir) => {
+    const skillDirNames = new Set();
+    const baseSrcDir = (0, path_1.join)(TEMPLATES_DIR, "skills");
+    if ((0, fs_1.existsSync)(baseSrcDir)) {
+        for (const entry of (0, fs_1.readdirSync)(baseSrcDir)) {
+            if ((0, fs_1.statSync)((0, path_1.join)(baseSrcDir, entry)).isDirectory()) {
+                skillDirNames.add(entry);
+            }
+        }
+    }
+    if (additionalTemplatesDir) {
+        const overlaySrcDir = (0, path_1.join)(additionalTemplatesDir, "skills");
+        if ((0, fs_1.existsSync)(overlaySrcDir)) {
+            for (const entry of (0, fs_1.readdirSync)(overlaySrcDir)) {
+                if ((0, fs_1.statSync)((0, path_1.join)(overlaySrcDir, entry)).isDirectory()) {
+                    skillDirNames.add(entry);
+                }
+            }
+        }
+    }
+    for (const skillName of skillDirNames) {
+        copyClaudeSubdir(workspaceDir, (0, path_1.join)("skills", skillName), additionalTemplatesDir);
+    }
+};
+// ---------------------------------------------------------------------------
+// Log filtering and diffs
+// ---------------------------------------------------------------------------
+const generateFilteredLogs = (workspaceDir) => {
+    const replaySubDirs = ["head", "base", "other"];
+    let count = 0;
+    for (const subDir of replaySubDirs) {
+        const subDirPath = (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "replays", subDir);
+        if (!(0, fs_1.existsSync)(subDirPath)) {
+            continue;
+        }
+        for (const replayId of (0, fs_1.readdirSync)(subDirPath)) {
+            const logPath = (0, path_1.join)(subDirPath, replayId, "logs.deterministic.txt");
+            if (!(0, fs_1.existsSync)(logPath)) {
+                continue;
+            }
+            const raw = (0, fs_1.readFileSync)(logPath, "utf8");
+            const filtered = filterLogLines(raw);
+            (0, fs_1.writeFileSync)((0, path_1.join)(subDirPath, replayId, "logs.deterministic.filtered.txt"), filtered);
+            count++;
+        }
+    }
+    if (count > 0) {
+        console.log(chalk_1.default.green(`  Generated ${count} filtered log file(s)`));
+    }
+};
+const LOG_NOISE_PATTERNS = [
+    /https?:\/\/[a-z0-9]+-[a-z0-9-]+-[a-z0-9]+\.tunnel-\d+\.tunnels\.meticulous\.ai/g,
+    /https?:\/\/[a-z0-9]+\.tunnel-\d+[^\s'")\]&]*/g,
+    /https?:\/\/[a-z0-9-]+\.lhr\.life[^\s'")\]&]*/g,
+    /https?:\/\/[a-z0-9-]+\.trycloudflare\.com[^\s'")\]&]*/g,
+    /X-Amz-Security-Token=[^\s&"']*/g,
+    /X-Amz-Credential=[^\s&"']*/g,
+    /X-Amz-Signature=[^\s&"']*/g,
+    /X-Amz-Date=[^\s&"']*/g,
+    /X-Amz-Expires=[^\s&"']*/g,
+    /"distinct_id":"[^"]*"/g,
+    /"token":"[^"]*"/g,
+    /"\$device_id":"[^"]*"/g,
+    /"\$session_id":"[^"]*"/g,
+    /"\$anon_distinct_id":"[^"]*"/g,
+    /"\$host":"[^"]*"/g,
+    /"\$current_url":"[^"]*"/g,
+    /"\$referrer":"[^"]*"/g,
+    /"\$initial_referrer":"[^"]*"/g,
+    /\/_next\/data\/[A-Za-z0-9_-]+\//g,
+    /\/_next\/static\/[A-Za-z0-9_-]{8,}\//g,
+    /(?<=[-./])[a-f0-9]{12,}(?=\.js)/g,
+    /(?<=[-./])[a-f0-9]{12,}(?=\.css)/g,
+    /(?<=["'/])[A-Za-z0-9_-]{20,}(?=["'/])/g,
+];
+const POSTHOG_LINE_PATTERNS = [
+    /us\.i\.posthog\.com/,
+    /\/decide\?/,
+    /\/e\?ip=1/,
+    /posthog-js/,
+    /\$autocapture/,
+    /\$pageview/,
+    /\$pageleave/,
+    /"event":"\$/,
+];
+const isPostHogLine = (content) => POSTHOG_LINE_PATTERNS.some((p) => p.test(content));
+const filterLine = (line) => {
+    let result = line;
+    for (const pattern of LOG_NOISE_PATTERNS) {
+        result = result.replace(new RegExp(pattern.source, pattern.flags || "g"), "<NOISE>");
+    }
+    result = result.replace(/\brequest\s+\d+\b/gi, "request <N>");
+    return result;
+};
+const filterLogLines = (raw) => {
+    const lines = raw.split("\n");
+    const filtered = [];
+    for (const line of lines) {
+        if (isPostHogLine(line)) {
+            continue;
+        }
+        filtered.push(filterLine(line));
+    }
+    return filtered.join("\n");
+};
+const generateLogDiffs = (debugContext, workspaceDir) => {
+    for (const diff of debugContext.replayDiffs) {
+        const headLogPath = (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "replays", "head", diff.headReplayId, "logs.deterministic.txt");
+        const baseLogPath = (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "replays", "base", diff.baseReplayId, "logs.deterministic.txt");
+        if (!(0, fs_1.existsSync)(headLogPath) || !(0, fs_1.existsSync)(baseLogPath)) {
+            continue;
+        }
+        const baseName = `${diff.headReplayId}-vs-${diff.baseReplayId}`;
+        generateLogDiffPair(baseLogPath, headLogPath, workspaceDir, baseName);
+    }
+    if (debugContext.replayDiffs.length === 0 &&
+        debugContext.replayIds.length === 2) {
+        const [idA, idB] = debugContext.replayIds;
+        const pathA = (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "replays", "other", idA, "logs.deterministic.txt");
+        const pathB = (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "replays", "other", idB, "logs.deterministic.txt");
+        if ((0, fs_1.existsSync)(pathA) && (0, fs_1.existsSync)(pathB)) {
+            generateLogDiffPair(pathA, pathB, workspaceDir, `${idA}-vs-${idB}`);
+        }
+    }
+};
+const generateLogDiffPair = (basePath, headPath, workspaceDir, baseName) => {
+    var _a;
+    const diffDir = (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "log-diffs");
+    (0, fs_1.mkdirSync)(diffDir, { recursive: true });
+    let rawDiff;
+    try {
+        rawDiff = (0, child_process_1.execFileSync)("diff", ["-u", basePath, headPath], {
+            encoding: "utf8",
+            maxBuffer: 10 * 1024 * 1024,
+        });
+    }
+    catch (error) {
+        rawDiff = (_a = error === null || error === void 0 ? void 0 : error.stdout) !== null && _a !== void 0 ? _a : "";
+    }
+    if (!rawDiff.trim()) {
+        return;
+    }
+    (0, fs_1.writeFileSync)((0, path_1.join)(diffDir, `${baseName}.diff`), rawDiff);
+    const filteredDiff = filterLogDiff(rawDiff);
+    if (filteredDiff.trim()) {
+        (0, fs_1.writeFileSync)((0, path_1.join)(diffDir, `${baseName}.filtered.diff`), filteredDiff);
+    }
+    const summary = summarizeLogDiff(rawDiff);
+    (0, fs_1.writeFileSync)((0, path_1.join)(diffDir, `${baseName}.summary.txt`), summary);
+};
+const filterLogDiff = (rawDiff) => {
+    const lines = rawDiff.split("\n");
+    const filteredLines = [];
+    for (const line of lines) {
+        if (!line.startsWith("+") && !line.startsWith("-")) {
+            filteredLines.push(line);
+            continue;
+        }
+        if (line.startsWith("+++") || line.startsWith("---")) {
+            filteredLines.push(line);
+            continue;
+        }
+        if (isPostHogLine(line)) {
+            continue;
+        }
+        filteredLines.push(filterLine(line));
+    }
+    return removeIdenticalHunks(filteredLines.join("\n"));
+};
+const removeIdenticalHunks = (diff) => {
+    var _a;
+    const parts = diff.split(/^(@@[^@]*@@.*$)/m);
+    const result = [parts[0]];
+    for (let i = 1; i < parts.length; i += 2) {
+        const hunkHeader = parts[i];
+        const hunkBody = (_a = parts[i + 1]) !== null && _a !== void 0 ? _a : "";
+        const addedLines = [];
+        const removedLines = [];
+        for (const line of hunkBody.split("\n")) {
+            if (line.startsWith("+") && !line.startsWith("+++")) {
+                addedLines.push(line.slice(1));
+            }
+            else if (line.startsWith("-") && !line.startsWith("---")) {
+                removedLines.push(line.slice(1));
+            }
+        }
+        if (addedLines.join("\n") !== removedLines.join("\n")) {
+            result.push(hunkHeader);
+            result.push(hunkBody);
+        }
+    }
+    return result.join("");
+};
+const summarizeLogDiff = (rawDiff) => {
+    const lines = rawDiff.split("\n");
+    let addedCount = 0;
+    let removedCount = 0;
+    let firstDivergenceLine;
+    const categories = {};
+    for (const line of lines) {
+        if (line.startsWith("@@")) {
+            const match = line.match(/@@ -(\d+)/);
+            if (match && firstDivergenceLine == null) {
+                firstDivergenceLine = parseInt(match[1], 10);
+            }
+            continue;
+        }
+        if (line.startsWith("+") && !line.startsWith("+++")) {
+            addedCount++;
+            categorizeLogLine(line, categories, "added");
+        }
+        else if (line.startsWith("-") && !line.startsWith("---")) {
+            removedCount++;
+            categorizeLogLine(line, categories, "removed");
+        }
+    }
+    const sortedCategories = Object.entries(categories).sort(([, a], [, b]) => b.added + b.removed - (a.added + a.removed));
+    const parts = [
+        `Log Diff Summary`,
+        `================`,
+        ``,
+        `Total changed lines: ${addedCount + removedCount} (+${addedCount} in head, -${removedCount} in base)`,
+        `First divergence at base log line: ${firstDivergenceLine !== null && firstDivergenceLine !== void 0 ? firstDivergenceLine : "unknown"}`,
+        ``,
+        `Change categories (+ = extra in head, - = extra in base):`,
+    ];
+    for (const [category, counts] of sortedCategories) {
+        const total = counts.added + counts.removed;
+        const net = counts.added - counts.removed;
+        const netStr = net > 0
+            ? `net +${net} in head`
+            : net < 0
+                ? `net ${net} in base`
+                : "balanced";
+        parts.push(`  ${category}: ${total} lines (+${counts.added} / -${counts.removed}, ${netStr})`);
+    }
+    parts.push("", "Tip: Read the .filtered.diff file for a version with tunnel URLs,", "PostHog payloads, and S3 tokens stripped. Hunks that only differ", "in these noisy values are removed entirely.");
+    return parts.join("\n");
+};
+const categorizeLogLine = (line, categories, direction) => {
+    var _a;
+    const content = line.slice(1);
+    const category = classifyLogContent(content);
+    const entry = (_a = categories[category]) !== null && _a !== void 0 ? _a : { added: 0, removed: 0 };
+    entry[direction]++;
+    categories[category] = entry;
+};
+const classifyLogContent = (content) => {
+    if (LOG_NOISE_PATTERNS.some((p) => new RegExp(p.source).test(content))) {
+        return "noise (tunnel URLs / tokens / PostHog)";
+    }
+    if (/\bfetch\b|\bXHR\b|\bnetwork\b|\brequest\b|\bresponse\b/i.test(content)) {
+        return "network";
+    }
+    if (/animation|requestAnimationFrame|rAF/i.test(content)) {
+        return "animation frames";
+    }
+    if (/screenshot/i.test(content)) {
+        return "screenshots";
+    }
+    if (/timer|setTimeout|setInterval|tick/i.test(content)) {
+        return "timers";
+    }
+    if (/navigation|navigate|pushState|replaceState|popstate/i.test(content)) {
+        return "navigation";
+    }
+    if (/priority|ordering|reorder/i.test(content)) {
+        return "priority / ordering";
+    }
+    return "other";
+};
+const generateDiffSummaries = (workspaceDir) => {
+    var _a, _b;
+    const diffsDir = (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "diffs");
+    if (!(0, fs_1.existsSync)(diffsDir)) {
+        return;
+    }
+    let count = 0;
+    const jsonFiles = (0, fs_1.readdirSync)(diffsDir).filter((f) => f.endsWith(".json") && !f.endsWith(".summary.json"));
+    for (const file of jsonFiles) {
+        const raw = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(diffsDir, file), "utf8"));
+        const results = (_b = (_a = raw === null || raw === void 0 ? void 0 : raw.data) === null || _a === void 0 ? void 0 : _a.screenshotDiffResults) !== null && _b !== void 0 ? _b : [];
+        if (results.length === 0) {
+            continue;
+        }
+        const compact = results.map((r) => {
+            const dtb = r.diffToBaseScreenshot;
+            return {
+                identifier: r.identifier,
+                outcome: r.outcome,
+                ...(dtb
+                    ? {
+                        width: dtb.width,
+                        height: dtb.height,
+                        mismatchPixels: dtb.mismatchPixels,
+                        mismatchFraction: dtb.mismatchFraction,
+                        mismatchPercent: dtb.mismatchFraction != null
+                            ? `${(dtb.mismatchFraction * 100).toFixed(4)}%`
+                            : undefined,
+                        diffFullFile: dtb.diffFullFile,
+                        changedSectionsClassNames: dtb.changedSectionsClassNames,
+                    }
+                    : {}),
+            };
+        });
+        const summaryFile = file.replace(".json", ".summary.json");
+        (0, fs_1.writeFileSync)((0, path_1.join)(diffsDir, summaryFile), JSON.stringify(compact, null, 2));
+        count++;
+    }
+    if (count > 0) {
+        console.log(chalk_1.default.green(`  Generated ${count} compact diff summary(ies) in diffs/`));
+    }
+};
+// ---------------------------------------------------------------------------
+// PR diff from project repo
+// ---------------------------------------------------------------------------
+const generatePrDiff = (debugContext, workspaceDir) => {
+    var _a;
+    const projectRepoDir = (0, path_1.join)(workspaceDir, "project-repo");
+    if (!(0, fs_1.existsSync)(projectRepoDir)) {
+        return;
+    }
+    const headSha = debugContext.commitSha;
+    const baseSha = debugContext.baseCommitSha;
+    if (!headSha) {
+        return;
+    }
+    const effectiveBaseSha = baseSha !== null && baseSha !== void 0 ? baseSha : resolveBaseShaFromGit(projectRepoDir, headSha);
+    if (!effectiveBaseSha) {
+        return;
+    }
+    let diffOutput;
+    try {
+        diffOutput = (0, child_process_1.execFileSync)("git", ["diff", `${effectiveBaseSha}..${headSha}`], { cwd: projectRepoDir, encoding: "utf8", maxBuffer: 50 * 1024 * 1024 });
+    }
+    catch (error) {
+        diffOutput = (_a = error === null || error === void 0 ? void 0 : error.stdout) !== null && _a !== void 0 ? _a : "";
+    }
+    if (diffOutput.trim()) {
+        (0, fs_1.writeFileSync)((0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "pr-diff.txt"), diffOutput);
+        console.log(chalk_1.default.green(`  Generated PR diff (${effectiveBaseSha.slice(0, 8)}..${headSha.slice(0, 8)})`));
+    }
+};
+const resolveBaseShaFromGit = (repoDir, headSha) => {
+    for (const branch of ["origin/main", "origin/master"]) {
+        try {
+            const mergeBase = (0, child_process_1.execFileSync)("git", ["merge-base", branch, headSha], { cwd: repoDir, encoding: "utf8" }).trim();
+            if (mergeBase) {
+                return mergeBase;
+            }
+        }
+        catch {
+            // Try next branch name
+        }
+    }
+    return undefined;
+};
+// ---------------------------------------------------------------------------
+// Params diffs
+// ---------------------------------------------------------------------------
+const generateParamsDiffs = (debugContext, workspaceDir) => {
+    var _a;
+    const paramsFile = "launchBrowserAndReplayParams.json";
+    const pairs = [];
+    for (const diff of debugContext.replayDiffs) {
+        pairs.push({
+            pathA: (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "replays", "base", diff.baseReplayId, paramsFile),
+            pathB: (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "replays", "head", diff.headReplayId, paramsFile),
+            label: `${diff.headReplayId}-vs-${diff.baseReplayId}`,
+        });
+    }
+    if (debugContext.replayDiffs.length === 0 &&
+        debugContext.replayIds.length === 2) {
+        const [idA, idB] = debugContext.replayIds;
+        pairs.push({
+            pathA: (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "replays", "other", idA, paramsFile),
+            pathB: (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "replays", "other", idB, paramsFile),
+            label: `${idA}-vs-${idB}`,
+        });
+    }
+    for (const { pathA, pathB, label } of pairs) {
+        if (!(0, fs_1.existsSync)(pathA) || !(0, fs_1.existsSync)(pathB)) {
+            continue;
+        }
+        try {
+            const jsonA = sortedJsonString((0, fs_1.readFileSync)(pathA, "utf8"));
+            const jsonB = sortedJsonString((0, fs_1.readFileSync)(pathB, "utf8"));
+            if (jsonA === jsonB) {
+                continue;
+            }
+            const tmpA = (0, path_1.join)(workspaceDir, ".tmp-params-a.json");
+            const tmpB = (0, path_1.join)(workspaceDir, ".tmp-params-b.json");
+            (0, fs_1.writeFileSync)(tmpA, jsonA);
+            (0, fs_1.writeFileSync)(tmpB, jsonB);
+            let diffOutput;
+            try {
+                diffOutput = (0, child_process_1.execFileSync)("diff", ["-u", tmpA, tmpB], {
+                    encoding: "utf8",
+                    maxBuffer: 5 * 1024 * 1024,
+                });
+            }
+            catch (diffError) {
+                diffOutput = (_a = diffError === null || diffError === void 0 ? void 0 : diffError.stdout) !== null && _a !== void 0 ? _a : "";
+            }
+            finally {
+                safeUnlink(tmpA);
+                safeUnlink(tmpB);
+            }
+            if (diffOutput.trim()) {
+                const diffsDir = (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "params-diffs");
+                (0, fs_1.mkdirSync)(diffsDir, { recursive: true });
+                (0, fs_1.writeFileSync)((0, path_1.join)(diffsDir, `${label}.diff`), diffOutput);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`  Warning: Could not diff params for ${label}: ${message}`);
+        }
+    }
+    const diffsDir = (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "params-diffs");
+    if ((0, fs_1.existsSync)(diffsDir) && (0, fs_1.readdirSync)(diffsDir).length > 0) {
+        console.log(chalk_1.default.green("  Generated replay params diff(s) in params-diffs/"));
+    }
+};
+const sortedJsonString = (raw) => {
+    const parsed = JSON.parse(raw);
+    return JSON.stringify(sortObjectKeys(parsed), null, 2);
+};
+const sortObjectKeys = (value) => {
+    if (value == null || typeof value !== "object") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map(sortObjectKeys);
+    }
+    const sorted = {};
+    for (const key of Object.keys(value).sort()) {
+        sorted[key] = sortObjectKeys(value[key]);
+    }
+    return sorted;
+};
+const safeUnlink = (filePath) => {
+    try {
+        (0, fs_1.unlinkSync)(filePath);
+    }
+    catch {
+        // Non-critical
+    }
+};
+// ---------------------------------------------------------------------------
+// Assets diffs
+// ---------------------------------------------------------------------------
+const generateAssetsDiff = (debugContext, workspaceDir) => {
+    for (const diff of debugContext.replayDiffs) {
+        const headAssetsDir = (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "replays", "head", diff.headReplayId, "snapshotted-assets");
+        const baseAssetsDir = (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "replays", "base", diff.baseReplayId, "snapshotted-assets");
+        const report = compareAssetDirs(baseAssetsDir, headAssetsDir);
+        if (!report) {
+            continue;
+        }
+        const diffsDir = (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "assets-diffs");
+        (0, fs_1.mkdirSync)(diffsDir, { recursive: true });
+        (0, fs_1.writeFileSync)((0, path_1.join)(diffsDir, `${diff.headReplayId}-vs-${diff.baseReplayId}.txt`), report);
+    }
+    const diffsDir = (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "assets-diffs");
+    if ((0, fs_1.existsSync)(diffsDir) && (0, fs_1.readdirSync)(diffsDir).length > 0) {
+        console.log(chalk_1.default.green("  Generated snapshotted assets diff(s) in assets-diffs/"));
+    }
+};
+const compareAssetDirs = (baseDir, headDir) => {
+    var _a;
+    const baseFiles = listAssetFiles(baseDir);
+    const headFiles = listAssetFiles(headDir);
+    if (baseFiles.size === 0 && headFiles.size === 0) {
+        return undefined;
+    }
+    const allNames = new Set([...baseFiles.keys(), ...headFiles.keys()]);
+    const added = [];
+    const removed = [];
+    const changed = [];
+    const unchanged = [];
+    for (const name of [...allNames].sort()) {
+        const baseInfo = baseFiles.get(name);
+        const headInfo = headFiles.get(name);
+        if (!baseInfo) {
+            added.push(`  + ${name} (${(_a = headInfo === null || headInfo === void 0 ? void 0 : headInfo.size) !== null && _a !== void 0 ? _a : 0} bytes)`);
+        }
+        else if (!headInfo) {
+            removed.push(`  - ${name} (${baseInfo.size} bytes)`);
+        }
+        else if (baseInfo.hash !== headInfo.hash) {
+            changed.push(`  ~ ${name} (${baseInfo.size} -> ${headInfo.size} bytes)`);
+        }
+        else {
+            unchanged.push(name);
+        }
+    }
+    if (added.length === 0 && removed.length === 0 && changed.length === 0) {
+        return undefined;
+    }
+    const parts = [
+        "Snapshotted Assets Diff",
+        "=======================",
+        `Total: ${allNames.size} files (${added.length} added, ${removed.length} removed, ${changed.length} changed, ${unchanged.length} unchanged)`,
+        "",
+    ];
+    if (added.length > 0) {
+        parts.push("Added:", ...added, "");
+    }
+    if (removed.length > 0) {
+        parts.push("Removed:", ...removed, "");
+    }
+    if (changed.length > 0) {
+        parts.push("Changed:", ...changed, "");
+    }
+    return parts.join("\n");
+};
+const listAssetFiles = (dir) => {
+    const result = new Map();
+    if (!(0, fs_1.existsSync)(dir)) {
+        return result;
+    }
+    const walk = (currentDir, relativeTo) => {
+        const entries = (0, fs_1.readdirSync)(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const relativePath = relativeTo
+                ? `${relativeTo}/${entry.name}`
+                : entry.name;
+            if (entry.isDirectory()) {
+                walk((0, path_1.join)(currentDir, entry.name), relativePath);
+            }
+            else {
+                const content = (0, fs_1.readFileSync)((0, path_1.join)(currentDir, entry.name));
+                const hash = (0, crypto_1.createHash)("md5").update(content).digest("hex");
+                result.set(relativePath, { size: content.length, hash });
+            }
+        }
+    };
+    walk(dir, "");
+    return result;
+};
+// ---------------------------------------------------------------------------
+// Timeline summaries
+// ---------------------------------------------------------------------------
+const generateTimelineSummaries = (workspaceDir) => {
+    const replaySubDirs = ["head", "base", "other"];
+    let count = 0;
+    for (const subDir of replaySubDirs) {
+        const subDirPath = (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "replays", subDir);
+        if (!(0, fs_1.existsSync)(subDirPath)) {
+            continue;
+        }
+        for (const replayId of (0, fs_1.readdirSync)(subDirPath)) {
+            const timelinePath = (0, path_1.join)(subDirPath, replayId, "timeline.json");
+            if (!(0, fs_1.existsSync)(timelinePath)) {
+                continue;
+            }
+            const timeline = JSON.parse((0, fs_1.readFileSync)(timelinePath, "utf8"));
+            if (!Array.isArray(timeline)) {
+                continue;
+            }
+            const summary = summarizeTimeline(timeline, replayId, subDir);
+            const summaryDir = (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "timeline-summaries");
+            (0, fs_1.mkdirSync)(summaryDir, { recursive: true });
+            (0, fs_1.writeFileSync)((0, path_1.join)(summaryDir, `${subDir}-${replayId}.txt`), summary);
+            count++;
+        }
+    }
+    if (count > 0) {
+        console.log(chalk_1.default.green(`  Generated ${count} timeline summary(ies) in timeline-summaries/`));
+    }
+};
+const summarizeTimeline = (timeline, replayId, role) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const eventKindCounts = {};
+    const screenshotEntries = [];
+    let navigationCount = 0;
+    let networkRequestCount = 0;
+    let animationFrameCount = 0;
+    let consoleMessageCount = 0;
+    let firstVirtualTime;
+    let lastVirtualTime;
+    const flakinessWarnings = [];
+    for (const entry of timeline) {
+        const kind = entry.kind;
+        eventKindCounts[kind] = ((_a = eventKindCounts[kind]) !== null && _a !== void 0 ? _a : 0) + 1;
+        const vt = entry.virtualTimeStart;
+        if (vt != null) {
+            if (firstVirtualTime == null || vt < firstVirtualTime) {
+                firstVirtualTime = vt;
+            }
+            if (lastVirtualTime == null || vt > lastVirtualTime) {
+                lastVirtualTime = vt;
+            }
+        }
+        if (kind.startsWith("potentialFlakinessWarning")) {
+            flakinessWarnings.push({
+                kind,
+                message: (_e = (_c = (_b = entry.data) === null || _b === void 0 ? void 0 : _b.message) !== null && _c !== void 0 ? _c : (_d = entry.data) === null || _d === void 0 ? void 0 : _d.warning) !== null && _e !== void 0 ? _e : JSON.stringify((_f = entry.data) !== null && _f !== void 0 ? _f : {}),
+                virtualTime: vt,
+            });
+        }
+        switch (kind) {
+            case "screenshot": {
+                const filename = ((_g = entry.data) === null || _g === void 0 ? void 0 : _g.identifier)
+                    ? screenshotIdentifierToFilename(entry.data.identifier)
+                    : undefined;
+                screenshotEntries.push({
+                    filename: filename !== null && filename !== void 0 ? filename : "unknown",
+                    virtualTime: vt,
+                });
+                break;
+            }
+            case "initialNavigation":
+            case "navigation":
+                navigationCount++;
+                break;
+            case "pollyReplay":
+                networkRequestCount++;
+                break;
+            case "jsReplay":
+                animationFrameCount++;
+                break;
+            default:
+                if (kind.startsWith("consoleMessage")) {
+                    consoleMessageCount++;
+                }
+                break;
+        }
+    }
+    const totalVirtualTimeMs = firstVirtualTime != null && lastVirtualTime != null
+        ? lastVirtualTime - firstVirtualTime
+        : undefined;
+    const sortedKinds = Object.entries(eventKindCounts).sort(([, a], [, b]) => b - a);
+    const parts = [
+        `Timeline Summary: ${role}/${replayId}`,
+        "=".repeat(40 + role.length + replayId.length),
+        "",
+        `Total timeline entries: ${timeline.length}`,
+        `Total virtual time: ${totalVirtualTimeMs != null ? `${totalVirtualTimeMs}ms` : "unknown"}`,
+        `Virtual time range: ${firstVirtualTime !== null && firstVirtualTime !== void 0 ? firstVirtualTime : "?"} - ${lastVirtualTime !== null && lastVirtualTime !== void 0 ? lastVirtualTime : "?"}`,
+        "",
+        "Key counts:",
+        `  Screenshots: ${screenshotEntries.length}`,
+        `  Navigations: ${navigationCount}`,
+        `  Network requests: ${networkRequestCount}`,
+        `  Animation frames (jsReplay): ${animationFrameCount}`,
+        `  Console messages: ${consoleMessageCount}`,
+        "",
+        "All event kinds:",
+    ];
+    for (const [kind, count] of sortedKinds) {
+        parts.push(`  ${kind}: ${count}`);
+    }
+    if (screenshotEntries.length > 0) {
+        parts.push("", "Screenshots:");
+        for (const ss of screenshotEntries) {
+            parts.push(`  ${ss.filename}  @ virtualTime ${ss.virtualTime != null ? `${ss.virtualTime}ms` : "unknown"}`);
+        }
+    }
+    if (flakinessWarnings.length > 0) {
+        parts.push("", "Potential flakiness warnings:");
+        for (const fw of flakinessWarnings) {
+            parts.push(`  [${fw.kind}] @ virtualTime ${fw.virtualTime != null ? `${fw.virtualTime}ms` : "unknown"}`);
+            parts.push(`    ${fw.message}`);
+        }
+    }
+    return parts.join("\n");
+};
+// ---------------------------------------------------------------------------
+// Prettify snapshot assets
+// ---------------------------------------------------------------------------
+const MAX_ASSET_SIZE_BYTES = 1024 * 1024;
+const prettifySnapshotAssets = (workspaceDir) => {
+    const prettierPath = findPrettier();
+    if (!prettierPath) {
+        console.log(chalk_1.default.gray("  Skipping asset formatting (prettier not found on PATH)."));
+        return;
+    }
+    const replaySubDirs = ["head", "base", "other"];
+    let copiedCount = 0;
+    let skippedLargeCount = 0;
+    for (const subDir of replaySubDirs) {
+        const subDirPath = (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "replays", subDir);
+        if (!(0, fs_1.existsSync)(subDirPath)) {
+            continue;
+        }
+        for (const replayId of (0, fs_1.readdirSync)(subDirPath)) {
+            const assetsDir = (0, path_1.join)(subDirPath, replayId, "snapshotted-assets");
+            if (!(0, fs_1.existsSync)(assetsDir)) {
+                continue;
+            }
+            let assetFiles;
+            try {
+                assetFiles = findAssetFilesRecursive(assetsDir, "");
+            }
+            catch {
+                continue;
+            }
+            if (assetFiles.length === 0) {
+                continue;
+            }
+            const formattedDir = (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "formatted-assets", subDir, replayId);
+            for (const relativePath of assetFiles) {
+                const srcPath = (0, path_1.join)(assetsDir, relativePath);
+                const fileSize = (0, fs_1.statSync)(srcPath).size;
+                if (fileSize > MAX_ASSET_SIZE_BYTES) {
+                    skippedLargeCount++;
+                    continue;
+                }
+                const destPath = (0, path_1.join)(formattedDir, relativePath);
+                (0, fs_1.mkdirSync)((0, path_1.dirname)(destPath), { recursive: true });
+                (0, fs_1.copyFileSync)(srcPath, destPath);
+                copiedCount++;
+            }
+        }
+    }
+    if (copiedCount === 0) {
+        return;
+    }
+    const formattedAssetsDir = (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "formatted-assets");
+    try {
+        (0, child_process_1.execFileSync)(prettierPath, ["--write", `${formattedAssetsDir}/**/*.{js,css}`], {
+            timeout: 120000,
+            stdio: "ignore",
+        });
+        console.log(chalk_1.default.green(`  Formatted ${copiedCount} snapshotted asset(s) in formatted-assets/`));
+    }
+    catch {
+        console.log(chalk_1.default.yellow(`  Copied ${copiedCount} snapshotted asset(s) to formatted-assets/ (prettier formatting partially failed)`));
+    }
+    if (skippedLargeCount > 0) {
+        console.log(chalk_1.default.gray(`  Skipped ${skippedLargeCount} large asset(s) over ${MAX_ASSET_SIZE_BYTES / (1024 * 1024)}MB`));
+    }
+};
+const findPrettier = () => {
+    try {
+        const whichResult = (0, child_process_1.execFileSync)("which", ["prettier"], {
+            encoding: "utf8",
+        }).trim();
+        if (whichResult) {
+            return whichResult;
+        }
+    }
+    catch {
+        // Not on PATH
+    }
+    return undefined;
+};
+const findAssetFilesRecursive = (baseDir, relativeTo) => {
+    const results = [];
+    const entries = (0, fs_1.readdirSync)(baseDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const relativePath = relativeTo
+            ? `${relativeTo}/${entry.name}`
+            : entry.name;
+        if (entry.isDirectory()) {
+            results.push(...findAssetFilesRecursive((0, path_1.join)(baseDir, entry.name), relativePath));
+        }
+        else if (entry.name.endsWith(".js") || entry.name.endsWith(".css")) {
+            results.push(relativePath);
+        }
+    }
+    return results;
+};
+// ---------------------------------------------------------------------------
+// Screenshot map & context
+// ---------------------------------------------------------------------------
+const SCREENSHOT_LOG_CONTEXT_LINES = 30;
+const buildScreenshotMap = (debugContext, workspaceDir) => {
+    var _a, _b, _c, _d;
+    const map = {};
+    for (const subDir of ["head", "base", "other"]) {
+        const subDirPath = (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "replays", subDir);
+        if (!(0, fs_1.existsSync)(subDirPath)) {
+            continue;
+        }
+        for (const replayId of (0, fs_1.readdirSync)(subDirPath)) {
+            const timelinePath = (0, path_1.join)(subDirPath, replayId, "timeline.json");
+            if (!(0, fs_1.existsSync)(timelinePath)) {
+                continue;
+            }
+            const timeline = JSON.parse((0, fs_1.readFileSync)(timelinePath, "utf8"));
+            if (!Array.isArray(timeline)) {
+                continue;
+            }
+            for (const entry of timeline) {
+                const e = entry;
+                if (e.kind !== "screenshot" || !((_a = e.data) === null || _a === void 0 ? void 0 : _a.identifier)) {
+                    continue;
+                }
+                const filename = screenshotIdentifierToFilename(e.data.identifier);
+                if (!filename) {
+                    continue;
+                }
+                map[`${subDir}/${replayId}/${filename}`] = {
+                    replayId,
+                    replayRole: subDir,
+                    filename,
+                    virtualTimeStart: (_b = e.virtualTimeStart) !== null && _b !== void 0 ? _b : null,
+                    virtualTimeEnd: (_c = e.virtualTimeEnd) !== null && _c !== void 0 ? _c : null,
+                    eventNumber: (_d = e.data.identifier.eventNumber) !== null && _d !== void 0 ? _d : null,
+                };
+            }
+        }
+    }
+    if (Object.keys(map).length > 0) {
+        console.log(chalk_1.default.green(`  Mapped ${Object.keys(map).length} screenshot(s) to virtual timestamps`));
+    }
+    return map;
+};
+const screenshotIdentifierToFilename = (identifier) => {
+    const variantPortion = identifier.variant === "redacted" ? ".redacted" : "";
+    if (identifier.type === "end-state") {
+        return identifier.logicVersion == null
+            ? `final-state${variantPortion}.png`
+            : `final-state-v${identifier.logicVersion}${variantPortion}.png`;
+    }
+    if (identifier.type === "after-event" && identifier.eventNumber != null) {
+        const eventIndexStr = identifier.eventNumber.toString().padStart(5, "0");
+        return identifier.logicVersion == null
+            ? `screenshot-after-event-${eventIndexStr}${variantPortion}.png`
+            : `screenshot-after-event-${eventIndexStr}-v${identifier.logicVersion}${variantPortion}.png`;
+    }
+    return undefined;
+};
+const generateScreenshotContext = (debugContext, workspaceDir, screenshotMap) => {
+    var _a, _b, _c, _d;
+    if (!debugContext.screenshot) {
+        return;
+    }
+    const targetScreenshot = debugContext.screenshot;
+    let count = 0;
+    for (const diff of debugContext.replayDiffs) {
+        const headLogPath = (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "replays", "head", diff.headReplayId, "logs.deterministic.txt");
+        const baseLogPath = (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "replays", "base", diff.baseReplayId, "logs.deterministic.txt");
+        const headEntry = screenshotMap[`head/${diff.headReplayId}/${targetScreenshot}`];
+        const baseEntry = screenshotMap[`base/${diff.baseReplayId}/${targetScreenshot}`];
+        const parts = [
+            `Screenshot Context: ${targetScreenshot}`,
+            "=".repeat(40 + targetScreenshot.length),
+            "",
+        ];
+        if (headEntry) {
+            parts.push(`HEAD (${diff.headReplayId}) @ virtualTime ${(_a = headEntry.virtualTimeStart) !== null && _a !== void 0 ? _a : "?"}ms, event ${(_b = headEntry.eventNumber) !== null && _b !== void 0 ? _b : "?"}:`, "");
+            const headContext = extractLogContext(headLogPath, headEntry);
+            parts.push(headContext !== null && headContext !== void 0 ? headContext : "  (could not extract log context)", "");
+        }
+        if (baseEntry) {
+            parts.push(`BASE (${diff.baseReplayId}) @ virtualTime ${(_c = baseEntry.virtualTimeStart) !== null && _c !== void 0 ? _c : "?"}ms, event ${(_d = baseEntry.eventNumber) !== null && _d !== void 0 ? _d : "?"}:`, "");
+            const baseContext = extractLogContext(baseLogPath, baseEntry);
+            parts.push(baseContext !== null && baseContext !== void 0 ? baseContext : "  (could not extract log context)", "");
+        }
+        if (headEntry || baseEntry) {
+            const contextDir = (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "screenshot-context");
+            (0, fs_1.mkdirSync)(contextDir, { recursive: true });
+            (0, fs_1.writeFileSync)((0, path_1.join)(contextDir, `${diff.headReplayId}-vs-${diff.baseReplayId}-${targetScreenshot.replace(".png", "")}.txt`), parts.join("\n"));
+            count++;
+        }
+    }
+    if (count > 0) {
+        console.log(chalk_1.default.green(`  Generated screenshot context for ${targetScreenshot} in screenshot-context/`));
+    }
+};
+const extractLogContext = (logPath, entry) => {
+    if (!(0, fs_1.existsSync)(logPath) || entry.virtualTimeStart == null) {
+        return undefined;
+    }
+    const lines = (0, fs_1.readFileSync)(logPath, "utf8").split("\n");
+    const targetVt = entry.virtualTimeStart;
+    let bestLine = -1;
+    let bestDist = Infinity;
+    for (let i = 0; i < lines.length; i++) {
+        if (!/screenshot/i.test(lines[i])) {
+            continue;
+        }
+        const vtMatch = lines[i].match(/\[virtual:\s*([\d.]+)ms\]/);
+        if (!vtMatch) {
+            continue;
+        }
+        const vt = parseFloat(vtMatch[1]);
+        const dist = Math.abs(vt - targetVt);
+        if (dist < bestDist) {
+            bestDist = dist;
+            bestLine = i;
+        }
+    }
+    if (bestLine < 0) {
+        return undefined;
+    }
+    const start = Math.max(0, bestLine - SCREENSHOT_LOG_CONTEXT_LINES);
+    const end = Math.min(lines.length, bestLine + SCREENSHOT_LOG_CONTEXT_LINES + 1);
+    const contextLines = lines.slice(start, end);
+    contextLines[bestLine - start] = `>>> ${contextLines[bestLine - start]}`;
+    return contextLines.join("\n");
+};
+// ---------------------------------------------------------------------------
+// Replay comparison
+// ---------------------------------------------------------------------------
+const buildReplayComparison = (debugContext, workspaceDir) => {
+    const entries = [];
+    for (const subDir of ["head", "base", "other"]) {
+        const subDirPath = (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "replays", subDir);
+        if (!(0, fs_1.existsSync)(subDirPath)) {
+            continue;
+        }
+        for (const replayId of (0, fs_1.readdirSync)(subDirPath)) {
+            const replayDir = (0, path_1.join)(subDirPath, replayId);
+            const stats = extractReplayStats(replayDir);
+            entries.push({ replayId, role: subDir, ...stats });
+        }
+    }
+    if (entries.length >= 2) {
+        console.log(chalk_1.default.green(`  Generated replay comparison for ${entries.length} replay(s)`));
+    }
+    return entries;
+};
+const extractReplayStats = (replayDir) => {
+    var _a, _b, _c;
+    const stats = {
+        totalEvents: null,
+        totalNetworkRequests: null,
+        totalAnimationFrames: null,
+        totalVirtualTimeMs: null,
+        screenshotCount: null,
+    };
+    const timelineStatsPath = (0, path_1.join)(replayDir, "timeline-stats.json");
+    if ((0, fs_1.existsSync)(timelineStatsPath)) {
+        const timelineStats = JSON.parse((0, fs_1.readFileSync)(timelineStatsPath, "utf8"));
+        const counts = (_a = timelineStats.countByType) !== null && _a !== void 0 ? _a : {};
+        stats.totalEvents = Object.values(counts).reduce((sum, n) => sum + n, 0);
+        stats.totalNetworkRequests = (_b = counts["pollyReplay"]) !== null && _b !== void 0 ? _b : null;
+        stats.totalAnimationFrames = (_c = counts["jsReplay"]) !== null && _c !== void 0 ? _c : null;
+    }
+    const timelinePath = (0, path_1.join)(replayDir, "timeline.json");
+    if ((0, fs_1.existsSync)(timelinePath)) {
+        const timeline = JSON.parse((0, fs_1.readFileSync)(timelinePath, "utf8"));
+        if (Array.isArray(timeline) && timeline.length > 0) {
+            let minVt;
+            let maxVt;
+            for (const entry of timeline) {
+                const vt = entry.virtualTimeStart;
+                if (vt != null) {
+                    if (minVt == null || vt < minVt) {
+                        minVt = vt;
+                    }
+                    if (maxVt == null || vt > maxVt) {
+                        maxVt = vt;
+                    }
+                }
+            }
+            if (minVt != null && maxVt != null) {
+                stats.totalVirtualTimeMs = Math.round(maxVt - minVt);
+            }
+        }
+    }
+    const replayId = (0, path_1.basename)(replayDir);
+    const screenshotsDir = (0, path_1.join)((0, common_1.getMeticulousLocalDataDir)(), "replays", replayId, "screenshots");
+    if ((0, fs_1.existsSync)(screenshotsDir)) {
+        stats.screenshotCount = (0, fs_1.readdirSync)(screenshotsDir).filter((f) => f.endsWith(".png")).length;
+    }
+    return stats;
+};
+// ---------------------------------------------------------------------------
+// File metadata
+// ---------------------------------------------------------------------------
+const collectFileMetadata = (debugContext, workspaceDir) => {
+    const entries = [];
+    const replayFiles = [
+        "logs.deterministic.txt",
+        "logs.deterministic.filtered.txt",
+        "logs.concise.txt",
+        "timeline.json",
+        "timeline-stats.json",
+        "metadata.json",
+        "launchBrowserAndReplayParams.json",
+        "stackTraces.json",
+        "accuracyData.json",
+    ];
+    for (const subDir of ["head", "base", "other"]) {
+        const subDirPath = (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "replays", subDir);
+        if (!(0, fs_1.existsSync)(subDirPath)) {
+            continue;
+        }
+        for (const replayId of (0, fs_1.readdirSync)(subDirPath)) {
+            for (const fileName of replayFiles) {
+                const filePath = (0, path_1.join)(subDirPath, replayId, fileName);
+                const relativePath = `${debug_constants_1.DEBUG_DATA_DIRECTORY}/replays/${subDir}/${replayId}/${fileName}`;
+                const meta = getFileMetadata(filePath, relativePath);
+                if (meta) {
+                    entries.push(meta);
+                }
+            }
+        }
+    }
+    for (const sessionId of debugContext.sessionIds) {
+        const filePath = (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "sessions", sessionId, "data.json");
+        const meta = getFileMetadata(filePath, `${debug_constants_1.DEBUG_DATA_DIRECTORY}/sessions/${sessionId}/data.json`);
+        if (meta) {
+            entries.push(meta);
+        }
+        const summaryPath = (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "session-summaries", `${sessionId}.txt`);
+        const summaryMeta = getFileMetadata(summaryPath, `${debug_constants_1.DEBUG_DATA_DIRECTORY}/session-summaries/${sessionId}.txt`);
+        if (summaryMeta) {
+            entries.push(summaryMeta);
+        }
+    }
+    return entries;
+};
+const getFileMetadata = (filePath, relativePath) => {
+    if (!(0, fs_1.existsSync)(filePath)) {
+        return undefined;
+    }
+    const buf = (0, fs_1.readFileSync)(filePath);
+    let lines = 0;
+    for (let i = 0; i < buf.length; i++) {
+        if (buf[i] === 0x0a) {
+            lines++;
+        }
+    }
+    return { path: relativePath, bytes: buf.length, lines };
+};
+const generateSessionSummaries = (debugContext, workspaceDir) => {
+    let count = 0;
+    for (const sessionId of debugContext.sessionIds) {
+        const dataPath = (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "sessions", sessionId, "data.json");
+        if (!(0, fs_1.existsSync)(dataPath)) {
+            continue;
+        }
+        try {
+            const raw = JSON.parse((0, fs_1.readFileSync)(dataPath, "utf8"));
+            const summary = summarizeSession(raw, sessionId);
+            const summaryDir = (0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "session-summaries");
+            (0, fs_1.mkdirSync)(summaryDir, { recursive: true });
+            (0, fs_1.writeFileSync)((0, path_1.join)(summaryDir, `${sessionId}.txt`), summary);
+            count++;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`  Warning: Could not summarize session ${sessionId}: ${message}`);
+        }
+    }
+    if (count > 0) {
+        console.log(chalk_1.default.green(`  Generated ${count} session summary(ies) in session-summaries/`));
+    }
+};
+const summarizeSession = (data, sessionId) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5;
+    const parts = [
+        `Session Summary: ${sessionId}`,
+        "=".repeat(20 + sessionId.length),
+        "",
+    ];
+    const win = (_a = data.userEvents) === null || _a === void 0 ? void 0 : _a.window;
+    parts.push(`Window: ${(_b = win === null || win === void 0 ? void 0 : win.startUrl) !== null && _b !== void 0 ? _b : "unknown"}`);
+    if ((win === null || win === void 0 ? void 0 : win.width) != null && (win === null || win === void 0 ? void 0 : win.height) != null) {
+        parts.push(`Viewport: ${win.width} x ${win.height}`);
+    }
+    parts.push(`Hostname: ${(_c = data.hostname) !== null && _c !== void 0 ? _c : "unknown"}`);
+    parts.push(`Recorded: ${(_d = data.datetime_first_payload) !== null && _d !== void 0 ? _d : "unknown"}`);
+    parts.push(`Abandoned: ${data.abandoned ? "yes" : "no"}`);
+    parts.push("");
+    const history = (_e = data.urlHistory) !== null && _e !== void 0 ? _e : [];
+    if (history.length > 0) {
+        parts.push(`URL History (${history.length} pages):`);
+        for (const entry of history) {
+            const ts = entry.timestamp != null ? `${entry.timestamp}ms` : "?";
+            const pattern = entry.urlPattern
+                ? `  [pattern: ${entry.urlPattern}]`
+                : "";
+            parts.push(`  ${ts}  ${(_f = entry.url) !== null && _f !== void 0 ? _f : "unknown"}${pattern}`);
+        }
+        parts.push("");
+    }
+    const events = (_h = (_g = data.userEvents) === null || _g === void 0 ? void 0 : _g.event_log) !== null && _h !== void 0 ? _h : [];
+    if (events.length > 0) {
+        const typeCounts = {};
+        for (const event of events) {
+            typeCounts[(_j = event.type) !== null && _j !== void 0 ? _j : "unknown"] =
+                ((_l = typeCounts[(_k = event.type) !== null && _k !== void 0 ? _k : "unknown"]) !== null && _l !== void 0 ? _l : 0) + 1;
+        }
+        parts.push(`User Events: ${events.length} events`);
+        for (const [type, count] of Object.entries(typeCounts).sort(([, a], [, b]) => b - a)) {
+            parts.push(`  ${type}: ${count}`);
+        }
+        parts.push("");
+    }
+    const harContainer = (_m = data.pollyHAR) === null || _m === void 0 ? void 0 : _m.pollyHAR;
+    if (harContainer) {
+        const allEntries = Object.values(harContainer).flatMap((r) => { var _a, _b; return (_b = (_a = r === null || r === void 0 ? void 0 : r.log) === null || _a === void 0 ? void 0 : _a.entries) !== null && _b !== void 0 ? _b : []; });
+        if (allEntries.length > 0) {
+            parts.push(`Network Requests: ${allEntries.length} total`);
+            const methodCounts = {};
+            for (const entry of allEntries) {
+                const method = (_p = (_o = entry.request) === null || _o === void 0 ? void 0 : _o.method) !== null && _p !== void 0 ? _p : "UNKNOWN";
+                methodCounts[method] = ((_q = methodCounts[method]) !== null && _q !== void 0 ? _q : 0) + 1;
+            }
+            parts.push(`  Methods: ${Object.entries(methodCounts)
+                .sort(([, a], [, b]) => b - a)
+                .map(([m, c]) => `${m} ${c}`)
+                .join(", ")}`);
+            parts.push("");
+        }
+    }
+    const localStorage = (_u = (_t = (_s = (_r = data.randomEvents) === null || _r === void 0 ? void 0 : _r.localStorage) === null || _s === void 0 ? void 0 : _s.state) === null || _t === void 0 ? void 0 : _t.length) !== null && _u !== void 0 ? _u : 0;
+    const sessionStorage = (_y = (_x = (_w = (_v = data.randomEvents) === null || _v === void 0 ? void 0 : _v.sessionStorage) === null || _w === void 0 ? void 0 : _w.state) === null || _x === void 0 ? void 0 : _x.length) !== null && _y !== void 0 ? _y : 0;
+    const cookies = (_0 = (_z = data.cookies) === null || _z === void 0 ? void 0 : _z.length) !== null && _0 !== void 0 ? _0 : 0;
+    parts.push("Storage:");
+    parts.push(`  localStorage: ${localStorage} entries`);
+    parts.push(`  sessionStorage: ${sessionStorage} entries`);
+    parts.push(`  Cookies: ${cookies}`);
+    parts.push("");
+    const connections = (_1 = data.webSocketData) !== null && _1 !== void 0 ? _1 : [];
+    if (connections.length > 0) {
+        parts.push(`WebSocket Connections: ${connections.length}`);
+        for (const conn of connections) {
+            parts.push(`  ${(_2 = conn.url) !== null && _2 !== void 0 ? _2 : "unknown"} (${(_4 = (_3 = conn.events) === null || _3 === void 0 ? void 0 : _3.length) !== null && _4 !== void 0 ? _4 : 0} events)`);
+        }
+        parts.push("");
+    }
+    const ctx = data.context;
+    if (ctx) {
+        parts.push("Session Context:");
+        if (ctx.userId || ctx.userEmail) {
+            parts.push(`  User: ${[ctx.userId, ctx.userEmail].filter(Boolean).join(" / ")}`);
+        }
+        const flags = Object.entries((_5 = ctx.featureFlags) !== null && _5 !== void 0 ? _5 : {});
+        if (flags.length > 0) {
+            parts.push(`  Feature flags: ${flags.map(([k, v]) => `${k}=${v}`).join(", ")}`);
+        }
+        parts.push("");
+    }
+    const appData = data.applicationSpecificData;
+    if (appData === null || appData === void 0 ? void 0 : appData.nextJs) {
+        parts.push("Framework: Next.js");
+        if (appData.nextJs.page) {
+            parts.push(`  Page: ${appData.nextJs.page}`);
+        }
+        parts.push("");
+    }
+    else if (appData === null || appData === void 0 ? void 0 : appData.reactRouter) {
+        parts.push("Framework: React Router");
+        parts.push("");
+    }
+    return parts.join("\n");
+};
+// ---------------------------------------------------------------------------
+// Context JSON generation (default implementation)
+// ---------------------------------------------------------------------------
+const defaultWriteContextJson = (debugContext, workspaceDir, fileMetadata, projectRepoDir, screenshotMap, replayComparison) => {
+    const headIds = new Set(debugContext.replayDiffs.map((d) => d.headReplayId));
+    const baseIds = new Set(debugContext.replayDiffs.map((d) => d.baseReplayId));
+    const headReplays = [];
+    const baseReplays = [];
+    const otherReplays = [];
+    for (const id of debugContext.replayIds) {
+        if (headIds.has(id)) {
+            headReplays.push(id);
+        }
+        else if (baseIds.has(id)) {
+            baseReplays.push(id);
+        }
+        else {
+            otherReplays.push(id);
+        }
+    }
+    const context = {
+        createdAt: new Date().toISOString(),
+        orgProject: debugContext.orgAndProject,
+        testRunId: debugContext.testRunId,
+        testRunStatus: debugContext.testRunStatus,
+        commitSha: debugContext.commitSha,
+        baseCommitSha: debugContext.baseCommitSha,
+        screenshot: debugContext.screenshot,
+        replayDiffs: debugContext.replayDiffs.map((d) => ({
+            id: d.id,
+            headReplayId: d.headReplayId,
+            baseReplayId: d.baseReplayId,
+            sessionId: d.sessionId,
+            numScreenshotDiffs: d.numScreenshotDiffs,
+        })),
+        replays: { head: headReplays, base: baseReplays, other: otherReplays },
+        sessions: debugContext.sessionIds,
+        screenshotMap,
+        replayComparison,
+        paths: {
+            replays: "replays/",
+            sessions: "sessions/",
+            diffs: "diffs/",
+            logDiffs: "log-diffs/",
+            logDiffsFiltered: "log-diffs/*.filtered.diff",
+            logDiffsSummary: "log-diffs/*.summary.txt",
+            paramsDiffs: "params-diffs/",
+            assetsDiffs: "assets-diffs/",
+            timelineSummaries: "timeline-summaries/",
+            screenshotContext: "screenshot-context/",
+            prDiff: "pr-diff.txt",
+            formattedAssets: "formatted-assets/",
+            testRun: "test-run/",
+            projectRepo: projectRepoDir ? "project-repo/" : undefined,
+        },
+        fileMetadata,
+    };
+    (0, fs_1.writeFileSync)((0, path_1.join)(workspaceDir, debug_constants_1.DEBUG_DATA_DIRECTORY, "context.json"), JSON.stringify(context, null, 2));
+};
+//# sourceMappingURL=generate-debug-workspace.js.map