@godscene/core 1.7.11

package/dist/lib/task-runner.js

@@ -0,0 +1,298 @@
+"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__, {
+    TaskExecutionError: ()=>TaskExecutionError,
+    TaskRunner: ()=>TaskRunner
+});
+const external_task_timing_js_namespaceObject = require("./task-timing.js");
+const external_types_js_namespaceObject = require("./types.js");
+const logger_namespaceObject = require("@godscene/shared/logger");
+const utils_namespaceObject = require("@godscene/shared/utils");
+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 debug = (0, logger_namespaceObject.getDebug)('task-runner');
+const UI_CONTEXT_CACHE_TTL_MS = 300;
+class TaskRunner {
+    async emitOnTaskUpdate(error) {
+        if (!this.onTaskUpdate) return;
+        await this.onTaskUpdate(this, error);
+    }
+    async getUiContext(options) {
+        const now = Date.now();
+        const shouldReuse = !options?.forceRefresh && this.lastUiContext && now - this.lastUiContext.capturedAt <= UI_CONTEXT_CACHE_TTL_MS;
+        if (shouldReuse && this.lastUiContext?.context) {
+            debug(`reuse cached uiContext captured ${now - this.lastUiContext.capturedAt}ms ago`);
+            return this.lastUiContext?.context;
+        }
+        try {
+            const uiContext = await this.uiContextBuilder();
+            if (uiContext) this.lastUiContext = {
+                context: uiContext,
+                capturedAt: Date.now()
+            };
+            else this.lastUiContext = void 0;
+            return uiContext;
+        } catch (error) {
+            this.lastUiContext = void 0;
+            throw error;
+        }
+    }
+    async captureScreenshot() {
+        try {
+            const uiContext = await this.getUiContext({
+                forceRefresh: true
+            });
+            return uiContext?.screenshot;
+        } catch (error) {
+            console.error('error while capturing screenshot', error);
+        }
+    }
+    attachRecorderItem(task, screenshot, phase) {
+        if (!phase || !screenshot) return;
+        const recorderItem = {
+            type: 'screenshot',
+            ts: Date.now(),
+            screenshot,
+            timing: phase
+        };
+        if (!task.recorder) {
+            task.recorder = [
+                recorderItem
+            ];
+            return;
+        }
+        task.recorder.push(recorderItem);
+    }
+    markTaskAsPending(task) {
+        return {
+            taskId: (0, utils_namespaceObject.uuid)(),
+            status: 'pending',
+            ...task
+        };
+    }
+    normalizeStatusFromError(options, errorMessage) {
+        if ('error' !== this.status) return;
+        (0, utils_namespaceObject.assert)(options?.allowWhenError, errorMessage || `task runner is in error state, cannot proceed\nerror=${this.latestErrorTask()?.error}\n${this.latestErrorTask()?.errorStack}`);
+        this.status = this.tasks.length > 0 ? 'pending' : 'init';
+    }
+    async append(task, options) {
+        this.normalizeStatusFromError(options, `task runner is in error state, cannot append task\nerror=${this.latestErrorTask()?.error}\n${this.latestErrorTask()?.errorStack}`);
+        if (Array.isArray(task)) this.tasks.push(...task.map((item)=>this.markTaskAsPending(item)));
+        else this.tasks.push(this.markTaskAsPending(task));
+        if ('running' !== this.status) this.status = 'pending';
+        await this.emitOnTaskUpdate();
+    }
+    async appendAndFlush(task, options) {
+        await this.append(task, options);
+        return this.flush(options);
+    }
+    async flush(options) {
+        if ('init' === this.status && this.tasks.length > 0) console.warn('illegal state for task runner, status is init but tasks are not empty');
+        this.normalizeStatusFromError(options, 'task runner is in error state');
+        (0, utils_namespaceObject.assert)('running' !== this.status, 'task runner is already running');
+        (0, utils_namespaceObject.assert)('completed' !== this.status, 'task runner is already completed');
+        const nextPendingIndex = this.tasks.findIndex((task)=>'pending' === task.status);
+        if (nextPendingIndex < 0) return;
+        this.status = 'running';
+        await this.emitOnTaskUpdate();
+        let taskIndex = nextPendingIndex;
+        let successfullyCompleted = true;
+        let previousFindOutput;
+        while(taskIndex < this.tasks.length){
+            const task = this.tasks[taskIndex];
+            (0, utils_namespaceObject.assert)('pending' === task.status, `task status should be pending, but got: ${task.status}`);
+            task.timing = {
+                start: Date.now()
+            };
+            try {
+                task.status = 'running';
+                await this.emitOnTaskUpdate();
+                try {
+                    if (this.onTaskStart) await this.onTaskStart(task);
+                } catch (e) {
+                    console.error('error in onTaskStart', e);
+                }
+                (0, utils_namespaceObject.assert)([
+                    'Insight',
+                    'Action Space',
+                    'Planning'
+                ].indexOf(task.type) >= 0, `unsupported task type: ${task.type}`);
+                const { executor, param } = task;
+                (0, utils_namespaceObject.assert)(executor, `executor is required for task type: ${task.type}`);
+                let returnValue;
+                const forceRefresh = 'Insight' === task.type;
+                (0, external_task_timing_js_namespaceObject.setTimingFieldOnce)(task.timing, 'getUiContextStart');
+                const uiContext = await this.getUiContext({
+                    forceRefresh
+                });
+                (0, external_task_timing_js_namespaceObject.setTimingFieldOnce)(task.timing, 'getUiContextEnd');
+                task.uiContext = uiContext;
+                const executorContext = {
+                    task,
+                    element: previousFindOutput?.element,
+                    uiContext
+                };
+                if ('Insight' === task.type) {
+                    (0, utils_namespaceObject.assert)('Query' === task.subType || 'Assert' === task.subType || 'WaitFor' === task.subType || 'Boolean' === task.subType || 'Number' === task.subType || 'String' === task.subType, `unsupported service subType: ${task.subType}`);
+                    returnValue = await task.executor(param, executorContext);
+                } else if ('Planning' === task.type) {
+                    returnValue = await task.executor(param, executorContext);
+                    if ('Locate' === task.subType) previousFindOutput = returnValue?.output;
+                } else if ('Action Space' === task.type) returnValue = await task.executor(param, executorContext);
+                else {
+                    console.warn(`unsupported task type: ${task.type}, will try to execute it directly`);
+                    returnValue = await task.executor(param, executorContext);
+                }
+                const isLastTask = taskIndex === this.tasks.length - 1;
+                if (isLastTask) {
+                    (0, external_task_timing_js_namespaceObject.setTimingFieldOnce)(task.timing, 'captureAfterCallingSnapshotStart');
+                    const screenshot = await this.captureScreenshot();
+                    this.attachRecorderItem(task, screenshot, 'after-calling');
+                    (0, external_task_timing_js_namespaceObject.setTimingFieldOnce)(task.timing, 'captureAfterCallingSnapshotEnd');
+                }
+                Object.assign(task, returnValue);
+                task.status = 'finished';
+                task.timing.end = Date.now();
+                task.timing.cost = task.timing.end - task.timing.start;
+                await this.emitOnTaskUpdate();
+                taskIndex++;
+            } catch (e) {
+                successfullyCompleted = false;
+                task.error = e;
+                task.errorMessage = e?.message || ('string' == typeof e ? e : 'error-without-message');
+                task.errorStack = e.stack;
+                task.status = 'failed';
+                task.timing.end = Date.now();
+                task.timing.cost = task.timing.end - task.timing.start;
+                await this.emitOnTaskUpdate();
+                break;
+            }
+        }
+        for(let i = taskIndex + 1; i < this.tasks.length; i++)this.tasks[i].status = 'cancelled';
+        if (taskIndex + 1 < this.tasks.length) await this.emitOnTaskUpdate();
+        let finalizeError;
+        if (successfullyCompleted) {
+            this.status = 'completed';
+            await this.emitOnTaskUpdate();
+        } else {
+            this.status = 'error';
+            const errorTask = this.latestErrorTask();
+            const messageBase = errorTask?.errorMessage || (errorTask?.error ? String(errorTask.error) : 'Task execution failed');
+            const stack = errorTask?.errorStack;
+            const message = stack ? `${messageBase}\n${stack}` : messageBase;
+            finalizeError = new TaskExecutionError(message, this, errorTask, {
+                cause: errorTask?.error
+            });
+            await this.emitOnTaskUpdate(finalizeError);
+        }
+        if (finalizeError) throw finalizeError;
+        if (this.tasks.length) {
+            const outputIndex = Math.min(taskIndex, this.tasks.length - 1);
+            const { thought, output } = this.tasks[outputIndex];
+            return {
+                thought,
+                output
+            };
+        }
+    }
+    isInErrorState() {
+        return 'error' === this.status;
+    }
+    latestErrorTask() {
+        if ('error' !== this.status) return null;
+        for(let i = this.tasks.length - 1; i >= 0; i--)if ('failed' === this.tasks[i].status) return this.tasks[i];
+        return null;
+    }
+    dump() {
+        return new external_types_js_namespaceObject.ExecutionDump({
+            id: this.id,
+            logTime: this.executionLogTime,
+            name: this.name,
+            tasks: this.tasks
+        });
+    }
+    async appendErrorPlan(errorMsg) {
+        const errorTask = {
+            type: 'Action Space',
+            subType: 'Error',
+            param: {
+                thought: errorMsg
+            },
+            thought: errorMsg,
+            executor: async ()=>{
+                throw new Error(errorMsg || 'error without thought');
+            }
+        };
+        await this.appendAndFlush(errorTask);
+        return {
+            output: void 0,
+            runner: this
+        };
+    }
+    constructor(name, uiContextBuilder, options){
+        _define_property(this, "id", void 0);
+        _define_property(this, "name", void 0);
+        _define_property(this, "tasks", void 0);
+        _define_property(this, "status", void 0);
+        _define_property(this, "onTaskStart", void 0);
+        _define_property(this, "uiContextBuilder", void 0);
+        _define_property(this, "onTaskUpdate", void 0);
+        _define_property(this, "executionLogTime", void 0);
+        _define_property(this, "lastUiContext", void 0);
+        this.id = (0, utils_namespaceObject.uuid)();
+        this.status = options?.tasks && options.tasks.length > 0 ? 'pending' : 'init';
+        this.name = name;
+        this.tasks = (options?.tasks || []).map((item)=>this.markTaskAsPending(item));
+        this.onTaskStart = options?.onTaskStart;
+        this.uiContextBuilder = uiContextBuilder;
+        this.onTaskUpdate = options?.onTaskUpdate;
+        this.executionLogTime = Date.now();
+    }
+}
+class TaskExecutionError extends Error {
+    constructor(message, runner, errorTask, options){
+        super(message, options), _define_property(this, "runner", void 0), _define_property(this, "errorTask", void 0);
+        this.runner = runner;
+        this.errorTask = errorTask;
+    }
+}
+exports.TaskExecutionError = __webpack_exports__.TaskExecutionError;
+exports.TaskRunner = __webpack_exports__.TaskRunner;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "TaskExecutionError",
+    "TaskRunner"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/task-timing.js

@@ -0,0 +1,44 @@
+"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__, {
+    setTimingFieldOnce: ()=>setTimingFieldOnce
+});
+const logger_namespaceObject = require("@godscene/shared/logger");
+const debugTiming = (0, logger_namespaceObject.getDebug)('task-timing');
+function setTimingFieldOnce(timing, field) {
+    if (!timing) return void debugTiming(`[warning] timing object missing, skip set. field=${field}`);
+    const value = Date.now();
+    const existingValue = timing[field];
+    if (void 0 !== existingValue) return void debugTiming(`[warning] duplicate timing field set ignored. field=${field}, existing=${existingValue}, incoming=${value}`);
+    timing[field] = value;
+}
+exports.setTimingFieldOnce = __webpack_exports__.setTimingFieldOnce;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "setTimingFieldOnce"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/tree.js

@@ -0,0 +1,51 @@
+"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__, {
+    descriptionOfTree: ()=>descriptionOfTree,
+    truncateText: ()=>extractor_namespaceObject.truncateText,
+    trimAttributes: ()=>extractor_namespaceObject.trimAttributes
+});
+const extractor_namespaceObject = require("@godscene/shared/extractor");
+const ELEMENT_COUNT_WARNING_THRESHOLD = 5000;
+const TREE_SIZE_WARNING_MESSAGE = 'The number of elements is too large, it may cause the prompt to be too long, please use domIncluded: "visible-only" to reduce the number of elements';
+function descriptionOfTree(tree, truncateTextLength, filterNonTextContent = false, visibleOnly = true) {
+    if (!visibleOnly) {
+        const flatElements = (0, extractor_namespaceObject.treeToList)(tree);
+        if (flatElements.length >= ELEMENT_COUNT_WARNING_THRESHOLD) console.warn(TREE_SIZE_WARNING_MESSAGE);
+    }
+    return (0, extractor_namespaceObject.descriptionOfTree)(tree, truncateTextLength, filterNonTextContent, visibleOnly);
+}
+exports.descriptionOfTree = __webpack_exports__.descriptionOfTree;
+exports.trimAttributes = __webpack_exports__.trimAttributes;
+exports.truncateText = __webpack_exports__.truncateText;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "descriptionOfTree",
+    "trimAttributes",
+    "truncateText"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/types.js

@@ -0,0 +1,298 @@
+"use strict";
+var __webpack_modules__ = {
+    "./dump/screenshot-restoration" (module) {
+        module.exports = require("./dump/screenshot-restoration.js");
+    },
+    "./dump/screenshot-store" (module) {
+        module.exports = require("./dump/screenshot-store.js");
+    },
+    "./screenshot-item" (module) {
+        module.exports = require("./screenshot-item.js");
+    },
+    "./yaml" (module) {
+        module.exports = require("./yaml.js");
+    },
+    "node:fs" (module) {
+        module.exports = require("node:fs");
+    },
+    "node:path" (module) {
+        module.exports = require("node:path");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __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__, {
+        ExecutionDump: ()=>ExecutionDump,
+        GroupedActionDump: ()=>GroupedActionDump,
+        ReportActionDump: ()=>ReportActionDump,
+        ServiceError: ()=>ServiceError,
+        UIContext: ()=>UIContext
+    });
+    var node_fs__rspack_import_0 = __webpack_require__("node:fs");
+    var node_path__rspack_import_1 = __webpack_require__("node:path");
+    var _dump_screenshot_restoration__rspack_import_2 = __webpack_require__("./dump/screenshot-restoration");
+    var _dump_screenshot_store__rspack_import_3 = __webpack_require__("./dump/screenshot-store");
+    var _screenshot_item__rspack_import_4 = __webpack_require__("./screenshot-item");
+    var _yaml__rspack_import_5 = __webpack_require__("./yaml");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _yaml__rspack_import_5)if ([
+        "UIContext",
+        "ServiceError",
+        "default",
+        "ReportActionDump",
+        "GroupedActionDump",
+        "ExecutionDump"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_yaml__rspack_import_5[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    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;
+    }
+    class UIContext {
+    }
+    class ServiceError extends Error {
+        constructor(message, dump){
+            super(message), _define_property(this, "dump", void 0);
+            this.name = 'ServiceError';
+            this.dump = dump;
+        }
+    }
+    function replacerForDumpSerialization(_key, value) {
+        if (value && value.constructor?.name === 'Page') return '[Page object]';
+        if (value && value.constructor?.name === 'Browser') return '[Browser object]';
+        if (value && 'function' == typeof value.toSerializable) return value.toSerializable();
+        return value;
+    }
+    function reviverForDumpDeserialization(key, value) {
+        if ('screenshot' !== key || 'object' != typeof value || null === value) return value;
+        _screenshot_item__rspack_import_4.ScreenshotItem.isSerialized(value);
+        return value;
+    }
+    class ExecutionDump {
+        serialize(indents) {
+            return JSON.stringify(this.toJSON(), replacerForDumpSerialization, indents);
+        }
+        toJSON() {
+            return {
+                id: this.id,
+                logTime: this.logTime,
+                name: this.name,
+                description: this.description,
+                tasks: this.tasks.map((task)=>({
+                        ...task,
+                        recorder: task.recorder || []
+                    })),
+                aiActContext: this.aiActContext
+            };
+        }
+        static fromSerializedString(serialized) {
+            const parsed = JSON.parse(serialized, reviverForDumpDeserialization);
+            return new ExecutionDump(parsed);
+        }
+        static fromJSON(data) {
+            return new ExecutionDump(data);
+        }
+        collectScreenshots() {
+            const screenshots = [];
+            for (const task of this.tasks){
+                if (task.uiContext?.screenshot instanceof _screenshot_item__rspack_import_4.ScreenshotItem) screenshots.push(task.uiContext.screenshot);
+                if (task.recorder) {
+                    for (const record of task.recorder)if (record.screenshot instanceof _screenshot_item__rspack_import_4.ScreenshotItem) screenshots.push(record.screenshot);
+                }
+            }
+            return screenshots;
+        }
+        constructor(data){
+            _define_property(this, "id", void 0);
+            _define_property(this, "logTime", void 0);
+            _define_property(this, "name", void 0);
+            _define_property(this, "description", void 0);
+            _define_property(this, "tasks", void 0);
+            _define_property(this, "aiActContext", void 0);
+            this.id = data.id;
+            this.logTime = data.logTime;
+            this.name = data.name;
+            this.description = data.description;
+            this.tasks = data.tasks;
+            this.aiActContext = data.aiActContext;
+        }
+    }
+    class ReportActionDump {
+        serialize(indents) {
+            return JSON.stringify(this.toJSON(), replacerForDumpSerialization, indents);
+        }
+        serializeWithInlineScreenshots(indents) {
+            const processValue = (obj)=>{
+                if (obj instanceof _screenshot_item__rspack_import_4.ScreenshotItem) return {
+                    base64: obj.base64,
+                    capturedAt: obj.capturedAt
+                };
+                if (Array.isArray(obj)) return obj.map(processValue);
+                if (obj && 'object' == typeof obj) {
+                    const entries = Object.entries(obj).map(([key, value])=>[
+                            key,
+                            processValue(value)
+                        ]);
+                    return Object.fromEntries(entries);
+                }
+                return obj;
+            };
+            const data = processValue(this.toJSON());
+            return JSON.stringify(data, null, indents);
+        }
+        toJSON() {
+            return {
+                sdkVersion: this.sdkVersion,
+                groupName: this.groupName,
+                groupDescription: this.groupDescription,
+                modelBriefs: this.modelBriefs,
+                executions: this.executions.map((exec)=>exec.toJSON()),
+                deviceType: this.deviceType
+            };
+        }
+        static fromSerializedString(serialized) {
+            const parsed = JSON.parse(serialized, reviverForDumpDeserialization);
+            return new ReportActionDump(parsed);
+        }
+        static fromJSON(data) {
+            return new ReportActionDump(data);
+        }
+        collectAllScreenshots() {
+            const screenshots = [];
+            for (const execution of this.executions)screenshots.push(...execution.collectScreenshots());
+            return screenshots;
+        }
+        serializeToFiles(basePath) {
+            const screenshotsDir = `${basePath}.screenshots`;
+            if (!(0, node_fs__rspack_import_0.existsSync)(screenshotsDir)) (0, node_fs__rspack_import_0.mkdirSync)(screenshotsDir, {
+                recursive: true
+            });
+            const screenshots = this.collectAllScreenshots();
+            for (const screenshot of screenshots){
+                const imagePath = (0, node_path__rspack_import_1.join)(screenshotsDir, `${screenshot.id}.${screenshot.extension}`);
+                if ((0, node_fs__rspack_import_0.existsSync)(imagePath)) continue;
+                const rawBase64 = screenshot.rawBase64;
+                (0, node_fs__rspack_import_0.writeFileSync)(imagePath, Buffer.from(rawBase64, 'base64'));
+            }
+            (0, node_fs__rspack_import_0.writeFileSync)(basePath, this.serialize(), 'utf-8');
+        }
+        static fromFilesAsInlineJson(basePath) {
+            const dumpString = (0, node_fs__rspack_import_0.readFileSync)(basePath, 'utf-8');
+            const screenshotsDir = `${basePath}.screenshots`;
+            const loadFromExecutionScreenshotDir = (id, mimeType)=>{
+                const ext = 'image/jpeg' === mimeType ? 'jpeg' : 'png';
+                const filePath = (0, node_path__rspack_import_1.join)(screenshotsDir, `${id}.${ext}`);
+                if (!(0, node_fs__rspack_import_0.existsSync)(filePath)) return '';
+                const data = (0, node_fs__rspack_import_0.readFileSync)(filePath);
+                return `data:image/${ext};base64,${data.toString('base64')}`;
+            };
+            const dumpData = JSON.parse(dumpString);
+            const store = new _dump_screenshot_store__rspack_import_3.ScreenshotStore({
+                mode: 'directory',
+                reportPath: basePath
+            });
+            const processedData = (0, _dump_screenshot_restoration__rspack_import_2.restoreImageReferences)(dumpData, (ref)=>{
+                const executionFileImage = loadFromExecutionScreenshotDir(ref.id, ref.mimeType);
+                if (executionFileImage) return executionFileImage;
+                if ('inline' === ref.storage) return '';
+                return store.loadBase64(ref);
+            });
+            return JSON.stringify(processedData);
+        }
+        static cleanupFiles(basePath) {
+            const filesToClean = [
+                basePath,
+                `${basePath}.screenshots`
+            ];
+            for (const filePath of filesToClean)try {
+                (0, node_fs__rspack_import_0.rmSync)(filePath, {
+                    force: true,
+                    recursive: true
+                });
+            } catch  {}
+        }
+        static getFilePaths(basePath) {
+            return [
+                basePath,
+                `${basePath}.screenshots`
+            ];
+        }
+        constructor(data){
+            _define_property(this, "sdkVersion", void 0);
+            _define_property(this, "groupName", void 0);
+            _define_property(this, "groupDescription", void 0);
+            _define_property(this, "modelBriefs", void 0);
+            _define_property(this, "executions", void 0);
+            _define_property(this, "deviceType", void 0);
+            this.sdkVersion = data.sdkVersion;
+            this.groupName = data.groupName;
+            this.groupDescription = data.groupDescription;
+            this.modelBriefs = data.modelBriefs;
+            this.executions = data.executions.map((exec)=>exec instanceof ExecutionDump ? exec : ExecutionDump.fromJSON(exec));
+            this.deviceType = data.deviceType;
+        }
+    }
+    const GroupedActionDump = ReportActionDump;
+})();
+exports.ExecutionDump = __webpack_exports__.ExecutionDump;
+exports.GroupedActionDump = __webpack_exports__.GroupedActionDump;
+exports.ReportActionDump = __webpack_exports__.ReportActionDump;
+exports.ServiceError = __webpack_exports__.ServiceError;
+exports.UIContext = __webpack_exports__.UIContext;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ExecutionDump",
+    "GroupedActionDump",
+    "ReportActionDump",
+    "ServiceError",
+    "UIContext"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});