@godscene/core 1.7.11

package/dist/lib/index.js

@@ -0,0 +1,184 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+    plan: ()=>external_ai_model_index_js_namespaceObject.plan,
+    TUserPromptSchema: ()=>external_ai_model_index_js_namespaceObject.TUserPromptSchema,
+    MIDSCENE_MODEL_NAME: ()=>env_namespaceObject.MIDSCENE_MODEL_NAME,
+    reportToMarkdown: ()=>external_report_markdown_js_namespaceObject.reportToMarkdown,
+    runConnectivityTest: ()=>external_ai_model_index_js_namespaceObject.runConnectivityTest,
+    collectDedupedExecutions: ()=>external_report_js_namespaceObject.collectDedupedExecutions,
+    generateImageScriptTag: ()=>external_dump_index_js_namespaceObject.generateImageScriptTag,
+    restoreImageReferences: ()=>external_dump_index_js_namespaceObject.restoreImageReferences,
+    splitReportHtmlByExecution: ()=>external_report_js_namespaceObject.splitReportHtmlByExecution,
+    parseDumpScriptAttributes: ()=>external_dump_index_js_namespaceObject.parseDumpScriptAttributes,
+    z: ()=>external_zod_namespaceObject.z,
+    generateDumpScriptTag: ()=>external_dump_index_js_namespaceObject.generateDumpScriptTag,
+    SizeSchema: ()=>external_ai_model_index_js_namespaceObject.SizeSchema,
+    default: ()=>src,
+    getVersion: ()=>external_utils_js_namespaceObject.getVersion,
+    getMidsceneLocationSchema: ()=>external_ai_model_index_js_namespaceObject.getMidsceneLocationSchema,
+    parseDumpScript: ()=>external_dump_index_js_namespaceObject.parseDumpScript,
+    ServiceError: ()=>external_types_js_namespaceObject.ServiceError,
+    parseImageScripts: ()=>external_dump_index_js_namespaceObject.parseImageScripts,
+    PointSchema: ()=>external_ai_model_index_js_namespaceObject.PointSchema,
+    RectSchema: ()=>external_ai_model_index_js_namespaceObject.RectSchema,
+    Agent: ()=>external_agent_index_js_namespaceObject.Agent,
+    nullReportGenerator: ()=>external_report_generator_js_namespaceObject.nullReportGenerator,
+    ScreenshotStore: ()=>screenshot_store_js_namespaceObject.ScreenshotStore,
+    ReportMergingTool: ()=>external_report_js_namespaceObject.ReportMergingTool,
+    Service: ()=>index_js_default(),
+    AiLocateElement: ()=>external_ai_model_index_js_namespaceObject.AiLocateElement,
+    createReportCliCommands: ()=>external_report_cli_js_namespaceObject.createReportCliCommands,
+    ScreenshotItem: ()=>external_screenshot_item_js_namespaceObject.ScreenshotItem,
+    createAgent: ()=>external_agent_index_js_namespaceObject.createAgent,
+    ExecutionDump: ()=>external_types_js_namespaceObject.ExecutionDump,
+    dedupeExecutionsKeepLatest: ()=>external_report_js_namespaceObject.dedupeExecutionsKeepLatest,
+    ReportGenerator: ()=>external_report_generator_js_namespaceObject.ReportGenerator,
+    escapeContent: ()=>external_dump_index_js_namespaceObject.escapeContent,
+    TaskRunner: ()=>external_task_runner_js_namespaceObject.TaskRunner,
+    ReportActionDump: ()=>external_types_js_namespaceObject.ReportActionDump,
+    GroupedActionDump: ()=>external_types_js_namespaceObject.GroupedActionDump,
+    TMultimodalPromptSchema: ()=>external_ai_model_index_js_namespaceObject.TMultimodalPromptSchema,
+    reportFileToMarkdown: ()=>external_report_cli_js_namespaceObject.reportFileToMarkdown,
+    executionToMarkdown: ()=>external_report_markdown_js_namespaceObject.executionToMarkdown,
+    splitReportFile: ()=>external_report_cli_js_namespaceObject.splitReportFile,
+    unescapeContent: ()=>external_dump_index_js_namespaceObject.unescapeContent
+});
+const external_zod_namespaceObject = require("zod");
+const index_js_namespaceObject = require("./service/index.js");
+var index_js_default = /*#__PURE__*/ __webpack_require__.n(index_js_namespaceObject);
+const external_task_runner_js_namespaceObject = require("./task-runner.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+const external_ai_model_index_js_namespaceObject = require("./ai-model/index.js");
+const env_namespaceObject = require("@godscene/shared/env");
+const external_types_js_namespaceObject = require("./types.js");
+const external_agent_index_js_namespaceObject = require("./agent/index.js");
+const external_dump_index_js_namespaceObject = require("./dump/index.js");
+const external_report_generator_js_namespaceObject = require("./report-generator.js");
+const external_report_js_namespaceObject = require("./report.js");
+const external_report_cli_js_namespaceObject = require("./report-cli.js");
+const external_screenshot_item_js_namespaceObject = require("./screenshot-item.js");
+const screenshot_store_js_namespaceObject = require("./dump/screenshot-store.js");
+const external_report_markdown_js_namespaceObject = require("./report-markdown.js");
+const src = index_js_default();
+exports.Agent = __webpack_exports__.Agent;
+exports.AiLocateElement = __webpack_exports__.AiLocateElement;
+exports.ExecutionDump = __webpack_exports__.ExecutionDump;
+exports.GroupedActionDump = __webpack_exports__.GroupedActionDump;
+exports.MIDSCENE_MODEL_NAME = __webpack_exports__.MIDSCENE_MODEL_NAME;
+exports.PointSchema = __webpack_exports__.PointSchema;
+exports.RectSchema = __webpack_exports__.RectSchema;
+exports.ReportActionDump = __webpack_exports__.ReportActionDump;
+exports.ReportGenerator = __webpack_exports__.ReportGenerator;
+exports.ReportMergingTool = __webpack_exports__.ReportMergingTool;
+exports.ScreenshotItem = __webpack_exports__.ScreenshotItem;
+exports.ScreenshotStore = __webpack_exports__.ScreenshotStore;
+exports.Service = __webpack_exports__.Service;
+exports.ServiceError = __webpack_exports__.ServiceError;
+exports.SizeSchema = __webpack_exports__.SizeSchema;
+exports.TMultimodalPromptSchema = __webpack_exports__.TMultimodalPromptSchema;
+exports.TUserPromptSchema = __webpack_exports__.TUserPromptSchema;
+exports.TaskRunner = __webpack_exports__.TaskRunner;
+exports.collectDedupedExecutions = __webpack_exports__.collectDedupedExecutions;
+exports.createAgent = __webpack_exports__.createAgent;
+exports.createReportCliCommands = __webpack_exports__.createReportCliCommands;
+exports.dedupeExecutionsKeepLatest = __webpack_exports__.dedupeExecutionsKeepLatest;
+exports["default"] = __webpack_exports__["default"];
+exports.escapeContent = __webpack_exports__.escapeContent;
+exports.executionToMarkdown = __webpack_exports__.executionToMarkdown;
+exports.generateDumpScriptTag = __webpack_exports__.generateDumpScriptTag;
+exports.generateImageScriptTag = __webpack_exports__.generateImageScriptTag;
+exports.getMidsceneLocationSchema = __webpack_exports__.getMidsceneLocationSchema;
+exports.getVersion = __webpack_exports__.getVersion;
+exports.nullReportGenerator = __webpack_exports__.nullReportGenerator;
+exports.parseDumpScript = __webpack_exports__.parseDumpScript;
+exports.parseDumpScriptAttributes = __webpack_exports__.parseDumpScriptAttributes;
+exports.parseImageScripts = __webpack_exports__.parseImageScripts;
+exports.plan = __webpack_exports__.plan;
+exports.reportFileToMarkdown = __webpack_exports__.reportFileToMarkdown;
+exports.reportToMarkdown = __webpack_exports__.reportToMarkdown;
+exports.restoreImageReferences = __webpack_exports__.restoreImageReferences;
+exports.runConnectivityTest = __webpack_exports__.runConnectivityTest;
+exports.splitReportFile = __webpack_exports__.splitReportFile;
+exports.splitReportHtmlByExecution = __webpack_exports__.splitReportHtmlByExecution;
+exports.unescapeContent = __webpack_exports__.unescapeContent;
+exports.z = __webpack_exports__.z;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "Agent",
+    "AiLocateElement",
+    "ExecutionDump",
+    "GroupedActionDump",
+    "MIDSCENE_MODEL_NAME",
+    "PointSchema",
+    "RectSchema",
+    "ReportActionDump",
+    "ReportGenerator",
+    "ReportMergingTool",
+    "ScreenshotItem",
+    "ScreenshotStore",
+    "Service",
+    "ServiceError",
+    "SizeSchema",
+    "TMultimodalPromptSchema",
+    "TUserPromptSchema",
+    "TaskRunner",
+    "collectDedupedExecutions",
+    "createAgent",
+    "createReportCliCommands",
+    "dedupeExecutionsKeepLatest",
+    "default",
+    "escapeContent",
+    "executionToMarkdown",
+    "generateDumpScriptTag",
+    "generateImageScriptTag",
+    "getMidsceneLocationSchema",
+    "getVersion",
+    "nullReportGenerator",
+    "parseDumpScript",
+    "parseDumpScriptAttributes",
+    "parseImageScripts",
+    "plan",
+    "reportFileToMarkdown",
+    "reportToMarkdown",
+    "restoreImageReferences",
+    "runConnectivityTest",
+    "splitReportFile",
+    "splitReportHtmlByExecution",
+    "unescapeContent",
+    "z"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/report-cli.js

@@ -0,0 +1,189 @@
+"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__, {
+    reportFileToMarkdown: ()=>reportFileToMarkdown,
+    createReportCliCommands: ()=>createReportCliCommands,
+    splitReportFile: ()=>splitReportFile
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+const external_zod_namespaceObject = require("zod");
+const screenshot_store_js_namespaceObject = require("./dump/screenshot-store.js");
+const external_report_js_namespaceObject = require("./report.js");
+const external_report_markdown_js_namespaceObject = require("./report-markdown.js");
+const external_types_js_namespaceObject = require("./types.js");
+function writeAttachmentFromReport(attachment, opts) {
+    const { suggestedFileName, id, mimeType } = attachment;
+    if (opts.writtenFiles.has(suggestedFileName)) return;
+    const absolutePath = external_node_path_namespaceObject.join(opts.screenshotsDir, suggestedFileName);
+    const outputRelativePath = `./screenshots/${suggestedFileName}`;
+    const sourceRef = attachment.filePath !== outputRelativePath ? {
+        type: 'midscene_screenshot_ref',
+        id,
+        capturedAt: 0,
+        mimeType: mimeType || 'image/png',
+        storage: 'file',
+        path: attachment.filePath
+    } : null;
+    const resolved = (0, screenshot_store_js_namespaceObject.resolveScreenshotSource)(sourceRef, {
+        reportPath: opts.htmlPath,
+        fallbackId: id,
+        fallbackMimeType: mimeType || 'image/png'
+    });
+    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'));
+        opts.writtenFiles.add(suggestedFileName);
+        return;
+    }
+    if (!(0, external_node_fs_namespaceObject.existsSync)(resolved.filePath)) throw new Error(`Cannot resolve screenshot "${id}" for markdown attachment from ${opts.htmlPath}`);
+    (0, external_node_fs_namespaceObject.copyFileSync)(resolved.filePath, absolutePath);
+    opts.writtenFiles.add(suggestedFileName);
+}
+async function markdownFromReport(htmlPath, outputDir) {
+    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 { baseDump, executions } = (0, external_report_js_namespaceObject.collectDedupedExecutions)(htmlPath);
+    const mergedReport = new external_types_js_namespaceObject.ReportActionDump({
+        sdkVersion: baseDump.sdkVersion,
+        groupName: baseDump.groupName,
+        groupDescription: baseDump.groupDescription,
+        modelBriefs: baseDump.modelBriefs,
+        deviceType: baseDump.deviceType,
+        executions
+    });
+    const result = (0, external_report_markdown_js_namespaceObject.reportToMarkdown)(mergedReport);
+    const markdownFiles = [];
+    const writtenScreenshots = new Set();
+    const mdPath = external_node_path_namespaceObject.join(outputDir, 'report.md');
+    (0, external_node_fs_namespaceObject.writeFileSync)(mdPath, result.markdown, 'utf-8');
+    markdownFiles.push(mdPath);
+    for (const attachment of result.attachments)writeAttachmentFromReport(attachment, {
+        htmlPath,
+        screenshotsDir,
+        writtenFiles: writtenScreenshots
+    });
+    return {
+        markdownFiles,
+        screenshotFiles: Array.from(writtenScreenshots).sort().map((f)=>external_node_path_namespaceObject.join(screenshotsDir, f))
+    };
+}
+function resolveReportHtmlPath(htmlPath) {
+    const normalizedPath = external_node_path_namespaceObject.resolve(htmlPath);
+    if (!(0, external_node_fs_namespaceObject.existsSync)(normalizedPath)) throw new Error(`report-tool: --htmlPath does not exist: ${htmlPath}`);
+    const stats = (0, external_node_fs_namespaceObject.statSync)(normalizedPath);
+    if (!stats.isDirectory()) return normalizedPath;
+    const indexHtmlPath = external_node_path_namespaceObject.join(normalizedPath, 'index.html');
+    if (!(0, external_node_fs_namespaceObject.existsSync)(indexHtmlPath)) throw new Error(`report-tool: "${htmlPath}" is not an HTML report file, and no index.html was found under this directory.`);
+    return indexHtmlPath;
+}
+function splitReportFile(options) {
+    const { htmlPath, outputDir } = options;
+    if (!htmlPath) throw new Error('splitReportFile: htmlPath is required');
+    if (!outputDir) throw new Error('splitReportFile: outputDir is required');
+    const resolvedHtmlPath = resolveReportHtmlPath(htmlPath);
+    return (0, external_report_js_namespaceObject.splitReportHtmlByExecution)({
+        htmlPath: resolvedHtmlPath,
+        outputDir
+    });
+}
+async function reportFileToMarkdown(options) {
+    const { htmlPath, outputDir } = options;
+    if (!htmlPath) throw new Error('reportFileToMarkdown: htmlPath is required');
+    if (!outputDir) throw new Error('reportFileToMarkdown: outputDir is required');
+    const resolvedHtmlPath = resolveReportHtmlPath(htmlPath);
+    return markdownFromReport(resolvedHtmlPath, outputDir);
+}
+const reportCommandDefinition = {
+    name: 'report-tool',
+    description: 'Transform Midscene report artifacts, including splitting executions and converting to markdown.',
+    schema: {
+        action: external_zod_namespaceObject.z["enum"]([
+            'split',
+            'to-markdown'
+        ]).optional().describe('Report action to run. Supports: split, to-markdown. Defaults to split.'),
+        htmlPath: external_zod_namespaceObject.z.string().optional().describe('Input report HTML path (e.g. ./report/index.html)'),
+        outputDir: external_zod_namespaceObject.z.string().optional().describe('Output directory for generated report artifacts')
+    },
+    handler: async (args)=>{
+        const { action = 'split', htmlPath, outputDir } = args;
+        if ('split' !== action && 'to-markdown' !== action) throw new Error(`report-tool: unsupported --action value "${action}". Currently supported: split, to-markdown`);
+        if (!htmlPath) throw new Error('report-tool: --htmlPath is required');
+        if (!outputDir) throw new Error('report-tool: --outputDir is required');
+        if ('to-markdown' === action) {
+            const result = await reportFileToMarkdown({
+                htmlPath,
+                outputDir
+            });
+            return {
+                isError: false,
+                content: [
+                    {
+                        type: 'text',
+                        text: `Markdown export completed. Generated ${result.markdownFiles.length} markdown file(s) and ${result.screenshotFiles.length} screenshot(s). Output path: ${outputDir}`
+                    }
+                ]
+            };
+        }
+        const result = splitReportFile({
+            htmlPath,
+            outputDir
+        });
+        return {
+            isError: false,
+            content: [
+                {
+                    type: 'text',
+                    text: `Report split completed. Generated ${result.executionJsonFiles.length} execution JSON files and ${result.screenshotFiles.length} screenshots. Output path: ${outputDir}`
+                }
+            ]
+        };
+    }
+};
+function createReportCliCommands() {
+    return [
+        {
+            name: 'report-tool',
+            def: reportCommandDefinition
+        }
+    ];
+}
+exports.createReportCliCommands = __webpack_exports__.createReportCliCommands;
+exports.reportFileToMarkdown = __webpack_exports__.reportFileToMarkdown;
+exports.splitReportFile = __webpack_exports__.splitReportFile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createReportCliCommands",
+    "reportFileToMarkdown",
+    "splitReportFile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/report-generator.js

@@ -0,0 +1,244 @@
+"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__, {
+    ReportGenerator: ()=>ReportGenerator,
+    assertReportGenerationOptions: ()=>assertReportGenerationOptions,
+    nullReportGenerator: ()=>nullReportGenerator
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const promises_namespaceObject = require("node:fs/promises");
+const external_node_path_namespaceObject = require("node:path");
+const common_namespaceObject = require("@godscene/shared/common");
+const env_namespaceObject = require("@godscene/shared/env");
+const utils_namespaceObject = require("@godscene/shared/utils");
+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;
+}
+const nullReportGenerator = {
+    onExecutionUpdate: ()=>{},
+    flush: async ()=>{},
+    finalize: async ()=>void 0,
+    getReportPath: ()=>void 0
+};
+function assertReportGenerationOptions(opts) {
+    if (false === opts.generateReport && true === opts.persistExecutionDump) throw new Error('persistExecutionDump cannot be true when generateReport is false');
+}
+class ReportGenerator {
+    static create(reportFileName, opts) {
+        assertReportGenerationOptions(opts);
+        if (false === opts.generateReport) return nullReportGenerator;
+        if (utils_namespaceObject.ifInBrowser) return nullReportGenerator;
+        validateReportFileName(reportFileName);
+        const reportRootDir = (0, common_namespaceObject.getMidsceneRunSubDir)('report');
+        const outputDir = (0, external_node_path_namespaceObject.join)(reportRootDir, reportFileName);
+        const reportPath = 'html-and-external-assets' === opts.outputFormat ? (0, external_node_path_namespaceObject.join)(outputDir, 'index.html') : (0, external_node_path_namespaceObject.join)(reportRootDir, ensureHtmlFileName(reportFileName));
+        return new ReportGenerator({
+            reportPath,
+            screenshotMode: 'html-and-external-assets' === opts.outputFormat ? 'directory' : 'inline',
+            persistExecutionDump: opts.persistExecutionDump,
+            autoPrint: opts.autoPrintReportMsg,
+            reuseExistingReport: opts.reuseExistingReport
+        });
+    }
+    onExecutionUpdate(execution, reportMeta, attributes) {
+        this.lastExecution = execution;
+        this.lastReportMeta = reportMeta;
+        this.mergeReportAttributes(attributes);
+        this.writeQueue = this.writeQueue.then(async ()=>{
+            if (this.destroyed) return;
+            await this.doWriteExecution(execution, reportMeta);
+        });
+    }
+    async flush() {
+        await this.writeQueue;
+    }
+    async finalize() {
+        if (this.lastExecution && this.lastReportMeta) this.onExecutionUpdate(this.lastExecution, this.lastReportMeta);
+        await this.flush();
+        this.destroyed = true;
+        if (!this.initialized) return;
+        this.printReportPath('finalized');
+        return this.reportPath;
+    }
+    getReportPath() {
+        return this.reportPath;
+    }
+    printReportPath(verb) {
+        if (!this.autoPrint || !this.reportPath) return;
+        if (env_namespaceObject.globalConfigManager.getEnvConfigInBoolean(env_namespaceObject.MIDSCENE_REPORT_QUIET)) return;
+        if ('directory' === this.screenshotMode) (0, utils_namespaceObject.logMsg)(`Midscene - report ${verb}: npx serve ${(0, external_node_path_namespaceObject.dirname)(this.reportPath)}`);
+        else (0, utils_namespaceObject.logMsg)(`Midscene - report ${verb}: ${this.reportPath}`);
+    }
+    async doWriteExecution(execution, reportMeta) {
+        const singleDump = this.wrapAsReportDump(execution, reportMeta);
+        if ('inline' === this.screenshotMode) await this.writeInlineExecution(execution, singleDump);
+        else await this.writeDirectoryExecution(execution, singleDump);
+        if (this.shouldPersistExecutionDump) await this.persistExecutionDumpToFile(execution, singleDump);
+        if (!this.firstWriteDone) {
+            this.firstWriteDone = true;
+            this.printReportPath('generated');
+        }
+    }
+    mergeReportAttributes(attributes) {
+        if (!attributes) return;
+        for (const [key, value] of Object.entries(attributes))if (null != value) this.reportAttributes[key] = String(value);
+    }
+    hydrateStateFromExistingReport() {
+        if (!(0, external_node_fs_namespaceObject.existsSync)(this.reportPath)) return;
+        this.initialized = true;
+        if (!this.shouldPersistExecutionDump) return;
+        const reportDir = (0, external_node_path_namespaceObject.dirname)(this.reportPath);
+        const existingExecutionIndices = (0, external_node_fs_namespaceObject.readdirSync)(reportDir).map((name)=>/^(\d+)\.execution\.json$/.exec(name)?.[1]).filter((index)=>Boolean(index)).map((index)=>Number.parseInt(index, 10)).filter((index)=>Number.isFinite(index));
+        if (existingExecutionIndices.length > 0) this.executionLogIndex = Math.max(...existingExecutionIndices);
+    }
+    getDumpScriptAttributes() {
+        return {
+            'data-group-id': this.reportStreamId,
+            ...this.reportAttributes
+        };
+    }
+    wrapAsReportDump(execution, reportMeta) {
+        return new external_types_js_namespaceObject.ReportActionDump({
+            sdkVersion: reportMeta.sdkVersion,
+            groupName: reportMeta.groupName,
+            groupDescription: reportMeta.groupDescription,
+            modelBriefs: reportMeta.modelBriefs,
+            deviceType: reportMeta.deviceType,
+            executions: [
+                execution
+            ]
+        });
+    }
+    async writeInlineExecution(execution, singleDump) {
+        const dir = (0, external_node_path_namespaceObject.dirname)(this.reportPath);
+        if (!(0, external_node_fs_namespaceObject.existsSync)(dir)) (0, external_node_fs_namespaceObject.mkdirSync)(dir, {
+            recursive: true
+        });
+        if (!this.initialized) {
+            await (0, promises_namespaceObject.writeFile)(this.reportPath, (0, external_utils_js_namespaceObject.getReportTpl)());
+            this.initialized = true;
+        }
+        for (const screenshot of execution.collectScreenshots())await this.screenshotStore.persist(screenshot);
+        const serialized = singleDump.serialize();
+        await (0, promises_namespaceObject.appendFile)(this.reportPath, `\n${(0, html_utils_js_namespaceObject.generateDumpScriptTag)(serialized, this.getDumpScriptAttributes())}`);
+    }
+    async writeDirectoryExecution(execution, singleDump) {
+        const dir = (0, external_node_path_namespaceObject.dirname)(this.reportPath);
+        if (!(0, external_node_fs_namespaceObject.existsSync)(dir)) (0, external_node_fs_namespaceObject.mkdirSync)(dir, {
+            recursive: true
+        });
+        for (const screenshot of execution.collectScreenshots())await this.screenshotStore.persist(screenshot);
+        const serialized = singleDump.serialize();
+        if (!this.initialized) {
+            await (0, promises_namespaceObject.writeFile)(this.reportPath, `${(0, external_utils_js_namespaceObject.getReportTpl)()}${(0, html_utils_js_namespaceObject.getBaseUrlFixScript)()}`);
+            this.initialized = true;
+        }
+        await (0, promises_namespaceObject.appendFile)(this.reportPath, `\n${(0, html_utils_js_namespaceObject.generateDumpScriptTag)(serialized, this.getDumpScriptAttributes())}`);
+    }
+    getExecutionLogKey(execution) {
+        if (!execution.id) throw new Error('ReportGenerator: execution.id is required for persisting execution dumps');
+        return `id:${execution.id}`;
+    }
+    async persistExecutionDumpToFile(execution, singleDump) {
+        const dir = (0, external_node_path_namespaceObject.dirname)(this.reportPath);
+        if (!(0, external_node_fs_namespaceObject.existsSync)(dir)) (0, external_node_fs_namespaceObject.mkdirSync)(dir, {
+            recursive: true
+        });
+        const executionLogKey = this.getExecutionLogKey(execution);
+        let fileIndex = this.executionLogFileIndexByExecutionKey.get(executionLogKey);
+        if (!fileIndex) {
+            this.executionLogIndex += 1;
+            fileIndex = this.executionLogIndex;
+            this.executionLogFileIndexByExecutionKey.set(executionLogKey, fileIndex);
+        }
+        const fileName = `${fileIndex}.execution.json`;
+        const filePath = (0, external_node_path_namespaceObject.join)((0, external_node_path_namespaceObject.dirname)(this.reportPath), fileName);
+        await (0, promises_namespaceObject.writeFile)(filePath, singleDump.serialize(2), 'utf-8');
+    }
+    constructor(options){
+        _define_property(this, "reportPath", void 0);
+        _define_property(this, "screenshotMode", void 0);
+        _define_property(this, "shouldPersistExecutionDump", void 0);
+        _define_property(this, "autoPrint", void 0);
+        _define_property(this, "firstWriteDone", false);
+        _define_property(this, "executionLogIndex", 0);
+        _define_property(this, "executionLogFileIndexByExecutionKey", new Map());
+        _define_property(this, "reportStreamId", void 0);
+        _define_property(this, "screenshotStore", void 0);
+        _define_property(this, "initialized", false);
+        _define_property(this, "lastExecution", void 0);
+        _define_property(this, "lastReportMeta", void 0);
+        _define_property(this, "reportAttributes", {});
+        _define_property(this, "writeQueue", Promise.resolve());
+        _define_property(this, "destroyed", false);
+        this.reportPath = options.reportPath;
+        this.screenshotMode = options.screenshotMode;
+        this.shouldPersistExecutionDump = options.persistExecutionDump ?? false;
+        this.autoPrint = options.autoPrint ?? true;
+        this.reportStreamId = (0, utils_namespaceObject.uuid)();
+        this.screenshotStore = new screenshot_store_js_namespaceObject.ScreenshotStore({
+            mode: 'inline' === this.screenshotMode ? 'inline' : 'directory',
+            reportPath: this.reportPath,
+            screenshotsDir: (0, external_node_path_namespaceObject.join)((0, external_node_path_namespaceObject.dirname)(this.reportPath), 'screenshots'),
+            writeInlineImage: async (id, base64)=>{
+                await (0, promises_namespaceObject.appendFile)(this.reportPath, `\n${(0, html_utils_js_namespaceObject.generateImageScriptTag)(id, base64)}`);
+            },
+            alsoWriteFileCopy: this.shouldPersistExecutionDump
+        });
+        if (options.reuseExistingReport) this.hydrateStateFromExistingReport();
+        this.printReportPath('will be generated at');
+    }
+}
+function ensureHtmlFileName(reportFileName) {
+    return reportFileName.endsWith('.html') ? reportFileName : `${reportFileName}.html`;
+}
+function validateReportFileName(reportFileName) {
+    if (!reportFileName?.trim()) throw new Error('reportFileName must be a non-empty string');
+    if (/[\\/]/.test(reportFileName)) throw new Error('reportFileName must not contain path separators (`/` or `\\\\`)');
+    if (/[:*?"<>|]/.test(reportFileName)) throw new Error('reportFileName contains illegal filename characters: : * ? " < > |');
+}
+exports.ReportGenerator = __webpack_exports__.ReportGenerator;
+exports.assertReportGenerationOptions = __webpack_exports__.assertReportGenerationOptions;
+exports.nullReportGenerator = __webpack_exports__.nullReportGenerator;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ReportGenerator",
+    "assertReportGenerationOptions",
+    "nullReportGenerator"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});