@godscene/core 1.7.11

package/dist/lib/dump/html-utils.js

@@ -0,0 +1,366 @@
+"use strict";
+var __webpack_modules__ = {
+    "node:fs" (module) {
+        module.exports = require("node:fs");
+    }
+};
+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__.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__, {
+        generateImageScriptTag: ()=>generateImageScriptTag,
+        getBaseUrlFixScript: ()=>getBaseUrlFixScript,
+        parseDumpScriptAttributes: ()=>parseDumpScriptAttributes,
+        extractImageByIdSync: ()=>extractImageByIdSync,
+        streamDumpScriptsSync: ()=>streamDumpScriptsSync,
+        escapeContent: ()=>escapeContent,
+        generateDumpScriptTag: ()=>generateDumpScriptTag,
+        STREAMING_CHUNK_SIZE: ()=>STREAMING_CHUNK_SIZE,
+        extractLastDumpScriptSync: ()=>extractLastDumpScriptSync,
+        parseDumpScript: ()=>parseDumpScript,
+        streamImageScriptsToFile: ()=>streamImageScriptsToFile,
+        streamScanTags: ()=>streamScanTags,
+        parseImageScripts: ()=>parseImageScripts,
+        extractAllDumpScriptsSync: ()=>extractAllDumpScriptsSync,
+        unescapeContent: ()=>unescapeContent
+    });
+    var external_node_fs_ = __webpack_require__("node:fs");
+    const utils_namespaceObject = require("@godscene/shared/utils");
+    const escapeContent = utils_namespaceObject.escapeScriptTag;
+    const unescapeContent = utils_namespaceObject.antiEscapeScriptTag;
+    const STREAMING_CHUNK_SIZE = 65536;
+    function streamScanTags(filePath, openTag, closeTag, onMatch) {
+        const fd = (0, external_node_fs_.openSync)(filePath, 'r');
+        const fileSize = (0, external_node_fs_.statSync)(filePath).size;
+        const buffer = Buffer.alloc(STREAMING_CHUNK_SIZE);
+        let position = 0;
+        let leftover = '';
+        let capturing = false;
+        let currentContent = '';
+        try {
+            while(position < fileSize){
+                const bytesRead = (0, external_node_fs_.readSync)(fd, buffer, 0, STREAMING_CHUNK_SIZE, position);
+                const chunk = leftover + buffer.toString('utf-8', 0, bytesRead);
+                position += bytesRead;
+                let searchStart = 0;
+                while(searchStart < chunk.length)if (capturing) {
+                    const endIdx = chunk.indexOf(closeTag, searchStart);
+                    if (-1 !== endIdx) {
+                        currentContent += chunk.slice(searchStart, endIdx);
+                        const shouldStop = onMatch(currentContent);
+                        if (shouldStop) return;
+                        capturing = false;
+                        currentContent = '';
+                        searchStart = endIdx + closeTag.length;
+                    } else {
+                        currentContent += chunk.slice(searchStart, -closeTag.length);
+                        leftover = chunk.slice(-closeTag.length);
+                        break;
+                    }
+                } else {
+                    const startIdx = chunk.indexOf(openTag, searchStart);
+                    if (-1 !== startIdx) {
+                        capturing = true;
+                        currentContent = chunk.slice(startIdx + openTag.length);
+                        const endIdx = currentContent.indexOf(closeTag);
+                        if (-1 !== endIdx) {
+                            const shouldStop = onMatch(currentContent.slice(0, endIdx));
+                            if (shouldStop) return;
+                            capturing = false;
+                            currentContent = '';
+                            searchStart = startIdx + openTag.length + endIdx + closeTag.length;
+                        } else {
+                            leftover = currentContent.slice(-closeTag.length);
+                            currentContent = currentContent.slice(0, -closeTag.length);
+                            break;
+                        }
+                    } else {
+                        leftover = chunk.slice(-openTag.length);
+                        break;
+                    }
+                }
+            }
+        } finally{
+            (0, external_node_fs_.closeSync)(fd);
+        }
+    }
+    function extractImageByIdSync(htmlPath, imageId) {
+        const targetTag = `<script type="midscene-image" data-id="${imageId}">`;
+        const closeTag = "<\/script>";
+        let result = null;
+        streamScanTags(htmlPath, targetTag, closeTag, (content)=>{
+            result = unescapeContent(content);
+            return true;
+        });
+        return result;
+    }
+    function streamImageScriptsToFile(srcFilePath, destFilePath) {
+        const { appendFileSync } = __webpack_require__("node:fs");
+        const openTag = '<script type="midscene-image"';
+        const closeTag = "<\/script>";
+        streamScanTags(srcFilePath, openTag, closeTag, (content)=>{
+            appendFileSync(destFilePath, `${openTag}${content}${closeTag}\n`);
+            return false;
+        });
+    }
+    function extractLastDumpScriptSync(filePath) {
+        const openTagPrefix = '<script type="midscene_web_dump"';
+        const closeTag = "<\/script>";
+        let lastContent = '';
+        const fd = (0, external_node_fs_.openSync)(filePath, 'r');
+        const fileSize = (0, external_node_fs_.statSync)(filePath).size;
+        const buffer = Buffer.alloc(STREAMING_CHUNK_SIZE);
+        let position = 0;
+        let leftover = '';
+        let capturing = false;
+        let currentContent = '';
+        try {
+            while(position < fileSize){
+                const bytesRead = (0, external_node_fs_.readSync)(fd, buffer, 0, STREAMING_CHUNK_SIZE, position);
+                const chunk = leftover + buffer.toString('utf-8', 0, bytesRead);
+                position += bytesRead;
+                let searchStart = 0;
+                while(searchStart < chunk.length)if (capturing) {
+                    const endIdx = chunk.indexOf(closeTag, searchStart);
+                    if (-1 !== endIdx) {
+                        currentContent += chunk.slice(searchStart, endIdx);
+                        lastContent = currentContent.trim();
+                        capturing = false;
+                        currentContent = '';
+                        searchStart = endIdx + closeTag.length;
+                    } else {
+                        currentContent += chunk.slice(searchStart, -closeTag.length);
+                        leftover = chunk.slice(-closeTag.length);
+                        break;
+                    }
+                } else {
+                    const startIdx = chunk.indexOf(openTagPrefix, searchStart);
+                    if (-1 !== startIdx) {
+                        const tagEndIdx = chunk.indexOf('>', startIdx);
+                        if (-1 !== tagEndIdx) {
+                            capturing = true;
+                            currentContent = chunk.slice(tagEndIdx + 1);
+                            const endIdx = currentContent.indexOf(closeTag);
+                            if (-1 !== endIdx) {
+                                lastContent = currentContent.slice(0, endIdx).trim();
+                                capturing = false;
+                                currentContent = '';
+                                searchStart = tagEndIdx + 1 + endIdx + closeTag.length;
+                            } else {
+                                leftover = currentContent.slice(-closeTag.length);
+                                currentContent = currentContent.slice(0, -closeTag.length);
+                                break;
+                            }
+                        } else {
+                            leftover = chunk.slice(startIdx);
+                            break;
+                        }
+                    } else {
+                        leftover = chunk.slice(-openTagPrefix.length);
+                        break;
+                    }
+                }
+            }
+        } finally{
+            (0, external_node_fs_.closeSync)(fd);
+        }
+        return lastContent;
+    }
+    function extractAllDumpScriptsSync(filePath) {
+        const results = [];
+        streamDumpScriptsSync(filePath, (dumpScript)=>{
+            results.push(dumpScript);
+            return false;
+        });
+        return results;
+    }
+    function streamDumpScriptsSync(filePath, onMatch) {
+        const openTagPrefix = '<script type="midscene_web_dump"';
+        const closeTag = "<\/script>";
+        const fd = (0, external_node_fs_.openSync)(filePath, 'r');
+        const fileSize = (0, external_node_fs_.statSync)(filePath).size;
+        const buffer = Buffer.alloc(STREAMING_CHUNK_SIZE);
+        let position = 0;
+        let leftover = '';
+        let capturing = false;
+        let currentContent = '';
+        let currentOpenTag = '';
+        try {
+            while(position < fileSize){
+                const bytesRead = (0, external_node_fs_.readSync)(fd, buffer, 0, STREAMING_CHUNK_SIZE, position);
+                const chunk = leftover + buffer.toString('utf-8', 0, bytesRead);
+                position += bytesRead;
+                let searchStart = 0;
+                while(searchStart < chunk.length)if (capturing) {
+                    const endIdx = chunk.indexOf(closeTag, searchStart);
+                    if (-1 !== endIdx) {
+                        currentContent += chunk.slice(searchStart, endIdx);
+                        const shouldStop = onMatch({
+                            openTag: currentOpenTag,
+                            content: currentContent.trim()
+                        });
+                        if (shouldStop) return;
+                        capturing = false;
+                        currentContent = '';
+                        currentOpenTag = '';
+                        searchStart = endIdx + closeTag.length;
+                    } else {
+                        currentContent += chunk.slice(searchStart, -closeTag.length);
+                        leftover = chunk.slice(-closeTag.length);
+                        break;
+                    }
+                } else {
+                    const startIdx = chunk.indexOf(openTagPrefix, searchStart);
+                    if (-1 !== startIdx) {
+                        const tagEndIdx = chunk.indexOf('>', startIdx);
+                        if (-1 !== tagEndIdx) {
+                            capturing = true;
+                            currentOpenTag = chunk.slice(startIdx, tagEndIdx + 1);
+                            currentContent = chunk.slice(tagEndIdx + 1);
+                            const endIdx = currentContent.indexOf(closeTag);
+                            if (-1 !== endIdx) {
+                                const shouldStop = onMatch({
+                                    openTag: currentOpenTag,
+                                    content: currentContent.slice(0, endIdx).trim()
+                                });
+                                if (shouldStop) return;
+                                capturing = false;
+                                currentContent = '';
+                                currentOpenTag = '';
+                                searchStart = tagEndIdx + 1 + endIdx + closeTag.length;
+                            } else {
+                                leftover = currentContent.slice(-closeTag.length);
+                                currentContent = currentContent.slice(0, -closeTag.length);
+                                break;
+                            }
+                        } else {
+                            leftover = chunk.slice(startIdx);
+                            break;
+                        }
+                    } else {
+                        leftover = chunk.slice(-openTagPrefix.length);
+                        break;
+                    }
+                }
+            }
+        } finally{
+            (0, external_node_fs_.closeSync)(fd);
+        }
+    }
+    function parseImageScripts(html) {
+        const imageMap = {};
+        const regex = /<script type="midscene-image" data-id="([^"]+)">([\s\S]*?)<\/script>/g;
+        for (const match of html.matchAll(regex)){
+            const [, id, content] = match;
+            imageMap[id] = unescapeContent(content);
+        }
+        return imageMap;
+    }
+    function parseDumpScript(html) {
+        const scriptOpenTag = '<script type="midscene_web_dump"';
+        const scriptCloseTag = "<\/script>";
+        const lastOpenIndex = html.lastIndexOf(scriptOpenTag);
+        if (-1 === lastOpenIndex) throw new Error("No dump script found in HTML");
+        const tagEndIndex = html.indexOf('>', lastOpenIndex);
+        if (-1 === tagEndIndex) throw new Error("No dump script found in HTML");
+        const closeIndex = html.indexOf(scriptCloseTag, tagEndIndex);
+        if (-1 === closeIndex) throw new Error("No dump script found in HTML");
+        const content = html.substring(tagEndIndex + 1, closeIndex);
+        return unescapeContent(content);
+    }
+    function parseDumpScriptAttributes(html) {
+        const regex = /<script type="midscene_web_dump"([^>]*)>/;
+        const match = regex.exec(html);
+        if (!match) return {};
+        const attrString = match[1];
+        const attributes = {};
+        const attrRegex = /(\w+)="([^"]*)"/g;
+        for (const attrMatch of attrString.matchAll(attrRegex)){
+            const [, key, value] = attrMatch;
+            if ('type' !== key) attributes[key] = decodeURIComponent(value);
+        }
+        return attributes;
+    }
+    function generateImageScriptTag(id, data) {
+        return '<script type="midscene-image" data-id="' + id + '">' + escapeContent(data) + "<\/script>";
+    }
+    let _baseUrlFixScript;
+    function getBaseUrlFixScript() {
+        if (!_baseUrlFixScript) {
+            const close = "<\/script>";
+            _baseUrlFixScript = '\n<script>(function(){var p=window.location.pathname;if(p.endsWith("/")||/\\.\\w+$/.test(p))return;var b=document.createElement("base");b.href=p+"/";document.head.insertBefore(b,document.head.firstChild)})()' + close + '\n';
+        }
+        return _baseUrlFixScript;
+    }
+    function generateDumpScriptTag(json, attributes) {
+        let attrString = '';
+        if (attributes && Object.keys(attributes).length > 0) attrString = ' ' + Object.entries(attributes).map(([k, v])=>k + '="' + encodeURIComponent(v) + '"').join(' ');
+        return '<script type="midscene_web_dump"' + attrString + '>' + escapeContent(json) + "<\/script>";
+    }
+})();
+exports.STREAMING_CHUNK_SIZE = __webpack_exports__.STREAMING_CHUNK_SIZE;
+exports.escapeContent = __webpack_exports__.escapeContent;
+exports.extractAllDumpScriptsSync = __webpack_exports__.extractAllDumpScriptsSync;
+exports.extractImageByIdSync = __webpack_exports__.extractImageByIdSync;
+exports.extractLastDumpScriptSync = __webpack_exports__.extractLastDumpScriptSync;
+exports.generateDumpScriptTag = __webpack_exports__.generateDumpScriptTag;
+exports.generateImageScriptTag = __webpack_exports__.generateImageScriptTag;
+exports.getBaseUrlFixScript = __webpack_exports__.getBaseUrlFixScript;
+exports.parseDumpScript = __webpack_exports__.parseDumpScript;
+exports.parseDumpScriptAttributes = __webpack_exports__.parseDumpScriptAttributes;
+exports.parseImageScripts = __webpack_exports__.parseImageScripts;
+exports.streamDumpScriptsSync = __webpack_exports__.streamDumpScriptsSync;
+exports.streamImageScriptsToFile = __webpack_exports__.streamImageScriptsToFile;
+exports.streamScanTags = __webpack_exports__.streamScanTags;
+exports.unescapeContent = __webpack_exports__.unescapeContent;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "STREAMING_CHUNK_SIZE",
+    "escapeContent",
+    "extractAllDumpScriptsSync",
+    "extractImageByIdSync",
+    "extractLastDumpScriptSync",
+    "generateDumpScriptTag",
+    "generateImageScriptTag",
+    "getBaseUrlFixScript",
+    "parseDumpScript",
+    "parseDumpScriptAttributes",
+    "parseImageScripts",
+    "streamDumpScriptsSync",
+    "streamImageScriptsToFile",
+    "streamScanTags",
+    "unescapeContent"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/dump/index.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 ("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__, {
+    parseDumpScript: ()=>external_html_utils_js_namespaceObject.parseDumpScript,
+    restoreImageReferences: ()=>external_screenshot_restoration_js_namespaceObject.restoreImageReferences,
+    generateImageScriptTag: ()=>external_html_utils_js_namespaceObject.generateImageScriptTag,
+    parseImageScripts: ()=>external_html_utils_js_namespaceObject.parseImageScripts,
+    parseDumpScriptAttributes: ()=>external_html_utils_js_namespaceObject.parseDumpScriptAttributes,
+    unescapeContent: ()=>external_html_utils_js_namespaceObject.unescapeContent,
+    escapeContent: ()=>external_html_utils_js_namespaceObject.escapeContent,
+    generateDumpScriptTag: ()=>external_html_utils_js_namespaceObject.generateDumpScriptTag
+});
+const external_screenshot_restoration_js_namespaceObject = require("./screenshot-restoration.js");
+const external_html_utils_js_namespaceObject = require("./html-utils.js");
+exports.escapeContent = __webpack_exports__.escapeContent;
+exports.generateDumpScriptTag = __webpack_exports__.generateDumpScriptTag;
+exports.generateImageScriptTag = __webpack_exports__.generateImageScriptTag;
+exports.parseDumpScript = __webpack_exports__.parseDumpScript;
+exports.parseDumpScriptAttributes = __webpack_exports__.parseDumpScriptAttributes;
+exports.parseImageScripts = __webpack_exports__.parseImageScripts;
+exports.restoreImageReferences = __webpack_exports__.restoreImageReferences;
+exports.unescapeContent = __webpack_exports__.unescapeContent;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "escapeContent",
+    "generateDumpScriptTag",
+    "generateImageScriptTag",
+    "parseDumpScript",
+    "parseDumpScriptAttributes",
+    "parseImageScripts",
+    "restoreImageReferences",
+    "unescapeContent"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/dump/screenshot-restoration.js

@@ -0,0 +1,64 @@
+"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__, {
+    restoreImageReferences: ()=>restoreImageReferences
+});
+const external_screenshot_store_js_namespaceObject = require("./screenshot-store.js");
+function restoreImageReferences(data, resolveImage) {
+    if ('string' == typeof data) return data;
+    if (Array.isArray(data)) return data.map((item)=>restoreImageReferences(item, resolveImage));
+    if ('object' == typeof data && null !== data) {
+        const refLike = (0, external_screenshot_store_js_namespaceObject.normalizeScreenshotRef)(data);
+        if (refLike) {
+            let resolved = null;
+            const lazy = Object.defineProperties({}, {
+                base64: {
+                    get () {
+                        if (null === resolved) resolved = resolveImage(refLike);
+                        return resolved;
+                    },
+                    enumerable: true
+                },
+                capturedAt: {
+                    value: refLike.capturedAt,
+                    enumerable: true
+                }
+            });
+            return lazy;
+        }
+        const result = {};
+        for (const [key, value] of Object.entries(data))result[key] = restoreImageReferences(value, resolveImage);
+        return result;
+    }
+    return data;
+}
+exports.restoreImageReferences = __webpack_exports__.restoreImageReferences;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "restoreImageReferences"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/dump/screenshot-store.js

@@ -0,0 +1,165 @@
+"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__, {
+    normalizeScreenshotRef: ()=>normalizeScreenshotRef,
+    ScreenshotStore: ()=>ScreenshotStore,
+    resolveScreenshotSource: ()=>resolveScreenshotSource
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const promises_namespaceObject = require("node:fs/promises");
+const external_node_path_namespaceObject = require("node:path");
+const external_html_utils_js_namespaceObject = require("./html-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 normalizeScreenshotRef(value) {
+    if ('object' != typeof value || null === value) return null;
+    const record = value;
+    if ('midscene_screenshot_ref' === record.type && 'string' == typeof record.id && 'number' == typeof record.capturedAt && ('inline' === record.storage || 'file' === record.storage) && ('image/png' === record.mimeType || 'image/jpeg' === record.mimeType)) {
+        if ('file' === record.storage && 'string' != typeof record.path) return null;
+        return record;
+    }
+    return null;
+}
+function extensionByMimeType(mimeType) {
+    return 'image/jpeg' === mimeType ? 'jpeg' : 'png';
+}
+function resolveScreenshotSource(refInput, options) {
+    const ref = normalizeScreenshotRef(refInput);
+    const id = ref?.id ?? options.fallbackId;
+    const mimeType = ref?.mimeType ?? options.fallbackMimeType;
+    if (!id || !mimeType) throw new Error('ScreenshotStore: screenshot id and mimeType are required to resolve screenshot');
+    const resolveReportRelativePath = (filePath)=>(0, external_node_path_namespaceObject.isAbsolute)(filePath) ? filePath : (0, external_node_path_namespaceObject.join)((0, external_node_path_namespaceObject.dirname)(options.reportPath), filePath);
+    if (ref?.storage === 'file') {
+        if (!ref.path) throw new Error(`ScreenshotStore: screenshot ref "${ref.id}" missing file path`);
+        const explicitFilePath = resolveReportRelativePath(ref.path);
+        if ((0, external_node_fs_namespaceObject.existsSync)(explicitFilePath)) return {
+            type: 'file',
+            id,
+            mimeType,
+            filePath: explicitFilePath
+        };
+    }
+    const inlineDataUri = (0, external_html_utils_js_namespaceObject.extractImageByIdSync)(options.reportPath, id);
+    if (inlineDataUri) return {
+        type: 'data-uri',
+        id,
+        mimeType,
+        dataUri: inlineDataUri
+    };
+    const siblingScreenshotPath = (0, external_node_path_namespaceObject.join)((0, external_node_path_namespaceObject.dirname)(options.reportPath), 'screenshots', `${id}.${extensionByMimeType(mimeType)}`);
+    if ((0, external_node_fs_namespaceObject.existsSync)(siblingScreenshotPath)) return {
+        type: 'file',
+        id,
+        mimeType,
+        filePath: siblingScreenshotPath
+    };
+    throw new Error(`ScreenshotStore: cannot resolve screenshot "${id}" from ${options.reportPath}`);
+}
+class ScreenshotStore {
+    async persist(screenshot) {
+        const shouldWriteFileCopy = 'directory' === this.mode || this.alsoWriteFileCopy;
+        const fileRef = shouldWriteFileCopy ? await this.persistToSharedFileIfNeeded(screenshot, {
+            markAsPersisted: 'directory' === this.mode
+        }) : null;
+        if ('inline' === this.mode) {
+            if (!this.writeInlineImage) throw new Error('ScreenshotStore: writeInlineImage is required in inline mode');
+            if (!this.writtenInlineIds.has(screenshot.id)) {
+                await this.writeInlineImage(screenshot.id, screenshot.base64);
+                this.writtenInlineIds.add(screenshot.id);
+            }
+            return screenshot.markPersistedInline(this.reportPath);
+        }
+        if (!fileRef) throw new Error('ScreenshotStore: file persistence is required in directory mode');
+        return fileRef;
+    }
+    async persistToSharedFileIfNeeded(screenshot, options) {
+        const screenshotsDir = this.screenshotsDir;
+        if (!screenshotsDir) throw new Error('ScreenshotStore: screenshotsDir is required when file persistence is enabled');
+        if (!(0, external_node_fs_namespaceObject.existsSync)(screenshotsDir)) (0, external_node_fs_namespaceObject.mkdirSync)(screenshotsDir, {
+            recursive: true
+        });
+        const relativePath = `./screenshots/${screenshot.id}.${screenshot.extension}`;
+        const absolutePath = (0, external_node_path_namespaceObject.join)(screenshotsDir, `${screenshot.id}.${screenshot.extension}`);
+        if (!this.writtenFileIds.has(screenshot.id)) {
+            const buffer = Buffer.from(screenshot.rawBase64, 'base64');
+            await (0, promises_namespaceObject.writeFile)(absolutePath, buffer);
+            this.writtenFileIds.add(screenshot.id);
+        }
+        if (options.markAsPersisted) return screenshot.markPersistedToPath(relativePath, absolutePath);
+        return screenshot.registerPersistedFileCopy(relativePath, absolutePath);
+    }
+    loadBase64(refInput) {
+        const ref = normalizeScreenshotRef(refInput);
+        if (!ref) throw new Error('ScreenshotStore: invalid screenshot reference');
+        const resolved = resolveScreenshotSource(ref, {
+            reportPath: this.reportPath
+        });
+        if ('data-uri' === resolved.type) return resolved.dataUri;
+        const data = (0, external_node_fs_namespaceObject.readFileSync)(resolved.filePath);
+        return `data:${resolved.mimeType};base64,${data.toString('base64')}`;
+    }
+    cleanup() {
+        if ('directory' === this.mode && this.screenshotsDir && (0, external_node_fs_namespaceObject.existsSync)(this.screenshotsDir)) (0, external_node_fs_namespaceObject.rmSync)(this.screenshotsDir, {
+            recursive: true,
+            force: true
+        });
+        this.writtenInlineIds.clear();
+        this.writtenFileIds.clear();
+    }
+    constructor(options){
+        _define_property(this, "mode", void 0);
+        _define_property(this, "reportPath", void 0);
+        _define_property(this, "screenshotsDir", void 0);
+        _define_property(this, "writeInlineImage", void 0);
+        _define_property(this, "alsoWriteFileCopy", void 0);
+        _define_property(this, "writtenInlineIds", new Set());
+        _define_property(this, "writtenFileIds", new Set());
+        this.mode = options.mode;
+        this.reportPath = options.reportPath;
+        this.screenshotsDir = options.screenshotsDir;
+        this.writeInlineImage = options.writeInlineImage;
+        this.alsoWriteFileCopy = options.alsoWriteFileCopy ?? options.ensureFileCopy ?? false;
+    }
+}
+exports.ScreenshotStore = __webpack_exports__.ScreenshotStore;
+exports.normalizeScreenshotRef = __webpack_exports__.normalizeScreenshotRef;
+exports.resolveScreenshotSource = __webpack_exports__.resolveScreenshotSource;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ScreenshotStore",
+    "normalizeScreenshotRef",
+    "resolveScreenshotSource"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});