@godscene/core 1.7.11

package/dist/lib/report-markdown.js

@@ -0,0 +1,253 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    executionToMarkdown: ()=>executionToMarkdown,
+    reportToMarkdown: ()=>reportToMarkdown
+});
+const external_node_path_namespaceObject = require("node:path");
+const ui_utils_js_namespaceObject = require("./agent/ui-utils.js");
+const external_screenshot_item_js_namespaceObject = require("./screenshot-item.js");
+const screenshot_store_js_namespaceObject = require("./dump/screenshot-store.js");
+function toExecutionDump(execution) {
+    if (!execution || 'object' != typeof execution) throw new Error('executionToMarkdown: execution is required');
+    if (!Array.isArray(execution.tasks)) throw new Error('executionToMarkdown: execution.tasks must be an array');
+    if (!execution.name) throw new Error('executionToMarkdown: execution.name is required');
+    return execution;
+}
+function toReportDump(report) {
+    if (!report || 'object' != typeof report) throw new Error('reportToMarkdown: report is required');
+    if (!Array.isArray(report.executions)) throw new Error('reportToMarkdown: report.executions must be an array');
+    return report;
+}
+function formatTime(ts) {
+    if ('number' != typeof ts || Number.isNaN(ts)) return 'N/A';
+    return new Date(ts).toISOString();
+}
+function resolveTaskTiming(task) {
+    const timing = task.timing;
+    if (!timing) return {};
+    const start = timing.start ?? timing.callAiStart ?? timing.callActionStart;
+    const end = timing.end ?? timing.callAiEnd ?? timing.callActionEnd ?? timing.captureAfterCallingSnapshotEnd;
+    const cost = timing.cost ?? ('number' == typeof start && 'number' == typeof end ? end - start : void 0);
+    return {
+        start,
+        end,
+        cost
+    };
+}
+function safeTaskParam(task) {
+    const readable = (0, ui_utils_js_namespaceObject.paramStr)(task);
+    if (readable) return readable;
+    if ('Insight' === task.type) return (0, ui_utils_js_namespaceObject.extractInsightParam)(task.param).content;
+    return '';
+}
+function formatSize(size) {
+    if (!size || 'number' != typeof size.width || 'number' != typeof size.height || Number.isNaN(size.width) || Number.isNaN(size.height)) return;
+    return `${size.width} x ${size.height}`;
+}
+function extractLocateCenter(task) {
+    const outputCenter = task.output?.element?.center;
+    if (Array.isArray(outputCenter) && outputCenter.length >= 2 && 'number' == typeof outputCenter[0] && 'number' == typeof outputCenter[1]) return [
+        outputCenter[0],
+        outputCenter[1]
+    ];
+    const paramLocateCenter = task.param?.locate?.center;
+    if (Array.isArray(paramLocateCenter) && paramLocateCenter.length >= 2 && 'number' == typeof paramLocateCenter[0] && 'number' == typeof paramLocateCenter[1]) return [
+        paramLocateCenter[0],
+        paramLocateCenter[1]
+    ];
+    const paramCenter = task.param?.center;
+    if (Array.isArray(paramCenter) && paramCenter.length >= 2 && 'number' == typeof paramCenter[0] && 'number' == typeof paramCenter[1]) return [
+        paramCenter[0],
+        paramCenter[1]
+    ];
+}
+function tryExtractBase64(screenshot) {
+    if (!screenshot || 'object' != typeof screenshot) return;
+    const s = screenshot;
+    if ('string' == typeof s.base64 && s.base64.length > 0) return s.base64;
+}
+function screenshotAttachment(screenshot, screenshotBaseDir, executionIndex, taskIndex) {
+    if (screenshot instanceof external_screenshot_item_js_namespaceObject.ScreenshotItem) {
+        const ext = screenshot.extension;
+        const suggestedFileName = `execution-${executionIndex + 1}-task-${taskIndex + 1}-${screenshot.id}.${ext}`;
+        const filePath = `${screenshotBaseDir}/${suggestedFileName}`;
+        return {
+            markdown: `\n![task-${taskIndex + 1}](${filePath})`,
+            attachment: {
+                id: screenshot.id,
+                suggestedFileName,
+                filePath,
+                mimeType: `image/${'jpeg' === ext ? 'jpeg' : 'png'}`,
+                executionIndex,
+                taskIndex,
+                base64Data: tryExtractBase64(screenshot)
+            }
+        };
+    }
+    const ref = (0, screenshot_store_js_namespaceObject.normalizeScreenshotRef)(screenshot);
+    if (ref) {
+        const ext = 'image/jpeg' === ref.mimeType ? 'jpeg' : 'png';
+        const suggestedFileName = `execution-${executionIndex + 1}-task-${taskIndex + 1}-${ref.id}.${ext}`;
+        const filePath = ref.path || `${screenshotBaseDir}/${suggestedFileName}`;
+        return {
+            markdown: `\n![task-${taskIndex + 1}](${filePath})`,
+            attachment: {
+                id: ref.id,
+                suggestedFileName,
+                filePath,
+                mimeType: ref.mimeType,
+                executionIndex,
+                taskIndex,
+                base64Data: tryExtractBase64(screenshot)
+            }
+        };
+    }
+    const base64 = tryExtractBase64(screenshot);
+    if (base64) {
+        const ext = base64.startsWith('data:image/jpeg') ? 'jpeg' : 'png';
+        const id = `restored-${executionIndex + 1}-${taskIndex + 1}`;
+        const suggestedFileName = `execution-${executionIndex + 1}-task-${taskIndex + 1}-${id}.${ext}`;
+        const filePath = `${screenshotBaseDir}/${suggestedFileName}`;
+        return {
+            markdown: `\n![task-${taskIndex + 1}](${filePath})`,
+            attachment: {
+                id,
+                suggestedFileName,
+                filePath,
+                mimeType: `image/${ext}`,
+                executionIndex,
+                taskIndex,
+                base64Data: base64
+            }
+        };
+    }
+    throw new Error(`executionToMarkdown: missing screenshot for execution #${executionIndex + 1} task #${taskIndex + 1}`);
+}
+function recorderMarkdownSection(recorder, screenshotBaseDir, executionIndex, taskIndex) {
+    if (!recorder?.length) return {
+        lines: [],
+        attachments: []
+    };
+    const lines = [
+        '',
+        '### Recorder'
+    ];
+    const attachments = [];
+    recorder.forEach((item, recorderIndex)=>{
+        lines.push(`- #${recorderIndex + 1} type=${item.type}, ts=${formatTime(item.ts)}, timing=${item.timing || 'N/A'}`);
+        if (!item.screenshot) return;
+        const imageResult = screenshotAttachment(item.screenshot, screenshotBaseDir, executionIndex, taskIndex);
+        lines.push(imageResult.markdown);
+        attachments.push(imageResult.attachment);
+    });
+    return {
+        lines,
+        attachments
+    };
+}
+function renderExecution(executionRaw, executionIndex, options) {
+    const execution = toExecutionDump(executionRaw);
+    const screenshotBaseDir = options?.screenshotBaseDir ?? './screenshots';
+    const lines = [];
+    const attachments = [];
+    lines.push(`# ${execution.name}`);
+    if (execution.description) lines.push('', execution.description);
+    lines.push('', `- Execution start: ${formatTime(execution.logTime)}`);
+    lines.push(`- Task count: ${execution.tasks.length}`);
+    execution.tasks.forEach((task, taskIndex)=>{
+        const title = (0, ui_utils_js_namespaceObject.typeStr)(task);
+        const detail = safeTaskParam(task);
+        const time = resolveTaskTiming(task);
+        lines.push('', `## ${taskIndex + 1}. ${title}${detail ? ` - ${detail}` : ''}`);
+        lines.push(`- Status: ${task.status || 'unknown'}`);
+        lines.push(`- Start: ${formatTime(time.start)}`);
+        lines.push(`- End: ${formatTime(time.end)}`);
+        lines.push(`- Cost(ms): ${'number' == typeof time.cost ? time.cost : 'N/A'}`);
+        lines.push(`- Screen size: ${formatSize(task.uiContext?.shotSize) || 'N/A'}`);
+        if ('Locate' === task.subType) {
+            const locateCenter = extractLocateCenter(task);
+            if (locateCenter) lines.push(`- Locate center: (${locateCenter[0]}, ${locateCenter[1]})`);
+        }
+        if (task.errorMessage) lines.push(`- Error: ${task.errorMessage}`);
+        if (task.uiContext?.screenshot) {
+            const imageResult = screenshotAttachment(task.uiContext.screenshot, screenshotBaseDir, executionIndex, taskIndex);
+            lines.push(imageResult.markdown);
+            attachments.push(imageResult.attachment);
+        }
+        const recorderSection = recorderMarkdownSection(task.recorder, screenshotBaseDir, executionIndex, taskIndex);
+        if (recorderSection.lines.length) {
+            lines.push(...recorderSection.lines);
+            attachments.push(...recorderSection.attachments);
+        }
+    });
+    return {
+        markdown: lines.join('\n'),
+        attachments
+    };
+}
+function reportFileName(execution, executionIndex) {
+    const safeName = execution.name.trim().replace(/\s+/g, '-').replace(/[^a-zA-Z0-9-_]/g, '') || `execution-${executionIndex + 1}`;
+    return `${executionIndex + 1}-${(0, external_node_path_namespaceObject.basename)(safeName)}.md`;
+}
+function executionToMarkdown(execution, options) {
+    return renderExecution(execution, 0, options);
+}
+function reportToMarkdown(report) {
+    const reportDump = toReportDump(report);
+    const executionResults = reportDump.executions.map((execution, index)=>{
+        const rendered = renderExecution(execution, index);
+        return {
+            executionIndex: index,
+            executionName: execution.name,
+            markdown: rendered.markdown,
+            attachments: rendered.attachments,
+            suggestedFileName: reportFileName(execution, index)
+        };
+    });
+    const attachments = executionResults.flatMap((item)=>item.attachments);
+    const header = [
+        `# ${reportDump.groupName}`,
+        reportDump.groupDescription ? `\n${reportDump.groupDescription}` : '',
+        `\n- SDK Version: ${reportDump.sdkVersion}`,
+        `- Execution count: ${reportDump.executions.length}`,
+        '\n## Suggested execution markdown files',
+        ...executionResults.map((item)=>`- ${item.suggestedFileName} (${item.executionName})`)
+    ].filter(Boolean).join('\n');
+    return {
+        markdown: `${header}\n\n${executionResults.map((item)=>item.markdown).join('\n\n---\n\n')}`,
+        attachments
+    };
+}
+exports.executionToMarkdown = __webpack_exports__.executionToMarkdown;
+exports.reportToMarkdown = __webpack_exports__.reportToMarkdown;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "executionToMarkdown",
+    "reportToMarkdown"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/report.js

@@ -0,0 +1,333 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    splitReportHtmlByExecution: ()=>splitReportHtmlByExecution,
+    ReportMergingTool: ()=>ReportMergingTool,
+    isDirectoryModeReport: ()=>isDirectoryModeReport,
+    dedupeExecutionsKeepLatest: ()=>dedupeExecutionsKeepLatest,
+    collectDedupedExecutions: ()=>collectDedupedExecutions
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+const common_namespaceObject = require("@godscene/shared/common");
+const utils_namespaceObject = require("@godscene/shared/utils");
+const index_js_namespaceObject = require("./agent/index.js");
+const html_utils_js_namespaceObject = require("./dump/html-utils.js");
+const screenshot_store_js_namespaceObject = require("./dump/screenshot-store.js");
+const external_types_js_namespaceObject = require("./types.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+function isDirectoryModeReport(reportFilePath) {
+    const reportDir = external_node_path_namespaceObject.dirname(reportFilePath);
+    return 'index.html' === external_node_path_namespaceObject.basename(reportFilePath) && (0, external_node_fs_namespaceObject.existsSync)(external_node_path_namespaceObject.join(reportDir, 'screenshots'));
+}
+function dedupeExecutionsKeepLatest(executions) {
+    let noIdCounter = 0;
+    const deduped = new Map();
+    for (const exec of executions){
+        const key = exec.id || `__no_id_${noIdCounter++}`;
+        deduped.set(key, exec);
+    }
+    return Array.from(deduped.values());
+}
+function peekReportSdkVersion(reportFilePath) {
+    try {
+        const dump = (0, html_utils_js_namespaceObject.extractLastDumpScriptSync)(reportFilePath);
+        if (!dump) return;
+        const match = dump.match(/"sdkVersion"\s*:\s*"([^"]+)"/);
+        return match?.[1];
+    } catch  {
+        return;
+    }
+}
+const warnedMismatchedVersions = new Set();
+class ReportMergingTool {
+    createEmptyDumpString(groupName, groupDescription) {
+        return new external_types_js_namespaceObject.ReportActionDump({
+            sdkVersion: '',
+            groupName,
+            groupDescription,
+            modelBriefs: [],
+            executions: []
+        }).serialize();
+    }
+    append(reportInfo) {
+        if (reportInfo.reportFilePath) {
+            const sourceVersion = peekReportSdkVersion(reportInfo.reportFilePath);
+            const currentVersion = (0, external_utils_js_namespaceObject.getVersion)();
+            if (sourceVersion && currentVersion && sourceVersion !== currentVersion && !warnedMismatchedVersions.has(sourceVersion)) {
+                warnedMismatchedVersions.add(sourceVersion);
+                (0, utils_namespaceObject.logMsg)(`[@godscene/core] ReportMergingTool version mismatch: source report was written by @godscene/core@${sourceVersion} but the merger is @godscene/core@${currentVersion}. This commonly means @godscene/core and the device package (e.g. @godscene/android) resolve to different versions in node_modules. Merged output may silently drop intermediate steps. Align the versions and reinstall (rm -rf node_modules package-lock.json && npm install).`);
+            }
+        }
+        this.reportInfos.push(reportInfo);
+    }
+    clear() {
+        this.reportInfos = [];
+    }
+    mergeDumpScripts(contents) {
+        const unescaped = contents.map((c)=>(0, utils_namespaceObject.antiEscapeScriptTag)(c)).filter((c)=>c.length > 0);
+        if (0 === unescaped.length) return '';
+        if (1 === unescaped.length) return unescaped[0];
+        const base = external_types_js_namespaceObject.ReportActionDump.fromSerializedString(unescaped[0]);
+        const allExecutions = [
+            ...base.executions
+        ];
+        for(let i = 1; i < unescaped.length; i++){
+            const other = external_types_js_namespaceObject.ReportActionDump.fromSerializedString(unescaped[i]);
+            allExecutions.push(...other.executions);
+        }
+        base.executions = dedupeExecutionsKeepLatest(allExecutions);
+        return base.serialize();
+    }
+    mergeReports(reportFileName = 'AUTO', opts) {
+        const { rmOriginalReports = false, overwrite = false } = opts ?? {};
+        if (0 === this.reportInfos.length) {
+            (0, utils_namespaceObject.logMsg)('No reports to merge');
+            return null;
+        }
+        const targetDir = (0, common_namespaceObject.getMidsceneRunSubDir)('report');
+        const hasDirectoryModeReport = this.reportInfos.some((info)=>{
+            const reportFilePath = info.reportFilePath;
+            return Boolean(reportFilePath && isDirectoryModeReport(reportFilePath));
+        });
+        const resolvedName = 'AUTO' === reportFileName ? (0, index_js_namespaceObject.getReportFileName)('merged-report') : reportFileName;
+        const outputFilePath = hasDirectoryModeReport ? external_node_path_namespaceObject.resolve(targetDir, resolvedName, 'index.html') : external_node_path_namespaceObject.resolve(targetDir, `${resolvedName}.html`);
+        if ('AUTO' !== reportFileName && (0, external_node_fs_namespaceObject.existsSync)(outputFilePath)) {
+            if (!overwrite) throw new Error(`Report file already exists: ${outputFilePath}\nSet overwrite to true to overwrite this file.`);
+            if (hasDirectoryModeReport) (0, external_node_fs_namespaceObject.rmSync)(external_node_path_namespaceObject.dirname(outputFilePath), {
+                recursive: true,
+                force: true
+            });
+            else (0, external_node_fs_namespaceObject.unlinkSync)(outputFilePath);
+        }
+        if (hasDirectoryModeReport) (0, external_node_fs_namespaceObject.mkdirSync)(external_node_path_namespaceObject.dirname(outputFilePath), {
+            recursive: true
+        });
+        (0, utils_namespaceObject.logMsg)(`Start merging ${this.reportInfos.length} reports...\nCreating template file...`);
+        try {
+            const htmlEndTag = '</html>';
+            const tpl = (0, external_utils_js_namespaceObject.getReportTpl)();
+            const htmlEndIdx = tpl.lastIndexOf(htmlEndTag);
+            const tplWithoutClose = -1 !== htmlEndIdx ? tpl.slice(0, htmlEndIdx) : tpl;
+            (0, external_node_fs_namespaceObject.appendFileSync)(outputFilePath, tplWithoutClose);
+            if (hasDirectoryModeReport) (0, external_node_fs_namespaceObject.appendFileSync)(outputFilePath, (0, html_utils_js_namespaceObject.getBaseUrlFixScript)());
+            for(let i = 0; i < this.reportInfos.length; i++){
+                const reportInfo = this.reportInfos[i];
+                (0, utils_namespaceObject.logMsg)(`Processing report ${i + 1}/${this.reportInfos.length}`);
+                const { reportAttributes } = reportInfo;
+                let dumpString = this.createEmptyDumpString(reportAttributes.testTitle, reportAttributes.testDescription);
+                let mergedGroupId = `merged-group-${i}`;
+                if (reportInfo.reportFilePath) {
+                    if (isDirectoryModeReport(reportInfo.reportFilePath)) {
+                        const reportDir = external_node_path_namespaceObject.dirname(reportInfo.reportFilePath);
+                        const screenshotsDir = external_node_path_namespaceObject.join(reportDir, 'screenshots');
+                        const mergedScreenshotsDir = external_node_path_namespaceObject.join(external_node_path_namespaceObject.dirname(outputFilePath), 'screenshots');
+                        (0, external_node_fs_namespaceObject.mkdirSync)(mergedScreenshotsDir, {
+                            recursive: true
+                        });
+                        for (const file of (0, external_node_fs_namespaceObject.readdirSync)(screenshotsDir)){
+                            const src = external_node_path_namespaceObject.join(screenshotsDir, file);
+                            const dest = external_node_path_namespaceObject.join(mergedScreenshotsDir, file);
+                            (0, external_node_fs_namespaceObject.copyFileSync)(src, dest);
+                        }
+                    } else (0, html_utils_js_namespaceObject.streamImageScriptsToFile)(reportInfo.reportFilePath, outputFilePath);
+                    const allDumps = (0, html_utils_js_namespaceObject.extractAllDumpScriptsSync)(reportInfo.reportFilePath).filter((d)=>d.openTag.includes('data-group-id'));
+                    const groupIdMatch = allDumps[0]?.openTag.match(/data-group-id="([^"]+)"/);
+                    if (groupIdMatch) mergedGroupId = decodeURIComponent(groupIdMatch[1]);
+                    const extractedDumpString = allDumps.length > 0 ? this.mergeDumpScripts(allDumps.map((d)=>d.content)) : (0, html_utils_js_namespaceObject.extractLastDumpScriptSync)(reportInfo.reportFilePath);
+                    if (extractedDumpString) dumpString = extractedDumpString;
+                }
+                const reportHtmlStr = `${(0, external_utils_js_namespaceObject.reportHTMLContent)({
+                    dumpString,
+                    attributes: {
+                        'data-group-id': mergedGroupId,
+                        playwright_test_duration: reportAttributes.testDuration,
+                        playwright_test_status: reportAttributes.testStatus,
+                        playwright_test_title: reportAttributes.testTitle,
+                        playwright_test_id: reportAttributes.testId,
+                        playwright_test_description: reportAttributes.testDescription,
+                        is_merged: true
+                    }
+                }, void 0, void 0, false)}\n`;
+                (0, external_node_fs_namespaceObject.appendFileSync)(outputFilePath, reportHtmlStr);
+            }
+            (0, external_node_fs_namespaceObject.appendFileSync)(outputFilePath, `${htmlEndTag}\n`);
+            (0, utils_namespaceObject.logMsg)(`Successfully merged new report: ${outputFilePath}`);
+            if (rmOriginalReports) {
+                for (const info of this.reportInfos)if (info.reportFilePath) try {
+                    if (isDirectoryModeReport(info.reportFilePath)) {
+                        const reportDir = external_node_path_namespaceObject.dirname(info.reportFilePath);
+                        (0, external_node_fs_namespaceObject.rmSync)(reportDir, {
+                            recursive: true,
+                            force: true
+                        });
+                    } else (0, external_node_fs_namespaceObject.unlinkSync)(info.reportFilePath);
+                } catch (error) {
+                    (0, utils_namespaceObject.logMsg)(`Error deleting report ${info.reportFilePath}: ${error}`);
+                }
+                (0, utils_namespaceObject.logMsg)(`Removed ${this.reportInfos.length} original reports`);
+            }
+            return outputFilePath;
+        } catch (error) {
+            (0, utils_namespaceObject.logMsg)(`Error in mergeReports: ${error}`);
+            throw error;
+        }
+    }
+    constructor(){
+        _define_property(this, "reportInfos", []);
+    }
+}
+function collectDedupedExecutions(htmlPath) {
+    let baseDump = null;
+    let executionSerial = 0;
+    const latestSerialByExecutionId = new Map();
+    (0, html_utils_js_namespaceObject.streamDumpScriptsSync)(htmlPath, (dumpScript)=>{
+        if (!dumpScript.openTag.includes('data-group-id')) return false;
+        const groupedDump = external_types_js_namespaceObject.ReportActionDump.fromSerializedString((0, utils_namespaceObject.antiEscapeScriptTag)(dumpScript.content));
+        for (const execution of groupedDump.executions){
+            executionSerial += 1;
+            if (execution.id) latestSerialByExecutionId.set(execution.id, executionSerial);
+        }
+        return false;
+    });
+    const executions = [];
+    executionSerial = 0;
+    (0, html_utils_js_namespaceObject.streamDumpScriptsSync)(htmlPath, (dumpScript)=>{
+        if (!dumpScript.openTag.includes('data-group-id')) return false;
+        const groupedDump = external_types_js_namespaceObject.ReportActionDump.fromSerializedString((0, utils_namespaceObject.antiEscapeScriptTag)(dumpScript.content));
+        if (!baseDump) baseDump = groupedDump;
+        for (const execution of groupedDump.executions){
+            executionSerial += 1;
+            if (!execution.id || latestSerialByExecutionId.get(execution.id) === executionSerial) executions.push(execution);
+        }
+        return false;
+    });
+    if (!baseDump) throw new Error(`No report dump scripts found in ${htmlPath}`);
+    return {
+        baseDump,
+        executions
+    };
+}
+function extensionByMimeType(mimeType) {
+    if ('image/png' === mimeType) return 'png';
+    if ('image/jpeg' === mimeType) return 'jpeg';
+    throw new Error(`Unsupported screenshot mime type: ${mimeType}`);
+}
+function externalizeScreenshotsInExecution(execution, opts) {
+    const visit = (node)=>{
+        if (Array.isArray(node)) {
+            for (const item of node)visit(item);
+            return;
+        }
+        if ('object' != typeof node || null === node) return;
+        const ref = (0, screenshot_store_js_namespaceObject.normalizeScreenshotRef)(node);
+        if (ref) {
+            const ext = extensionByMimeType(ref.mimeType);
+            const fileName = `${ref.id}.${ext}`;
+            const relativePath = `./screenshots/${fileName}`;
+            const absolutePath = external_node_path_namespaceObject.join(opts.screenshotsDir, fileName);
+            if (!opts.writtenFiles.has(fileName)) {
+                const resolved = (0, screenshot_store_js_namespaceObject.resolveScreenshotSource)(ref, {
+                    reportPath: opts.htmlPath
+                });
+                if ('data-uri' === resolved.type) {
+                    const rawBase64 = resolved.dataUri.replace(/^data:image\/[a-zA-Z+]+;base64,/, '');
+                    (0, external_node_fs_namespaceObject.writeFileSync)(absolutePath, Buffer.from(rawBase64, 'base64'));
+                } else (0, external_node_fs_namespaceObject.copyFileSync)(resolved.filePath, absolutePath);
+                opts.writtenFiles.add(fileName);
+            }
+            ref.storage = 'file';
+            ref.path = relativePath;
+            return;
+        }
+        for (const value of Object.values(node))visit(value);
+    };
+    visit(execution);
+}
+function splitReportHtmlByExecution(options) {
+    const { htmlPath, outputDir } = options;
+    const screenshotsDir = external_node_path_namespaceObject.join(outputDir, 'screenshots');
+    (0, external_node_fs_namespaceObject.mkdirSync)(outputDir, {
+        recursive: true
+    });
+    (0, external_node_fs_namespaceObject.mkdirSync)(screenshotsDir, {
+        recursive: true
+    });
+    const executionJsonFiles = [];
+    const writtenScreenshotFiles = new Set();
+    const { baseDump, executions } = collectDedupedExecutions(htmlPath);
+    let fileIndex = 0;
+    for (const execution of executions){
+        fileIndex += 1;
+        externalizeScreenshotsInExecution(execution, {
+            htmlPath,
+            screenshotsDir,
+            writtenFiles: writtenScreenshotFiles
+        });
+        const singleExecutionDump = new external_types_js_namespaceObject.ReportActionDump({
+            sdkVersion: baseDump.sdkVersion,
+            groupName: baseDump.groupName,
+            groupDescription: baseDump.groupDescription,
+            modelBriefs: baseDump.modelBriefs,
+            deviceType: baseDump.deviceType,
+            executions: [
+                execution
+            ]
+        });
+        const jsonFilePath = external_node_path_namespaceObject.join(outputDir, `${fileIndex}.execution.json`);
+        (0, external_node_fs_namespaceObject.writeFileSync)(jsonFilePath, singleExecutionDump.serialize(2), 'utf-8');
+        executionJsonFiles.push(jsonFilePath);
+    }
+    return {
+        executionJsonFiles,
+        screenshotFiles: Array.from(writtenScreenshotFiles).sort().map((fileName)=>external_node_path_namespaceObject.join(screenshotsDir, fileName))
+    };
+}
+exports.ReportMergingTool = __webpack_exports__.ReportMergingTool;
+exports.collectDedupedExecutions = __webpack_exports__.collectDedupedExecutions;
+exports.dedupeExecutionsKeepLatest = __webpack_exports__.dedupeExecutionsKeepLatest;
+exports.isDirectoryModeReport = __webpack_exports__.isDirectoryModeReport;
+exports.splitReportHtmlByExecution = __webpack_exports__.splitReportHtmlByExecution;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ReportMergingTool",
+    "collectDedupedExecutions",
+    "dedupeExecutionsKeepLatest",
+    "isDirectoryModeReport",
+    "splitReportHtmlByExecution"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});