@aiscene/shared 8.0.2 → 8.0.4

package/dist/lib/cli/record-command.js

@@ -0,0 +1,164 @@
+"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 ('undefined' != 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__, {
+    createRecordCliCommand: ()=>createRecordCliCommand
+});
+const external_zod_namespaceObject = require("zod");
+const error_formatter_js_namespaceObject = require("../agent-tools/error-formatter.js");
+const observation_artifact_js_namespaceObject = require("../agent-tools/observation-artifact.js");
+const observation_record_js_namespaceObject = require("../agent-tools/observation-record.js");
+const external_interrupt_js_namespaceObject = require("./interrupt.js");
+const external_verbose_js_namespaceObject = require("./verbose.js");
+const recordCliMetadata = {
+    positionals: [
+        'action'
+    ],
+    options: {
+        intervalMs: {
+            preferredName: 'interval-ms',
+            aliases: [
+                'intervalMs'
+            ]
+        },
+        maxFrames: {
+            preferredName: 'max-frames',
+            aliases: [
+                'maxFrames'
+            ]
+        },
+        watchdogMs: {
+            preferredName: 'watchdog-ms',
+            aliases: [
+                'watchdogMs'
+            ]
+        },
+        action: {
+            hidden: true
+        }
+    }
+};
+function mergeCliMetadata(base, extra) {
+    return {
+        positionals: base.positionals,
+        options: {
+            ...base.options ?? {},
+            ...extra?.options ?? {}
+        }
+    };
+}
+function createErrorResult(message) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: message
+            }
+        ],
+        isError: true
+    };
+}
+function createRecordCliCommand(getAgent, initArgSchema = {}, initArgCliMetadata) {
+    return {
+        name: 'record',
+        description: 'Record the page/screen in the foreground until Ctrl+C or a termination signal, then save the ordered frame window for a later assert command.',
+        schema: {
+            action: external_zod_namespaceObject.z.literal('start').describe('Start a foreground recording. Press Ctrl+C to finish.'),
+            output: external_zod_namespaceObject.z.string().optional().describe('Path for the JSON observation manifest. Frames are stored in an adjacent <name>.frames directory. Defaults to a generated path under midscene_run/output.'),
+            intervalMs: external_zod_namespaceObject.z.number().min(200).optional().describe('Sampling interval in milliseconds. Defaults to 1000; minimum 200 (5fps).'),
+            maxFrames: external_zod_namespaceObject.z.number().int().min(2).optional().describe('Maximum buffered frames. Defaults to 30; minimum 2.'),
+            watchdogMs: external_zod_namespaceObject.z.number().min(0).optional().describe('Safety timeout in milliseconds. Defaults to 300000 (5 minutes); 0 disables it.'),
+            ...initArgSchema
+        },
+        cli: mergeCliMetadata(recordCliMetadata, initArgCliMetadata),
+        handler: async (args = {})=>{
+            if ('start' !== args.action) return createErrorResult('record requires the start operation (for example: record start --output ./observation.json)');
+            try {
+                const agent = await getAgent(args);
+                (0, external_verbose_js_namespaceObject.emitCliVerboseEvent)({
+                    event: 'agent_ready',
+                    tool: 'record'
+                });
+                if (!agent.startObserving) throw new Error('record is not supported because this agent does not provide startObserving');
+                const observationArtifacts = (0, observation_artifact_js_namespaceObject.resolveObservationArtifactAdapter)(agent);
+                if (!observationArtifacts) throw new Error('record is not supported because this agent does not provide observation artifact persistence');
+                const unsubscribeVerbose = (0, external_verbose_js_namespaceObject.attachCliVerboseDumpListener)(agent, {
+                    toolName: 'record'
+                });
+                let observer;
+                let interruptWaiter;
+                try {
+                    const watchdogMs = args.watchdogMs ?? 300000;
+                    observer = await agent.startObserving({
+                        intervalMs: args.intervalMs,
+                        maxFrames: args.maxFrames,
+                        watchdogMs
+                    });
+                    interruptWaiter = (0, external_interrupt_js_namespaceObject.createCliInterruptWaiter)(watchdogMs);
+                    (0, external_verbose_js_namespaceObject.emitCliVerboseEvent)({
+                        event: 'recording_ready',
+                        tool: 'record',
+                        watchdogMs
+                    });
+                    const stopReason = await interruptWaiter.result;
+                    (0, external_verbose_js_namespaceObject.emitCliVerboseEvent)({
+                        event: 'recording_stopping',
+                        tool: 'record',
+                        reason: stopReason
+                    });
+                    const observation = await observer.stop();
+                    const record = await observationArtifacts.exportRecord(observation);
+                    const outputPath = (0, observation_record_js_namespaceObject.writeUIObservationRecord)(record, args.output);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `Observation record saved: ${outputPath}`
+                            }
+                        ]
+                    };
+                } finally{
+                    try {
+                        await observer?.dispose?.();
+                    } finally{
+                        interruptWaiter?.dispose();
+                        unsubscribeVerbose();
+                    }
+                }
+            } catch (error) {
+                const errorMessage = (0, error_formatter_js_namespaceObject.getErrorMessage)(error);
+                console.error('Error executing record:', errorMessage);
+                return createErrorResult(`Failed to execute record: ${errorMessage}`);
+            }
+        }
+    };
+}
+exports.createRecordCliCommand = __webpack_exports__.createRecordCliCommand;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRecordCliCommand"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/cli/screenshot-file.js

@@ -0,0 +1,58 @@
+"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 ('undefined' != 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__, {
+    writeCliScreenshotFile: ()=>writeCliScreenshotFile
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_os_namespaceObject = require("node:os");
+const external_node_path_namespaceObject = require("node:path");
+function safeScreenshotFilenamePart(value) {
+    const text = 'string' == typeof value && value.length > 0 ? value : 'shot';
+    return text.replace(/[^a-zA-Z0-9._-]/g, '_') || 'shot';
+}
+function extensionFromImageMetadata(mimeType, extension) {
+    if ('jpeg' === extension || 'jpg' === extension) return 'jpeg';
+    if ('png' === extension) return 'png';
+    return 'image/jpeg' === mimeType ? 'jpeg' : 'png';
+}
+function writeCliScreenshotFile(rawBase64, options = {}) {
+    const extension = extensionFromImageMetadata(options.mimeType, options.extension);
+    const directory = options.directoryPath ? options.directoryPath : options.directoryName ? (0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), options.directoryName) : (0, external_node_os_namespaceObject.tmpdir)();
+    if (!(0, external_node_fs_namespaceObject.existsSync)(directory)) (0, external_node_fs_namespaceObject.mkdirSync)(directory, {
+        recursive: true
+    });
+    const filename = void 0 !== options.id ? `${safeScreenshotFilenamePart(options.id)}.${extension}` : `${options.filenamePrefix ?? 'screenshot'}-${Date.now()}.${extension}`;
+    const filePath = (0, external_node_path_namespaceObject.join)(directory, filename);
+    if (false !== options.overwrite || !(0, external_node_fs_namespaceObject.existsSync)(filePath)) (0, external_node_fs_namespaceObject.writeFileSync)(filePath, Buffer.from(rawBase64, 'base64'));
+    return filePath;
+}
+exports.writeCliScreenshotFile = __webpack_exports__.writeCliScreenshotFile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "writeCliScreenshotFile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/cli/verbose-ai-act.js

@@ -0,0 +1,273 @@
+"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 ('undefined' != 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__, {
+    buildAiActProgressEventLines: ()=>buildAiActProgressEventLines,
+    aiActCliProgressRenderer: ()=>aiActCliProgressRenderer,
+    cliAiActProgressScope: ()=>cliAiActProgressScope,
+    normalizeAiActProgressEventForCli: ()=>normalizeAiActProgressEventForCli
+});
+const external_verbose_screenshot_js_namespaceObject = require("./verbose-screenshot.js");
+const cliAiActProgressScope = 'aiAct';
+function isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function compactText(value) {
+    if (null == value || '' === value) return '';
+    if ('string' == typeof value) return value.length > 180 ? `${value.slice(0, 177)}...` : value;
+    if ('number' == typeof value || 'boolean' == typeof value) return String(value);
+    try {
+        const json = JSON.stringify(value);
+        return json.length > 180 ? `${json.slice(0, 177)}...` : json;
+    } catch  {
+        return String(value);
+    }
+}
+function numericValue(value) {
+    return 'number' == typeof value && Number.isFinite(value) ? value : void 0;
+}
+function firstText(values) {
+    for (const value of values){
+        const text = compactText(value);
+        if (text) return text;
+    }
+    return '';
+}
+function planPrefix(event) {
+    const planIndex = numericValue(event.planIndex);
+    if (!planIndex) return '[Midscene][aiAct]';
+    const planLimit = numericValue(event.planLimit);
+    return `[Midscene][aiAct][Plan ${Math.round(planIndex)}${planLimit ? `/${Math.round(planLimit)}` : ''}]`;
+}
+function eventKey(event, suffix) {
+    const sequence = numericValue(event.sequence);
+    if (sequence) return `aiAct:${sequence}:${suffix}`;
+    return [
+        'aiAct',
+        compactText(event.phase),
+        compactText(event.planIndex),
+        suffix
+    ].filter(Boolean).join(':');
+}
+function integerText(value) {
+    return String(Math.round(value));
+}
+function numberTuple2(value) {
+    if (Array.isArray(value) && value.length >= 2 && 'number' == typeof value[0] && 'number' == typeof value[1]) return [
+        value[0],
+        value[1]
+    ];
+}
+function numberTuple4(value) {
+    if (Array.isArray(value) && value.length >= 4 && value.slice(0, 4).every((item)=>'number' == typeof item)) return [
+        value[0],
+        value[1],
+        value[2],
+        value[3]
+    ];
+}
+function parseAction(value) {
+    if (!isRecord(value) || 'string' != typeof value.name) return;
+    return {
+        name: value.name,
+        target: 'string' == typeof value.target ? value.target : void 0,
+        point: numberTuple2(value.point),
+        bbox: numberTuple4(value.bbox),
+        param: value.param
+    };
+}
+function formatPoint(point) {
+    return `(${integerText(point[0])}, ${integerText(point[1])})`;
+}
+function formatBbox(bbox) {
+    return `(${bbox.map(integerText).join(',')})`;
+}
+function sleepActionText(action) {
+    if ('Sleep' !== action.name || !isRecord(action.param)) return;
+    const timeMs = numericValue(action.param.timeMs) ?? numericValue(action.param.duration) ?? numericValue(action.param.timeoutMs);
+    return void 0 !== timeMs ? `Sleep ${integerText(timeMs)}ms` : void 0;
+}
+function plannedActionText(action) {
+    if (action.point) {
+        const targetSegment = action.target ? ` "${action.target}"` : '';
+        const bboxSegment = action.bbox ? `, bbox=${formatBbox(action.bbox)}` : '';
+        return `${action.name}${targetSegment} at ${formatPoint(action.point)}${bboxSegment}`;
+    }
+    const sleep = sleepActionText(action);
+    if (sleep) return sleep;
+    const paramText = compactText(action.param);
+    return paramText ? `${action.name}: ${paramText}` : action.name;
+}
+function runningActionText(action) {
+    if (action.point) return `${action.name} at ${formatPoint(action.point)}`;
+    return plannedActionText(action);
+}
+function normalizeAiActProgressEventForCli(event, screenshotOptions = {}) {
+    if (!isRecord(event) || event.scope !== cliAiActProgressScope) return;
+    const data = isRecord(event.data) ? event.data : {};
+    const screenshots = (0, external_verbose_screenshot_js_namespaceObject.collectScreenshotRefs)(data.screenshot, screenshotOptions);
+    const latestPath = screenshots.slice().reverse().find((item)=>'string' == typeof item.path && item.path.length > 0)?.path;
+    const screenshotPath = 'string' == typeof latestPath ? (0, external_verbose_screenshot_js_namespaceObject.pathForReportScreenshot)(latestPath, screenshotOptions.reportFile) : void 0;
+    const { prompt, planIndex, planLimit, action, thought, log, output, durationMs, error } = data;
+    return {
+        phase: event.phase,
+        sequence: event.sequence,
+        prompt,
+        planIndex,
+        planLimit,
+        action,
+        thought,
+        log,
+        output,
+        durationMs,
+        error,
+        ...screenshots.length > 0 ? {
+            screenshots
+        } : {},
+        ...screenshotPath ? {
+            screenshotPath
+        } : {}
+    };
+}
+function buildAiActProgressEventLines(event) {
+    const phase = 'string' == typeof event.phase ? event.phase : '';
+    const prefix = planPrefix(event);
+    const error = compactText(event.error);
+    const duration = 'number' == typeof event.durationMs ? ` cost=${Math.round(event.durationMs)}ms` : '';
+    const action = parseAction(event.action);
+    switch(phase){
+        case 'start':
+            {
+                const prompt = compactText(event.prompt);
+                return [
+                    {
+                        key: `aiAct:start:${prompt}`,
+                        text: prompt ? `[Midscene][aiAct] Start: ${prompt}` : '[Midscene][aiAct] Start'
+                    }
+                ];
+            }
+        case 'plan_thinking':
+            return event.screenshotPath ? [
+                {
+                    key: eventKey(event, 'thinking'),
+                    text: `${prefix} Thinking with the latest screenshot: ${event.screenshotPath}`
+                }
+            ] : [
+                {
+                    key: eventKey(event, 'thinking'),
+                    text: `${prefix} Thinking with the latest screenshot`
+                }
+            ];
+        case 'plan_planned':
+            {
+                const text = firstText([
+                    event.log,
+                    event.thought,
+                    event.output
+                ]);
+                return text ? [
+                    {
+                        key: eventKey(event, 'planned'),
+                        text: `${prefix} Planned: ${text}`
+                    }
+                ] : [];
+            }
+        case 'plan_action':
+            return action ? [
+                {
+                    key: eventKey(event, 'action'),
+                    text: `${prefix} Action: ${plannedActionText(action)}`
+                }
+            ] : [];
+        case 'plan_failed':
+            return [
+                {
+                    key: eventKey(event, 'plan_failed'),
+                    text: `${prefix} Failed${error ? `: ${error}` : ''}`
+                }
+            ];
+        case 'action_running':
+            return action ? [
+                {
+                    key: eventKey(event, 'action_running'),
+                    text: `[Midscene][aiAct][Action] Running: ${runningActionText(action)}`
+                }
+            ] : [];
+        case 'action_done':
+            return action ? [
+                {
+                    key: eventKey(event, 'action_done'),
+                    text: `[Midscene][aiAct][Action] Done: ${action.name}${duration}`
+                }
+            ] : [];
+        case 'action_failed':
+            return [
+                {
+                    key: eventKey(event, 'action_failed'),
+                    text: `[Midscene][aiAct][Action] Failed${action ? `: ${action.name}` : ''}${duration}${error ? ` error=${error}` : ''}`
+                }
+            ];
+        case 'complete':
+            {
+                const text = firstText([
+                    event.output,
+                    event.log,
+                    event.thought
+                ]);
+                return [
+                    {
+                        key: eventKey(event, 'complete'),
+                        text: `[Midscene][aiAct] Complete${text ? `: ${text}` : ''}`
+                    }
+                ];
+            }
+        case 'failed':
+            return [
+                {
+                    key: eventKey(event, 'failed'),
+                    text: `[Midscene][aiAct] Failed${error ? `: ${error}` : ''}`
+                }
+            ];
+        default:
+            return [];
+    }
+}
+const aiActCliProgressRenderer = {
+    normalize: normalizeAiActProgressEventForCli,
+    buildLines: buildAiActProgressEventLines
+};
+exports.aiActCliProgressRenderer = __webpack_exports__.aiActCliProgressRenderer;
+exports.buildAiActProgressEventLines = __webpack_exports__.buildAiActProgressEventLines;
+exports.cliAiActProgressScope = __webpack_exports__.cliAiActProgressScope;
+exports.normalizeAiActProgressEventForCli = __webpack_exports__.normalizeAiActProgressEventForCli;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "aiActCliProgressRenderer",
+    "buildAiActProgressEventLines",
+    "cliAiActProgressScope",
+    "normalizeAiActProgressEventForCli"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/cli/verbose-screenshot.js

@@ -0,0 +1,177 @@
+"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 ('undefined' != 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__, {
+    collectScreenshotRefs: ()=>collectScreenshotRefs,
+    pathForReportScreenshot: ()=>pathForReportScreenshot,
+    latestScreenshotPathForAiAct: ()=>latestScreenshotPathForAiAct,
+    renderScreenshotList: ()=>renderScreenshotList
+});
+const external_node_path_namespaceObject = require("node:path");
+const external_screenshot_file_js_namespaceObject = require("./screenshot-file.js");
+function isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function isCliVerboseScreenshotRefLike(value) {
+    return isRecord(value) && 'midscene_screenshot_ref' === value.type;
+}
+function toSerializableScreenshot(value) {
+    if (!value || 'object' != typeof value) return null;
+    const maybeSerializable = value;
+    if ('function' == typeof maybeSerializable.toSerializable) try {
+        const serialized = maybeSerializable.toSerializable();
+        return isCliVerboseScreenshotRefLike(serialized) ? serialized : null;
+    } catch  {
+        return null;
+    }
+    return isCliVerboseScreenshotRefLike(value) ? value : null;
+}
+function getStringProperty(value, key) {
+    if (!isRecord(value)) return;
+    try {
+        const property = value[key];
+        return 'string' == typeof property && property.length > 0 ? property : void 0;
+    } catch  {
+        return;
+    }
+}
+function screenshotRawBase64(value) {
+    const rawBase64 = getStringProperty(value, 'rawBase64');
+    if (rawBase64) return rawBase64;
+    const base64 = getStringProperty(value, 'base64');
+    const match = base64?.match(/^data:image\/(?:png|jpeg|jpg);base64,(.+)$/);
+    return match?.[1];
+}
+function inlineScreenshotCacheKey(rawBase64, serialized, directoryPath, directoryName, extension) {
+    return JSON.stringify([
+        serialized.id,
+        serialized.mimeType,
+        directoryPath,
+        directoryName,
+        extension,
+        rawBase64
+    ]);
+}
+function exportInlineScreenshotForVerbose(value, serialized, options) {
+    if ('string' == typeof serialized.path) return serialized.path;
+    const exportMode = options.exportMode ?? 'tmp';
+    if ('none' === exportMode) return;
+    const rawBase64 = screenshotRawBase64(value);
+    if (!rawBase64) return;
+    const directoryPath = 'report' === exportMode && 'string' == typeof options.reportFile && options.reportFile.length > 0 ? (0, external_node_path_namespaceObject.join)((0, external_node_path_namespaceObject.dirname)(options.reportFile), 'screenshots') : void 0;
+    const directoryName = directoryPath ? void 0 : 'midscene-cli-screenshots';
+    const extension = getStringProperty(value, 'extension');
+    const cacheKey = inlineScreenshotCacheKey(rawBase64, serialized, directoryPath, directoryName, extension);
+    const cachedPath = options.cache?.get(cacheKey);
+    if (cachedPath) return cachedPath;
+    try {
+        const path = (0, external_screenshot_file_js_namespaceObject.writeCliScreenshotFile)(rawBase64, {
+            id: serialized.id,
+            mimeType: serialized.mimeType,
+            extension,
+            ...directoryPath ? {
+                directoryPath
+            } : {
+                directoryName
+            },
+            overwrite: false
+        });
+        options.cache?.set(cacheKey, path);
+        return path;
+    } catch  {
+        return;
+    }
+}
+function collectScreenshotRefs(value, options = {}) {
+    const screenshots = [];
+    const visit = (candidate, timing)=>{
+        if (Array.isArray(candidate)) {
+            for (const item of candidate)visit(item, timing);
+            return;
+        }
+        const serialized = toSerializableScreenshot(candidate);
+        if (serialized?.type === 'midscene_screenshot_ref') {
+            const screenshot = {
+                id: serialized.id,
+                storage: serialized.storage
+            };
+            const exportedPath = exportInlineScreenshotForVerbose(candidate, serialized, options);
+            if (exportedPath) {
+                screenshot.path = exportedPath;
+                screenshot.file = (0, external_node_path_namespaceObject.basename)(exportedPath);
+            }
+            if ('string' == typeof timing) screenshot.timing = timing;
+            screenshots.push(screenshot);
+            return;
+        }
+        if (!isRecord(candidate)) return;
+        const screenshotRecord = candidate.screenshot;
+        if (screenshotRecord) visit(screenshotRecord, candidate.timing);
+        if (candidate.recorder) visit(candidate.recorder);
+        if (isRecord(candidate.uiContext)) visit(candidate.uiContext.screenshot);
+    };
+    visit(value);
+    return screenshots;
+}
+function pathForReportScreenshot(path, reportFile) {
+    const resolvedPath = 'string' == typeof reportFile && reportFile.length > 0 && (path.startsWith('./') || path.startsWith('../')) ? (0, external_node_path_namespaceObject.join)((0, external_node_path_namespaceObject.dirname)(reportFile), path) : path;
+    if (!(0, external_node_path_namespaceObject.isAbsolute)(resolvedPath)) return resolvedPath;
+    const relativePath = (0, external_node_path_namespaceObject.relative)(process.cwd(), resolvedPath);
+    if (relativePath && !relativePath.startsWith('..') && !(0, external_node_path_namespaceObject.isAbsolute)(relativePath)) return relativePath;
+    return resolvedPath;
+}
+function latestScreenshotPathForAiAct(value, options = {}) {
+    const screenshot = collectScreenshotRefs(value, {
+        ...options,
+        exportMode: options.exportMode ?? 'report'
+    }).slice().reverse().find((item)=>'string' == typeof item.path && item.path.length > 0);
+    const path = 'string' == typeof screenshot?.path ? screenshot.path : '';
+    return path ? pathForReportScreenshot(path, options.reportFile) : '';
+}
+function renderScreenshotList(screenshots) {
+    if (!Array.isArray(screenshots) || 0 === screenshots.length) return '';
+    return screenshots.map((item)=>{
+        if (!isRecord(item)) return '';
+        const path = 'string' == typeof item.path ? item.path : 'string' == typeof item.file ? item.file : 'string' == typeof item.id ? item.id : '';
+        const timing = 'string' == typeof item.timing ? item.timing : '';
+        return [
+            timing,
+            path
+        ].filter(Boolean).join(' ');
+    }).filter(Boolean).join(', ');
+}
+exports.collectScreenshotRefs = __webpack_exports__.collectScreenshotRefs;
+exports.latestScreenshotPathForAiAct = __webpack_exports__.latestScreenshotPathForAiAct;
+exports.pathForReportScreenshot = __webpack_exports__.pathForReportScreenshot;
+exports.renderScreenshotList = __webpack_exports__.renderScreenshotList;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "collectScreenshotRefs",
+    "latestScreenshotPathForAiAct",
+    "pathForReportScreenshot",
+    "renderScreenshotList"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});