opendevbrowser 0.0.15 → 0.0.17

package/extension/dist/ops/ops-runtime.js

@@ -5,24 +5,59 @@ import { logError } from "../logging.js";
 import { DomBridge } from "./dom-bridge.js";
 import { buildSnapshot } from "./snapshot-builder.js";
 import { OpsSessionStore } from "./ops-session-store.js";
+import { DEFAULT_OPS_PARALLELISM_POLICY, evaluateOpsGovernor } from "./parallelism-governor.js";
 import { redactConsoleText, redactUrl } from "./redaction.js";
 const MAX_CONSOLE_EVENTS = 200;
 const MAX_NETWORK_EVENTS = 300;
 const SESSION_TTL_MS = 20_000;
 const SCREENSHOT_TIMEOUT_MS = 8000;
 const TAB_CLOSE_TIMEOUT_MS = 5000;
+const TARGET_SCOPED_COMMANDS = new Set([
+    "storage.setCookies",
+    "storage.getCookies",
+    "nav.goto",
+    "nav.wait",
+    "nav.snapshot",
+    "interact.click",
+    "interact.hover",
+    "interact.press",
+    "interact.check",
+    "interact.uncheck",
+    "interact.type",
+    "interact.select",
+    "interact.scroll",
+    "interact.scrollIntoView",
+    "dom.getHtml",
+    "dom.getText",
+    "dom.getAttr",
+    "dom.getValue",
+    "dom.isVisible",
+    "dom.isEnabled",
+    "dom.isChecked",
+    "canvas.applyRuntimePreviewBridge",
+    "export.clonePage",
+    "export.cloneComponent",
+    "devtools.perf",
+    "page.screenshot"
+]);
 export class OpsRuntime {
     sendEnvelope;
     cdp;
+    getCanvasPageState;
+    performCanvasPageAction;
     tabs = new TabManager();
     dom = new DomBridge();
     sessions = new OpsSessionStore();
     encoder = new TextEncoder();
     closingTimers = new Map();
+    parallelWaiters = new Map();
     constructor(options) {
         this.sendEnvelope = options.send;
         this.cdp = options.cdp;
+        this.getCanvasPageState = options.getCanvasPageState;
+        this.performCanvasPageAction = options.performCanvasPageAction;
         chrome.tabs.onRemoved.addListener(this.handleTabRemoved);
+        chrome.tabs.onUpdated.addListener(this.handleTabUpdated);
         chrome.debugger.onEvent.addListener(this.handleDebuggerEvent);
         chrome.debugger.onDetach.addListener(this.handleDebuggerDetach);
     }
@@ -95,6 +130,19 @@ export class OpsRuntime {
     handleTabRemoved = (tabId) => {
         this.handleClosedTarget(tabId, "ops_tab_closed");
     };
+    handleTabUpdated = (tabId, changeInfo, tab) => {
+        const session = this.sessions.getByTabId(tabId);
+        if (!session)
+            return;
+        if (changeInfo.discarded === true || tab.discarded === true) {
+            session.discardedSignals += 1;
+        }
+        const frozenChange = changeInfo.frozen === true;
+        const frozenTab = tab.frozen === true;
+        if (frozenChange || frozenTab) {
+            session.frozenSignals += 1;
+        }
+    };
     handleDebuggerDetach = (source) => {
         if (typeof source.tabId !== "number")
             return;
@@ -197,12 +245,21 @@ export class OpsRuntime {
             case "session.status":
                 await this.handleSessionStatus(message, clientId);
                 return;
+            case "storage.setCookies":
+                await this.withSession(message, clientId, (session) => this.handleStorageSetCookies(message, session));
+                return;
+            case "storage.getCookies":
+                await this.withSession(message, clientId, (session) => this.handleStorageGetCookies(message, session));
+                return;
             case "targets.list":
                 await this.withSession(message, clientId, (session) => this.handleTargetsList(message, session));
                 return;
             case "targets.use":
                 await this.withSession(message, clientId, (session) => this.handleTargetsUse(message, session));
                 return;
+            case "targets.registerCanvas":
+                await this.withSession(message, clientId, (session) => this.handleTargetsRegisterCanvas(message, session));
+                return;
             case "targets.new":
                 await this.withSession(message, clientId, (session) => this.handleTargetsNew(message, session));
                 return;
@@ -275,6 +332,9 @@ export class OpsRuntime {
             case "dom.isChecked":
                 await this.withSession(message, clientId, (session) => this.handleDomIsChecked(message, session));
                 return;
+            case "canvas.applyRuntimePreviewBridge":
+                await this.withSession(message, clientId, (session) => this.handleCanvasRuntimePreviewBridge(message, session));
+                return;
             case "export.clonePage":
                 await this.withSession(message, clientId, (session) => this.handleClonePage(message, session));
                 return;
@@ -299,6 +359,7 @@ export class OpsRuntime {
     }
     async handleSessionLaunch(message, clientId) {
         const payload = isRecord(message.payload) ? message.payload : {};
+        const parallelismPolicy = parseParallelismPolicy(payload.parallelismPolicy);
         const startUrl = typeof payload.startUrl === "string" ? payload.startUrl : undefined;
         if (startUrl) {
             try {
@@ -320,28 +381,38 @@ export class OpsRuntime {
             this.sendError(message, buildError("ops_unavailable", "No active tab to attach.", true));
             return;
         }
-        if (activeTab.url) {
-            const restriction = isRestrictedUrl(activeTab.url);
+        const activeTabId = activeTab.id;
+        const resolvedTab = startUrl
+            ? await this.tabs.waitForTabComplete(activeTabId)
+                .catch(() => undefined)
+                .then(async () => await this.tabs.getTab(activeTabId) ?? activeTab)
+            : activeTab;
+        if (resolvedTab.url) {
+            const restriction = isRestrictedUrl(resolvedTab.url);
             if (restriction.restricted) {
                 this.sendError(message, buildError("restricted_url", restriction.message ?? "Restricted tab.", false));
                 return;
             }
         }
         try {
-            await this.cdp.attach(activeTab.id);
+            await this.cdp.attach(activeTabId);
         }
         catch (error) {
             const detail = error instanceof Error ? error.message : "Debugger attach failed";
             this.sendError(message, buildError("cdp_attach_failed", detail, false));
             return;
         }
-        await this.tabs.waitForTabComplete(activeTab.id).catch(() => undefined);
+        if (!startUrl) {
+            await this.tabs.waitForTabComplete(activeTab.id).catch(() => undefined);
+        }
         const leaseId = typeof message.leaseId === "string" && message.leaseId.trim().length > 0
             ? message.leaseId.trim()
             : createId();
-        const session = this.sessions.createSession(clientId, activeTab.id, leaseId, {
-            url: activeTab.url ?? undefined,
-            title: activeTab.title ?? undefined
+        const session = this.sessions.createSession(clientId, activeTabId, leaseId, {
+            url: resolvedTab.url ?? undefined,
+            title: resolvedTab.title ?? undefined
+        }, {
+            parallelismPolicy
         });
         await this.enableSessionDomains(session);
         this.sendEvent({
@@ -354,8 +425,8 @@ export class OpsRuntime {
         this.sendResponse(message, {
             opsSessionId: session.id,
             activeTargetId: session.activeTargetId,
-            url: activeTab.url ?? undefined,
-            title: activeTab.title ?? undefined,
+            url: resolvedTab.url ?? undefined,
+            title: resolvedTab.title ?? undefined,
             leaseId: session.leaseId
         });
     }
@@ -385,11 +456,12 @@ export class OpsRuntime {
         const includeUrls = payload.includeUrls === true;
         const targets = await Promise.all(Array.from(session.targets.values()).map(async (target) => {
             const tab = await this.tabs.getTab(target.tabId);
+            const synthetic = session.syntheticTargets.get(target.targetId);
             return {
                 targetId: target.targetId,
                 type: "page",
-                title: tab?.title ?? target.title,
-                url: includeUrls ? tab?.url ?? target.url : undefined
+                title: resolveReportedTargetTitle(target, tab?.title, synthetic),
+                url: includeUrls ? resolveReportedTargetUrl(target, tab?.url, synthetic) : undefined
             };
         }));
         this.sendResponse(message, { activeTargetId: session.activeTargetId || null, targets });
@@ -407,10 +479,66 @@ export class OpsRuntime {
             await this.tabs.activateTab(target.tabId).catch(() => undefined);
         }
         const tab = target ? await this.tabs.getTab(target.tabId) : null;
+        const synthetic = target ? session.syntheticTargets.get(target.targetId) : undefined;
         this.sendResponse(message, {
             activeTargetId: targetId,
-            url: tab?.url ?? target?.url,
-            title: tab?.title ?? target?.title
+            url: target ? resolveReportedTargetUrl(target, tab?.url, synthetic) : undefined,
+            title: target ? resolveReportedTargetTitle(target, tab?.title, synthetic) : undefined
+        });
+    }
+    async handleTargetsRegisterCanvas(message, session) {
+        const payload = isRecord(message.payload) ? message.payload : {};
+        const targetId = typeof payload.targetId === "string" ? payload.targetId.trim() : "";
+        if (!targetId) {
+            this.sendError(message, buildError("invalid_request", "Missing targetId", false));
+            return;
+        }
+        const tabId = parseTabTargetId(targetId);
+        if (tabId === null) {
+            this.sendError(message, buildError("invalid_request", "Canvas targetId must be tab-<id>.", false));
+            return;
+        }
+        let tab = await this.tabs.getTab(tabId);
+        if (!tab) {
+            this.sendError(message, buildError("invalid_request", "Unknown targetId", false));
+            return;
+        }
+        await this.tabs.waitForTabComplete(tabId, 5000).catch(() => undefined);
+        tab = await this.tabs.getTab(tabId) ?? tab;
+        if (!this.isAllowedCanvasTargetUrl(tab.url)) {
+            this.sendError(message, buildError("restricted_url", "Only the extension canvas tab can be registered.", false));
+            return;
+        }
+        const existing = session.targets.get(targetId);
+        if (existing) {
+            existing.url = tab.url ?? existing.url;
+            existing.title = tab.title ?? existing.title;
+            session.activeTargetId = targetId;
+            this.sendResponse(message, {
+                targetId,
+                url: existing.url,
+                title: existing.title,
+                adopted: false
+            });
+            return;
+        }
+        try {
+            await this.cdp.attach(tabId);
+            await this.enableTargetDomains(tabId);
+        }
+        catch (error) {
+            logError("ops.register_canvas_target", error, {
+                code: "canvas_target_attach_failed",
+                extra: { tabId, targetId }
+            });
+        }
+        const target = this.sessions.addTarget(session.id, tabId, { url: tab.url ?? undefined, title: tab.title ?? undefined });
+        session.activeTargetId = target.targetId;
+        this.sendResponse(message, {
+            targetId: target.targetId,
+            url: target.url,
+            title: target.title,
+            adopted: true
         });
     }
     async handleTargetsNew(message, session) {
@@ -492,11 +620,12 @@ export class OpsRuntime {
         const pages = await Promise.all(this.sessions.listNamedTargets(session.id).map(async ({ name, targetId }) => {
             const target = session.targets.get(targetId);
             const tab = target ? await this.tabs.getTab(target.tabId) : null;
+            const synthetic = session.syntheticTargets.get(targetId);
             return {
                 name,
                 targetId,
-                url: tab?.url ?? target?.url,
-                title: tab?.title ?? target?.title
+                url: resolveReportedTargetUrl(target, tab?.url, synthetic),
+                title: resolveReportedTargetTitle(target, tab?.title, synthetic)
             };
         }));
         this.sendResponse(message, { pages });
@@ -549,6 +678,24 @@ export class OpsRuntime {
         if (!target)
             return;
         await this.tabs.activateTab(target.tabId).catch(() => undefined);
+        const targetRecord = session.targets.get(target.targetId);
+        const syntheticHtml = decodeHtmlDataUrl(url);
+        if (syntheticHtml !== null) {
+            const result = await executeInTab(target.tabId, replaceDocumentWithHtmlScript, [{ html: syntheticHtml }]);
+            session.refStore.clearTarget(target.targetId);
+            session.syntheticTargets.set(target.targetId, {
+                url,
+                title: typeof result?.title === "string" && result.title.trim().length > 0
+                    ? result.title
+                    : targetRecord?.title
+            });
+            this.sendResponse(message, {
+                finalUrl: url,
+                status: undefined,
+                timingMs: Date.now() - start
+            });
+            return;
+        }
         const updated = await new Promise((resolve) => {
             chrome.tabs.update(target.tabId, { url }, (tab) => {
                 resolve(tab ?? null);
@@ -556,10 +703,13 @@ export class OpsRuntime {
         });
         await this.tabs.waitForTabComplete(target.tabId, timeoutMs).catch(() => undefined);
         const refreshed = await this.tabs.getTab(target.tabId);
-        const targetRecord = session.targets.get(target.targetId);
+        session.syntheticTargets.delete(target.targetId);
         if (targetRecord) {
-            targetRecord.url = refreshed?.url ?? updated?.url ?? url;
-            targetRecord.title = refreshed?.title ?? updated?.title ?? targetRecord.title;
+            session.targets.set(target.targetId, {
+                ...targetRecord,
+                url: refreshed?.url ?? updated?.url ?? url,
+                title: refreshed?.title ?? updated?.title ?? targetRecord.title
+            });
         }
         this.sendResponse(message, {
             finalUrl: refreshed?.url ?? updated?.url ?? url,
@@ -580,7 +730,7 @@ export class OpsRuntime {
             if (!selector)
                 return;
             try {
-                await this.waitForSelector(target.tabId, selector, state, timeoutMs);
+                await this.waitForSelector(target, selector, state, timeoutMs);
                 this.sendResponse(message, { timingMs: Date.now() - start });
             }
             catch (error) {
@@ -619,10 +769,12 @@ export class OpsRuntime {
             return;
         }
         const tab = await this.tabs.getTab(target.tabId);
+        const targetRecord = session.targets.get(target.targetId);
+        const synthetic = session.syntheticTargets.get(target.targetId);
         this.sendResponse(message, {
             snapshotId: snapshot.snapshotId,
-            url: tab?.url ?? undefined,
-            title: tab?.title ?? undefined,
+            url: resolveReportedTargetUrl(targetRecord ?? null, tab?.url, synthetic),
+            title: resolveReportedTargetTitle(targetRecord ?? null, tab?.title, synthetic),
             content,
             truncated,
             nextCursor,
@@ -640,7 +792,7 @@ export class OpsRuntime {
             return;
         const start = Date.now();
         const before = await this.tabs.getTab(target.tabId);
-        await this.dom.click(target.tabId, selector);
+        await this.runElementAction(target, selector, { type: "click" }, () => this.dom.click(target.tabId, selector));
         const after = await this.tabs.getTab(target.tabId);
         const navigated = Boolean(before?.url && after?.url && before.url !== after.url);
         this.sendResponse(message, { timingMs: Date.now() - start, navigated });
@@ -653,7 +805,7 @@ export class OpsRuntime {
         if (!target)
             return;
         const start = Date.now();
-        await this.dom.hover(target.tabId, selector);
+        await this.runElementAction(target, selector, { type: "hover" }, () => this.dom.hover(target.tabId, selector));
         this.sendResponse(message, { timingMs: Date.now() - start });
     }
     async handlePress(message, session) {
@@ -670,7 +822,7 @@ export class OpsRuntime {
         if (payload.ref && !selector)
             return;
         const start = Date.now();
-        await this.dom.press(target.tabId, selector, key);
+        await this.runCanvasPageAction(target, { type: "press", key }, selector, () => this.dom.press(target.tabId, selector, key));
         this.sendResponse(message, { timingMs: Date.now() - start });
     }
     async handleCheck(message, session, checked) {
@@ -681,7 +833,7 @@ export class OpsRuntime {
         if (!target)
             return;
         const start = Date.now();
-        await this.dom.setChecked(target.tabId, selector, checked);
+        await this.runElementAction(target, selector, { type: "setChecked", checked }, () => this.dom.setChecked(target.tabId, selector, checked));
         this.sendResponse(message, { timingMs: Date.now() - start });
     }
     async handleType(message, session) {
@@ -699,7 +851,7 @@ export class OpsRuntime {
         if (!target)
             return;
         const start = Date.now();
-        await this.dom.type(target.tabId, selector, text, payload.clear === true, payload.submit === true);
+        await this.runElementAction(target, selector, { type: "type", value: text, clear: payload.clear === true, submit: payload.submit === true }, () => this.dom.type(target.tabId, selector, text, payload.clear === true, payload.submit === true));
         this.sendResponse(message, { timingMs: Date.now() - start });
     }
     async handleSelect(message, session) {
@@ -716,7 +868,7 @@ export class OpsRuntime {
         const target = this.requireActiveTarget(session, message);
         if (!target)
             return;
-        await this.dom.select(target.tabId, selector, values);
+        await this.runElementAction(target, selector, { type: "select", values: values }, () => this.dom.select(target.tabId, selector, values));
         this.sendResponse(message, {});
     }
     async handleScroll(message, session) {
@@ -729,7 +881,7 @@ export class OpsRuntime {
         const target = this.requireActiveTarget(session, message);
         if (!target)
             return;
-        await this.dom.scroll(target.tabId, dy, selector);
+        await this.runCanvasPageAction(target, { type: "scroll", dy }, selector ?? null, () => this.dom.scroll(target.tabId, dy, selector));
         this.sendResponse(message, {});
     }
     async handleScrollIntoView(message, session) {
@@ -740,7 +892,7 @@ export class OpsRuntime {
         if (!target)
             return;
         const start = Date.now();
-        await this.dom.scrollIntoView(target.tabId, selector);
+        await this.runElementAction(target, selector, { type: "scrollIntoView" }, () => this.dom.scrollIntoView(target.tabId, selector));
         this.sendResponse(message, { timingMs: Date.now() - start });
     }
     async handleDomGetHtml(message, session) {
@@ -757,7 +909,7 @@ export class OpsRuntime {
         const target = this.requireActiveTarget(session, message);
         if (!target)
             return;
-        const html = await this.dom.getOuterHtml(target.tabId, selector);
+        const html = await this.runElementAction(target, selector, { type: "outerHTML" }, () => this.dom.getOuterHtml(target.tabId, selector));
         const truncated = html.length > maxChars;
         const outerHTML = truncated ? html.slice(0, maxChars) : html;
         this.sendResponse(message, { outerHTML, truncated });
@@ -776,7 +928,7 @@ export class OpsRuntime {
         const target = this.requireActiveTarget(session, message);
         if (!target)
             return;
-        const text = await this.dom.getInnerText(target.tabId, selector);
+        const text = await this.runElementAction(target, selector, { type: "innerText" }, () => this.dom.getInnerText(target.tabId, selector));
         const truncated = text.length > maxChars;
         this.sendResponse(message, { text: truncated ? text.slice(0, maxChars) : text, truncated });
     }
@@ -794,7 +946,7 @@ export class OpsRuntime {
         const target = this.requireActiveTarget(session, message);
         if (!target)
             return;
-        const value = await this.dom.getAttr(target.tabId, selector, name);
+        const value = await this.runElementAction(target, selector, { type: "getAttr", name }, () => this.dom.getAttr(target.tabId, selector, name));
         this.sendResponse(message, { value });
     }
     async handleDomGetValue(message, session) {
@@ -810,7 +962,7 @@ export class OpsRuntime {
         const target = this.requireActiveTarget(session, message);
         if (!target)
             return;
-        const value = await this.dom.getValue(target.tabId, selector);
+        const value = await this.runElementAction(target, selector, { type: "getValue" }, () => this.dom.getValue(target.tabId, selector));
         this.sendResponse(message, { value });
     }
     async handleDomIsVisible(message, session) {
@@ -820,8 +972,11 @@ export class OpsRuntime {
         const target = this.requireActiveTarget(session, message);
         if (!target)
             return;
-        const visible = await this.dom.isVisible(target.tabId, selector);
-        this.sendResponse(message, { value: visible });
+        const visible = await this.runElementAction(target, selector, { type: "getSelectorState" }, async () => await this.dom.getSelectorState(target.tabId, selector));
+        const isVisible = typeof visible === "object" && visible !== null && "visible" in visible
+            ? Boolean(visible.visible)
+            : Boolean(visible);
+        this.sendResponse(message, { value: isVisible });
     }
     async handleDomIsEnabled(message, session) {
         const selector = this.resolveSelector(session, message.payload, message);
@@ -830,7 +985,7 @@ export class OpsRuntime {
         const target = this.requireActiveTarget(session, message);
         if (!target)
             return;
-        const enabled = await this.dom.isEnabled(target.tabId, selector);
+        const enabled = await this.runElementAction(target, selector, { type: "isEnabled" }, () => this.dom.isEnabled(target.tabId, selector));
         this.sendResponse(message, { value: enabled });
     }
     async handleDomIsChecked(message, session) {
@@ -840,14 +995,34 @@ export class OpsRuntime {
         const target = this.requireActiveTarget(session, message);
         if (!target)
             return;
-        const checked = await this.dom.isChecked(target.tabId, selector);
+        const checked = await this.runElementAction(target, selector, { type: "isChecked" }, () => this.dom.isChecked(target.tabId, selector));
         this.sendResponse(message, { value: checked });
     }
+    async handleCanvasRuntimePreviewBridge(message, session) {
+        const payload = isRecord(message.payload) ? message.payload : {};
+        const bindingId = typeof payload.bindingId === "string" ? payload.bindingId.trim() : "";
+        const rootSelector = typeof payload.rootSelector === "string" ? payload.rootSelector.trim() : "";
+        const html = typeof payload.html === "string" ? payload.html : "";
+        if (!bindingId || !rootSelector) {
+            this.sendError(message, buildError("invalid_request", "Missing bindingId or rootSelector", false));
+            return;
+        }
+        const target = this.requireActiveTarget(session, message);
+        if (!target)
+            return;
+        const result = await this.dom.applyRuntimePreviewBridge(target.tabId, bindingId, rootSelector, html);
+        this.sendResponse(message, result);
+    }
     async handleClonePage(message, session) {
         const payload = isRecord(message.payload) ? message.payload : {};
         const target = this.requireActiveTarget(session, message);
         if (!target)
             return;
+        const canvasCapture = await this.captureCanvasPage(target.tabId, target.targetId);
+        if (canvasCapture) {
+            this.sendResponse(message, { capture: canvasCapture });
+            return;
+        }
         const capture = await this.dom.captureDom(target.tabId, "body", {
             sanitize: payload.sanitize !== false,
             maxNodes: typeof payload.maxNodes === "number" ? payload.maxNodes : undefined,
@@ -925,11 +1100,98 @@ export class OpsRuntime {
         const nextSeq = lastEvent ? lastEvent.seq : sinceSeq;
         this.sendResponse(message, { events, nextSeq });
     }
+    async handleStorageSetCookies(message, session) {
+        const payload = isRecord(message.payload) ? message.payload : {};
+        const cookies = Array.isArray(payload.cookies) ? payload.cookies : null;
+        if (!cookies) {
+            this.sendError(message, buildError("invalid_request", "Missing cookies", false));
+            return;
+        }
+        const strict = payload.strict !== false;
+        const requestId = typeof payload.requestId === "string" && payload.requestId.trim().length > 0
+            ? payload.requestId
+            : createId();
+        const normalized = [];
+        const rejected = [];
+        cookies.forEach((entry, index) => {
+            if (!isRecord(entry)) {
+                rejected.push({ index, reason: "Invalid cookie entry: expected object." });
+                return;
+            }
+            const validation = validateCookieRecord(entry);
+            if (!validation.valid) {
+                rejected.push({ index, reason: validation.reason });
+                return;
+            }
+            normalized.push(validation.cookie);
+        });
+        if (strict && rejected.length > 0) {
+            this.sendError(message, buildError("invalid_request", `Cookie import rejected ${rejected.length} entries.`, false));
+            return;
+        }
+        if (normalized.length > 0) {
+            const target = this.requireActiveTarget(session, message);
+            if (!target)
+                return;
+            try {
+                await this.cdp.sendCommand({ tabId: target.tabId }, "Network.setCookies", { cookies: normalized });
+            }
+            catch (error) {
+                const detail = error instanceof Error ? error.message : "Cookie import failed";
+                this.sendError(message, buildError("execution_failed", detail, false));
+                return;
+            }
+        }
+        this.sendResponse(message, {
+            requestId,
+            imported: normalized.length,
+            rejected
+        });
+    }
+    async handleStorageGetCookies(message, session) {
+        const payload = isRecord(message.payload) ? message.payload : {};
+        const requestId = typeof payload.requestId === "string" && payload.requestId.trim().length > 0
+            ? payload.requestId
+            : createId();
+        let urls;
+        try {
+            urls = parseCookieFilterUrls(payload.urls);
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : "Invalid cookie url filter.";
+            this.sendError(message, buildError("invalid_request", detail, false));
+            return;
+        }
+        const target = this.requireActiveTarget(session, message);
+        if (!target)
+            return;
+        let rawCookies = [];
+        try {
+            const response = await this.cdp.sendCommand({ tabId: target.tabId }, "Network.getCookies", urls ? { urls } : {});
+            rawCookies = Array.isArray(response.cookies) ? response.cookies : [];
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : "Cookie list failed";
+            this.sendError(message, buildError("execution_failed", detail, false));
+            return;
+        }
+        const cookies = rawCookies
+            .map((entry) => toCookieListRecord(entry))
+            .filter((entry) => entry !== null);
+        this.sendResponse(message, {
+            requestId,
+            cookies,
+            count: cookies.length
+        });
+    }
     async enableSessionDomains(session) {
+        await this.enableTargetDomains(session.tabId);
+    }
+    async enableTargetDomains(tabId) {
         try {
-            await this.cdp.sendCommand({ tabId: session.tabId }, "Runtime.enable", {});
-            await this.cdp.sendCommand({ tabId: session.tabId }, "Network.enable", {});
-            await this.cdp.sendCommand({ tabId: session.tabId }, "Performance.enable", {});
+            await this.cdp.sendCommand({ tabId }, "Runtime.enable", {});
+            await this.cdp.sendCommand({ tabId }, "Network.enable", {});
+            await this.cdp.sendCommand({ tabId }, "Performance.enable", {});
         }
         catch (error) {
             logError("ops.enable_domains", error, { code: "enable_domains_failed" });
@@ -939,8 +1201,175 @@ export class OpsRuntime {
         const session = this.getSessionForMessage(message, clientId);
         if (!session)
             return;
-        session.queue = session.queue.then(() => handler(session), () => handler(session));
-        await session.queue;
+        if (!TARGET_SCOPED_COMMANDS.has(message.command)) {
+            session.queue = session.queue.then(() => handler(session), () => handler(session));
+            await session.queue;
+            return;
+        }
+        try {
+            await this.withTargetQueue(message, session, handler);
+        }
+        catch (error) {
+            if (isParallelismBackpressureError(error)) {
+                this.sendError(message, buildError("parallelism_backpressure", error.message, true, error.details));
+                return;
+            }
+            throw error;
+        }
+    }
+    resolveTargetIdForQueue(session, message) {
+        const payload = isRecord(message.payload) ? message.payload : {};
+        const requested = typeof payload.targetId === "string" ? payload.targetId.trim() : "";
+        return requested || session.activeTargetId || session.targetId;
+    }
+    sessionQueueAgeMs(session) {
+        let oldest = null;
+        for (const value of session.targetQueueOldestAt.values()) {
+            if (oldest === null || value < oldest) {
+                oldest = value;
+            }
+        }
+        return oldest === null ? 0 : Math.max(0, Date.now() - oldest);
+    }
+    sampleParallelism(session) {
+        const now = Date.now();
+        const policy = session.parallelismPolicy;
+        if (session.parallelismState.lastSampleAt > 0
+            && now - session.parallelismState.lastSampleAt < policy.sampleIntervalMs) {
+            return {
+                state: session.parallelismState,
+                pressure: session.parallelismState.lastPressure,
+                targetCap: session.parallelismState.effectiveCap,
+                waitQueueDepth: session.pendingParallel,
+                waitQueueAgeMs: this.sessionQueueAgeMs(session)
+            };
+        }
+        const snapshot = evaluateOpsGovernor(policy, session.parallelismState, {
+            hostFreeMemPct: 100,
+            rssUsagePct: 0,
+            queueAgeMs: this.sessionQueueAgeMs(session),
+            queueDepth: session.pendingParallel,
+            discardedSignals: session.discardedSignals,
+            frozenSignals: session.frozenSignals
+        }, now);
+        session.parallelismState = snapshot.state;
+        session.discardedSignals = 0;
+        session.frozenSignals = 0;
+        return snapshot;
+    }
+    wakeParallelWaiters(session) {
+        const waiters = this.parallelWaiters.get(session.id);
+        if (!waiters || waiters.length === 0) {
+            return;
+        }
+        this.sampleParallelism(session);
+        while (waiters.length > 0 && session.parallelInFlight < session.parallelismState.effectiveCap) {
+            const waiter = waiters.shift();
+            if (!waiter)
+                break;
+            if (waiter.timer !== null) {
+                clearTimeout(waiter.timer);
+                waiter.timer = null;
+            }
+            session.parallelInFlight += 1;
+            waiter.resolve();
+        }
+        if (waiters.length === 0) {
+            this.parallelWaiters.delete(session.id);
+        }
+    }
+    createParallelismBackpressureError(session, targetId, timeoutMs) {
+        const snapshot = this.sampleParallelism(session);
+        const details = {
+            sessionId: session.id,
+            targetId,
+            effectiveParallelCap: session.parallelismState.effectiveCap,
+            inFlight: session.parallelInFlight,
+            waitQueueDepth: snapshot.waitQueueDepth,
+            waitQueueAgeMs: snapshot.waitQueueAgeMs,
+            pressure: snapshot.pressure,
+            timeoutMs
+        };
+        const error = new Error(`Parallelism cap reached for target ${targetId}; retry later.`);
+        error.code = "parallelism_backpressure";
+        error.details = details;
+        return error;
+    }
+    async acquireParallelSlot(session, targetId, timeoutMs) {
+        const waiters = this.parallelWaiters.get(session.id) ?? [];
+        this.parallelWaiters.set(session.id, waiters);
+        this.sampleParallelism(session);
+        if (session.parallelInFlight < session.parallelismState.effectiveCap && waiters.length === 0) {
+            session.parallelInFlight += 1;
+            return;
+        }
+        await new Promise((resolve, reject) => {
+            const waiter = {
+                targetId,
+                enqueuedAt: Date.now(),
+                timeoutMs,
+                resolve,
+                reject,
+                timer: null
+            };
+            waiter.timer = setTimeout(() => {
+                const index = waiters.indexOf(waiter);
+                if (index >= 0) {
+                    waiters.splice(index, 1);
+                }
+                if (waiters.length === 0) {
+                    this.parallelWaiters.delete(session.id);
+                }
+                reject(this.createParallelismBackpressureError(session, targetId, timeoutMs));
+            }, timeoutMs);
+            waiters.push(waiter);
+            this.wakeParallelWaiters(session);
+        });
+    }
+    releaseParallelSlot(session) {
+        session.parallelInFlight = Math.max(0, session.parallelInFlight - 1);
+        this.wakeParallelWaiters(session);
+    }
+    async withTargetQueue(message, session, handler) {
+        const targetId = this.resolveTargetIdForQueue(session, message);
+        const enqueuedAt = Date.now();
+        const previous = session.targetQueues.get(targetId) ?? Promise.resolve();
+        let releaseQueue = () => { };
+        const gate = new Promise((resolve) => {
+            releaseQueue = resolve;
+        });
+        const tail = previous.then(() => gate, () => gate);
+        session.targetQueues.set(targetId, tail);
+        session.pendingParallel += 1;
+        session.targetQueueDepth.set(targetId, (session.targetQueueDepth.get(targetId) ?? 0) + 1);
+        if (!session.targetQueueOldestAt.has(targetId)) {
+            session.targetQueueOldestAt.set(targetId, enqueuedAt);
+        }
+        await previous;
+        let acquired = false;
+        try {
+            await this.acquireParallelSlot(session, targetId, session.parallelismPolicy.backpressureTimeoutMs);
+            acquired = true;
+            await handler(session);
+        }
+        finally {
+            if (acquired) {
+                this.releaseParallelSlot(session);
+            }
+            releaseQueue();
+            const depth = (session.targetQueueDepth.get(targetId) ?? 1) - 1;
+            if (depth <= 0) {
+                session.targetQueueDepth.delete(targetId);
+                session.targetQueueOldestAt.delete(targetId);
+            }
+            else {
+                session.targetQueueDepth.set(targetId, depth);
+            }
+            session.pendingParallel = Math.max(0, session.pendingParallel - 1);
+            if (session.targetQueues.get(targetId) === tail) {
+                session.targetQueues.delete(targetId);
+            }
+        }
     }
     getSessionForMessage(message, clientId) {
         const opsSessionId = message.opsSessionId;
@@ -974,8 +1403,15 @@ export class OpsRuntime {
         session.lastUsedAt = Date.now();
         return session;
     }
+    requestedTargetId(session, message) {
+        const payload = isRecord(message.payload) ? message.payload : {};
+        if (typeof payload.targetId === "string" && payload.targetId.trim().length > 0) {
+            return payload.targetId.trim();
+        }
+        return session.activeTargetId || null;
+    }
     requireActiveTarget(session, message) {
-        const targetId = session.activeTargetId;
+        const targetId = this.requestedTargetId(session, message);
         if (!targetId) {
             this.sendError(message, buildError("invalid_request", "No active target", false));
             return null;
@@ -987,12 +1423,99 @@ export class OpsRuntime {
         }
         if (target.url) {
             const restriction = isRestrictedUrl(target.url);
-            if (restriction.restricted) {
+            if (restriction.restricted && !this.isAllowedCanvasTargetUrl(target.url)) {
                 this.sendError(message, buildError("restricted_url", restriction.message ?? "Restricted tab.", false));
                 return null;
             }
         }
-        return { tabId: target.tabId, targetId: target.targetId };
+        return { tabId: target.tabId, targetId: target.targetId, url: target.url };
+    }
+    isAllowedCanvasTargetUrl(rawUrl) {
+        if (typeof rawUrl !== "string" || rawUrl.length === 0) {
+            return false;
+        }
+        try {
+            const allowedUrl = chrome.runtime.getURL("canvas.html");
+            return rawUrl === allowedUrl || rawUrl.startsWith(`${allowedUrl}#`) || rawUrl.startsWith(`${allowedUrl}?`);
+        }
+        catch {
+            return false;
+        }
+    }
+    async captureCanvasPage(tabId, targetId) {
+        if (!this.getCanvasPageState) {
+            return null;
+        }
+        const state = this.getCanvasPageState(targetId);
+        if (!state) {
+            return null;
+        }
+        const previewHtml = typeof state.html === "string" && state.html.length > 0
+            ? extractBodyHtml(state.html)
+            : null;
+        const shouldProbeLiveStage = Boolean(state.pendingMutation)
+            || (canvasStateContainsRichMedia(state) && !htmlContainsRichMedia(previewHtml));
+        if (shouldProbeLiveStage) {
+            const liveStageCapture = await this.captureLiveCanvasStage(tabId);
+            if (liveStageCapture) {
+                return liveStageCapture;
+            }
+            const documentCapture = buildCanvasDocumentCapture(state);
+            if (documentCapture) {
+                return documentCapture;
+            }
+        }
+        if (!previewHtml) {
+            return buildCanvasDocumentCapture(state);
+        }
+        return {
+            html: previewHtml,
+            styles: {},
+            warnings: ["canvas_state_capture"],
+            inlineStyles: false
+        };
+    }
+    async runElementAction(target, selector, action, fallback) {
+        return await this.runCanvasPageAction(target, action, selector, fallback);
+    }
+    async runCanvasPageAction(target, action, selector, fallback) {
+        if (!this.isAllowedCanvasTargetUrl(target.url) || !this.performCanvasPageAction) {
+            return await fallback();
+        }
+        return await this.performCanvasPageAction(target.targetId, action, selector ?? null);
+    }
+    async captureLiveCanvasStage(tabId) {
+        try {
+            const results = await chrome.scripting.executeScript({
+                target: { tabId },
+                func: () => {
+                    const stage = document.getElementById("canvas-stage-inner");
+                    if (!(stage instanceof HTMLElement)) {
+                        return null;
+                    }
+                    const html = stage.innerHTML.trim();
+                    if (!html) {
+                        return null;
+                    }
+                    const width = stage.style.width || `${Math.max(stage.scrollWidth, 320)}px`;
+                    const height = stage.style.height || `${Math.max(stage.scrollHeight, 240)}px`;
+                    return `<body><main data-surface="canvas" style="position:relative;width:${width};min-height:${height};">${html}</main></body>`;
+                }
+            });
+            const html = typeof results[0]?.result === "string" ? results[0].result : null;
+            if (!html) {
+                return null;
+            }
+            return {
+                html,
+                styles: {},
+                warnings: ["canvas_state_capture"],
+                inlineStyles: true
+            };
+        }
+        catch {
+            return null;
+        }
     }
     resolveSelector(session, refOrPayload, message) {
         const ref = typeof refOrPayload === "string"
@@ -1002,17 +1525,22 @@ export class OpsRuntime {
             this.sendError(message, buildError("invalid_request", "Missing ref", false));
             return null;
         }
-        const entry = session.refStore.resolve(session.activeTargetId, ref);
+        const targetId = this.requestedTargetId(session, message);
+        if (!targetId) {
+            this.sendError(message, buildError("invalid_request", "No active target", false));
+            return null;
+        }
+        const entry = session.refStore.resolve(targetId, ref);
         if (!entry) {
             this.sendError(message, buildError("invalid_request", `Unknown ref: ${ref}`, false));
             return null;
         }
         return entry.selector;
     }
-    async waitForSelector(tabId, selector, state, timeoutMs) {
+    async waitForSelector(target, selector, state, timeoutMs) {
         const start = Date.now();
         while (Date.now() - start < timeoutMs) {
-            const snapshot = await this.dom.getSelectorState(tabId, selector);
+            const snapshot = await this.runElementAction(target, selector, { type: "getSelectorState" }, () => this.dom.getSelectorState(target.tabId, selector));
             if (state === "attached" && snapshot.attached)
                 return;
             if (state === "visible" && snapshot.visible)
@@ -1025,6 +1553,17 @@ export class OpsRuntime {
     }
     cleanupSession(session, event) {
         this.clearClosingTimer(session.id);
+        const waiters = this.parallelWaiters.get(session.id);
+        if (waiters) {
+            for (const waiter of waiters) {
+                if (waiter.timer !== null) {
+                    clearTimeout(waiter.timer);
+                    waiter.timer = null;
+                }
+                waiter.reject(new Error("Ops session closed while waiting for parallelism slot."));
+            }
+            this.parallelWaiters.delete(session.id);
+        }
         this.sessions.delete(session.id);
         for (const target of session.targets.values()) {
             void this.cdp.detachTab(target.tabId).catch(() => undefined);
@@ -1185,12 +1724,188 @@ export class OpsRuntime {
         });
     }
 }
+const numberInRange = (value, fallback, min, max) => {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return fallback;
+    }
+    return Math.min(max, Math.max(min, value));
+};
+const parseParallelismPolicy = (value) => {
+    if (!isRecord(value)) {
+        return DEFAULT_OPS_PARALLELISM_POLICY;
+    }
+    const modeCapsInput = isRecord(value.modeCaps) ? value.modeCaps : {};
+    return {
+        floor: numberInRange(value.floor, DEFAULT_OPS_PARALLELISM_POLICY.floor, 1, 32),
+        backpressureTimeoutMs: numberInRange(value.backpressureTimeoutMs, DEFAULT_OPS_PARALLELISM_POLICY.backpressureTimeoutMs, 100, 120000),
+        sampleIntervalMs: numberInRange(value.sampleIntervalMs, DEFAULT_OPS_PARALLELISM_POLICY.sampleIntervalMs, 250, 60000),
+        recoveryStableWindows: numberInRange(value.recoveryStableWindows, DEFAULT_OPS_PARALLELISM_POLICY.recoveryStableWindows, 1, 20),
+        hostFreeMemMediumPct: numberInRange(value.hostFreeMemMediumPct, DEFAULT_OPS_PARALLELISM_POLICY.hostFreeMemMediumPct, 1, 99),
+        hostFreeMemHighPct: numberInRange(value.hostFreeMemHighPct, DEFAULT_OPS_PARALLELISM_POLICY.hostFreeMemHighPct, 1, 99),
+        hostFreeMemCriticalPct: numberInRange(value.hostFreeMemCriticalPct, DEFAULT_OPS_PARALLELISM_POLICY.hostFreeMemCriticalPct, 1, 99),
+        rssBudgetMb: numberInRange(value.rssBudgetMb, DEFAULT_OPS_PARALLELISM_POLICY.rssBudgetMb, 64, 65536),
+        rssSoftPct: numberInRange(value.rssSoftPct, DEFAULT_OPS_PARALLELISM_POLICY.rssSoftPct, 1, 99),
+        rssHighPct: numberInRange(value.rssHighPct, DEFAULT_OPS_PARALLELISM_POLICY.rssHighPct, 1, 99),
+        rssCriticalPct: numberInRange(value.rssCriticalPct, DEFAULT_OPS_PARALLELISM_POLICY.rssCriticalPct, 1, 99),
+        queueAgeHighMs: numberInRange(value.queueAgeHighMs, DEFAULT_OPS_PARALLELISM_POLICY.queueAgeHighMs, 100, 120000),
+        queueAgeCriticalMs: numberInRange(value.queueAgeCriticalMs, DEFAULT_OPS_PARALLELISM_POLICY.queueAgeCriticalMs, 100, 120000),
+        modeCaps: {
+            managedHeaded: numberInRange(modeCapsInput.managedHeaded, DEFAULT_OPS_PARALLELISM_POLICY.modeCaps.managedHeaded, 1, 64),
+            managedHeadless: numberInRange(modeCapsInput.managedHeadless, DEFAULT_OPS_PARALLELISM_POLICY.modeCaps.managedHeadless, 1, 64),
+            cdpConnectHeaded: numberInRange(modeCapsInput.cdpConnectHeaded, DEFAULT_OPS_PARALLELISM_POLICY.modeCaps.cdpConnectHeaded, 1, 64),
+            cdpConnectHeadless: numberInRange(modeCapsInput.cdpConnectHeadless, DEFAULT_OPS_PARALLELISM_POLICY.modeCaps.cdpConnectHeadless, 1, 64),
+            extensionOpsHeaded: numberInRange(modeCapsInput.extensionOpsHeaded, DEFAULT_OPS_PARALLELISM_POLICY.modeCaps.extensionOpsHeaded, 1, 64),
+            extensionLegacyCdpHeaded: numberInRange(modeCapsInput.extensionLegacyCdpHeaded, DEFAULT_OPS_PARALLELISM_POLICY.modeCaps.extensionLegacyCdpHeaded, 1, 64)
+        }
+    };
+};
+const isParallelismBackpressureError = (error) => {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const typed = error;
+    return typed.code === "parallelism_backpressure" && typeof typed.details === "object" && typed.details !== null;
+};
 const buildError = (code, message, retryable, details) => ({
     code,
     message,
     retryable,
     details
 });
+const validateCookieRecord = (cookie) => {
+    const name = cookie.name?.trim();
+    if (!name) {
+        return { valid: false, reason: "Cookie name is required.", cookie };
+    }
+    if (!/^[^\s;=]+$/.test(name)) {
+        return { valid: false, reason: `Invalid cookie name: ${cookie.name}.`, cookie };
+    }
+    if (typeof cookie.value !== "string" || /\r|\n|;/.test(cookie.value)) {
+        return { valid: false, reason: `Invalid cookie value for ${name}.`, cookie };
+    }
+    const hasUrl = typeof cookie.url === "string" && cookie.url.trim().length > 0;
+    const hasDomain = typeof cookie.domain === "string" && cookie.domain.trim().length > 0;
+    if (!hasUrl && !hasDomain) {
+        return { valid: false, reason: `Cookie ${name} requires url or domain.`, cookie };
+    }
+    let normalizedUrl;
+    if (hasUrl) {
+        try {
+            const parsedUrl = new URL(cookie.url);
+            if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+                return { valid: false, reason: `Cookie ${name} url must be http(s).`, cookie };
+            }
+            normalizedUrl = parsedUrl.toString();
+        }
+        catch {
+            return { valid: false, reason: `Cookie ${name} has invalid url.`, cookie };
+        }
+    }
+    let normalizedDomain;
+    if (hasDomain) {
+        normalizedDomain = String(cookie.domain).trim().toLowerCase();
+        if (!/^\.?[a-z0-9.-]+$/.test(normalizedDomain) || normalizedDomain.includes("..")) {
+            return { valid: false, reason: `Cookie ${name} has invalid domain.`, cookie };
+        }
+    }
+    const normalizedPath = typeof cookie.path === "string" ? cookie.path.trim() : undefined;
+    if (typeof normalizedPath === "string" && !normalizedPath.startsWith("/")) {
+        return { valid: false, reason: `Cookie ${name} path must start with '/'.`, cookie };
+    }
+    if (typeof cookie.expires !== "undefined") {
+        if (!Number.isFinite(cookie.expires) || cookie.expires < -1) {
+            return { valid: false, reason: `Cookie ${name} has invalid expires.`, cookie };
+        }
+    }
+    if (cookie.sameSite === "None" && cookie.secure !== true) {
+        return { valid: false, reason: `Cookie ${name} with SameSite=None must set secure=true.`, cookie };
+    }
+    const normalizedCookie = {
+        name,
+        value: cookie.value,
+        ...(typeof cookie.expires === "number" ? { expires: cookie.expires } : {}),
+        ...(typeof cookie.httpOnly === "boolean" ? { httpOnly: cookie.httpOnly } : {}),
+        ...(typeof cookie.secure === "boolean" ? { secure: cookie.secure } : {}),
+        ...(cookie.sameSite ? { sameSite: cookie.sameSite } : {})
+    };
+    if (normalizedDomain) {
+        normalizedCookie.domain = normalizedDomain;
+        normalizedCookie.path = normalizedPath ?? "/";
+    }
+    else if (normalizedUrl) {
+        normalizedCookie.url = normalizedUrl;
+    }
+    return {
+        valid: true,
+        reason: "",
+        cookie: normalizedCookie
+    };
+};
+const parseCookieFilterUrls = (value) => {
+    if (typeof value === "undefined") {
+        return undefined;
+    }
+    if (!Array.isArray(value)) {
+        throw new Error("Cookie url filters must be an array of strings.");
+    }
+    const normalized = [];
+    const seen = new Set();
+    for (const entry of value) {
+        if (typeof entry !== "string") {
+            throw new Error("Cookie url filters must be an array of strings.");
+        }
+        const trimmed = entry.trim();
+        if (!trimmed) {
+            throw new Error("Cookie url filters must be non-empty strings.");
+        }
+        let parsedUrl;
+        try {
+            parsedUrl = new URL(trimmed);
+        }
+        catch {
+            throw new Error(`Cookie url filter is invalid: ${trimmed}`);
+        }
+        if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+            throw new Error(`Cookie url filter must be http(s): ${trimmed}`);
+        }
+        const normalizedUrl = parsedUrl.toString();
+        if (seen.has(normalizedUrl)) {
+            continue;
+        }
+        seen.add(normalizedUrl);
+        normalized.push(normalizedUrl);
+    }
+    return normalized.length > 0 ? normalized : undefined;
+};
+const toCookieListRecord = (entry) => {
+    if (!isRecord(entry)) {
+        return null;
+    }
+    const name = typeof entry.name === "string" ? entry.name : "";
+    const value = typeof entry.value === "string" ? entry.value : "";
+    const domain = typeof entry.domain === "string" ? entry.domain : "";
+    const path = typeof entry.path === "string" ? entry.path : "";
+    const expires = typeof entry.expires === "number" && Number.isFinite(entry.expires) ? entry.expires : -1;
+    const httpOnly = entry.httpOnly === true;
+    const secure = entry.secure === true;
+    if (!name || !domain || !path) {
+        return null;
+    }
+    const sameSiteRaw = entry.sameSite;
+    const sameSite = sameSiteRaw === "Strict" || sameSiteRaw === "Lax" || sameSiteRaw === "None"
+        ? sameSiteRaw
+        : undefined;
+    return {
+        name,
+        value,
+        domain,
+        path,
+        expires,
+        httpOnly,
+        secure,
+        ...(sameSite ? { sameSite } : {})
+    };
+};
 const isRecord = (value) => {
     return Boolean(value && typeof value === "object" && !Array.isArray(value));
 };
@@ -1227,6 +1942,257 @@ const paginate = (lines, startIndex, maxChars) => {
     };
 };
 const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const parseTabTargetId = (targetId) => {
+    const raw = targetId.startsWith("tab-") ? targetId.slice(4) : targetId;
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return null;
+    }
+    return parsed;
+};
+const extractBodyHtml = (html) => {
+    const bodyMatch = html.match(/<body\b[^>]*>[\s\S]*<\/body>/i);
+    if (bodyMatch) {
+        return bodyMatch[0];
+    }
+    return html;
+};
+const htmlContainsRichMedia = (html) => {
+    return typeof html === "string" && /<(img|video|audio)\b/i.test(html);
+};
+const canvasStateContainsRichMedia = (state) => {
+    const document = isRecord(state.document) ? state.document : null;
+    const pages = Array.isArray(document?.pages) ? document.pages : [];
+    const assets = Array.isArray(document?.assets) ? document.assets : [];
+    const assetsById = new Map(assets.flatMap((asset) => typeof asset?.id === "string" ? [[asset.id, asset]] : []));
+    return pages.some((page) => Array.isArray(page?.nodes) && page.nodes.some((node) => nodeContainsRichMedia(node, assetsById)));
+};
+const nodeContainsRichMedia = (node, assetsById) => {
+    const tagName = readCanvasMediaTagName(node);
+    if (tagName === "img" || tagName === "video" || tagName === "audio") {
+        return true;
+    }
+    const assetIds = Array.isArray(node.metadata.assetIds)
+        ? node.metadata.assetIds.filter((entry) => typeof entry === "string" && entry.trim().length > 0)
+        : [];
+    return assetIds.some((assetId) => {
+        const asset = assetsById.get(assetId);
+        const kind = typeof asset?.kind === "string" ? asset.kind.toLowerCase() : "";
+        const mime = typeof asset?.mime === "string" ? asset.mime.toLowerCase() : "";
+        return kind === "image" || kind === "video" || kind === "audio" || mime.startsWith("image/") || mime.startsWith("video/") || mime.startsWith("audio/");
+    });
+};
+const readCanvasMediaTagName = (node) => {
+    if (typeof node.props.tagName === "string" && node.props.tagName.trim().length > 0) {
+        return node.props.tagName.trim().toLowerCase();
+    }
+    const codeSync = isRecord(node.metadata.codeSync) ? node.metadata.codeSync : null;
+    if (codeSync && typeof codeSync.tagName === "string" && codeSync.tagName.trim().length > 0) {
+        return codeSync.tagName.trim().toLowerCase();
+    }
+    return null;
+};
+const buildCanvasDocumentCapture = (state) => {
+    const page = Array.isArray(state.document.pages) ? state.document.pages[0] : null;
+    if (!page || !Array.isArray(page.nodes) || page.nodes.length === 0) {
+        return null;
+    }
+    const { width, height } = computeCanvasDocumentBounds(page.nodes);
+    const nodes = [...page.nodes]
+        .sort(compareCanvasCaptureNodes)
+        .map((node) => renderCanvasDocumentNode(state.document, node))
+        .join("");
+    return {
+        html: `<body><main data-surface="canvas" style="position:relative;width:${width}px;min-height:${height}px;">${nodes}</main></body>`,
+        styles: {},
+        warnings: ["canvas_state_capture"],
+        inlineStyles: true
+    };
+};
+const computeCanvasDocumentBounds = (nodes) => {
+    if (nodes.length === 0) {
+        return { width: 1600, height: 1200 };
+    }
+    const maxX = Math.max(...nodes.map((node) => node.rect.x + node.rect.width));
+    const maxY = Math.max(...nodes.map((node) => node.rect.y + node.rect.height));
+    return {
+        width: Math.max(maxX + 240, 1600),
+        height: Math.max(maxY + 240, 1200)
+    };
+};
+const compareCanvasCaptureNodes = (left, right) => {
+    const rootOrder = Number(left.parentId !== null) - Number(right.parentId !== null);
+    if (rootOrder !== 0) {
+        return rootOrder;
+    }
+    const areaOrder = (right.rect.width * right.rect.height) - (left.rect.width * left.rect.height);
+    if (areaOrder !== 0) {
+        return areaOrder;
+    }
+    const verticalOrder = left.rect.y - right.rect.y;
+    return verticalOrder !== 0 ? verticalOrder : left.rect.x - right.rect.x;
+};
+const renderCanvasDocumentNode = (document, node) => {
+    const media = resolveCanvasDocumentMedia(document, node);
+    const text = escapeCanvasHtml(nodeTextForCapture(node) || node.name);
+    const style = serializeCanvasCaptureStyle({
+        position: "absolute",
+        left: `${node.rect.x}px`,
+        top: `${node.rect.y}px`,
+        width: `${Math.max(node.rect.width, 40)}px`,
+        minHeight: `${Math.max(node.rect.height, readCanvasMediaTagName(node) === "audio" ? 64 : 40)}px`,
+        overflow: "hidden",
+        ...node.style
+    });
+    const title = escapeCanvasAttribute(`${node.kind} • ${node.name}`);
+    if (media?.kind === "image" && media.src) {
+        return `<div data-node-id="${escapeCanvasAttribute(node.id)}" title="${title}" style="${style}"><img src="${escapeCanvasAttribute(media.src)}" alt="${escapeCanvasAttribute(media.alt ?? node.name)}" loading="lazy" draggable="false" style="width:100%;height:100%;object-fit:cover;display:block;" /></div>`;
+    }
+    if (media?.kind === "video" && media.src) {
+        const poster = media.poster ? ` poster="${escapeCanvasAttribute(media.poster)}"` : "";
+        return `<div data-node-id="${escapeCanvasAttribute(node.id)}" title="${title}" style="${style}"><video src="${escapeCanvasAttribute(media.src)}"${poster} muted loop autoplay playsinline preload="metadata" style="width:100%;height:100%;object-fit:cover;display:block;"></video></div>`;
+    }
+    if (media?.kind === "audio" && media.src) {
+        return `<div data-node-id="${escapeCanvasAttribute(node.id)}" title="${title}" style="${style}"><audio src="${escapeCanvasAttribute(media.src)}" controls preload="metadata" style="width:100%;display:block;"></audio>${text ? `<div style="margin-top:8px;font:500 12px/1.4 sans-serif;">${text}</div>` : ""}</div>`;
+    }
+    return `<div data-node-id="${escapeCanvasAttribute(node.id)}" title="${title}" style="${style}">${text}</div>`;
+};
+const nodeTextForCapture = (node) => {
+    const raw = node.props.text ?? node.metadata.text;
+    if (raw !== undefined && raw !== null) {
+        return typeof raw === "string" ? raw : String(raw);
+    }
+    return node.kind === "text" || node.kind === "note" || node.kind === "component-instance"
+        ? node.name
+        : "";
+};
+const resolveCanvasDocumentMedia = (document, node) => {
+    const tagName = readCanvasMediaTagName(node);
+    const attributes = isRecord(node.props.attributes) ? node.props.attributes : {};
+    const assetIds = Array.isArray(node.metadata.assetIds)
+        ? node.metadata.assetIds.filter((entry) => typeof entry === "string" && entry.trim().length > 0)
+        : [];
+    const asset = assetIds.length > 0
+        ? document.assets.find((entry) => entry.id === assetIds[0])
+        : null;
+    const assetKind = typeof asset?.kind === "string" ? asset.kind.toLowerCase() : null;
+    const assetMime = typeof asset?.mime === "string" ? asset.mime.toLowerCase() : null;
+    const src = typeof node.props.src === "string"
+        ? node.props.src
+        : typeof attributes.src === "string"
+            ? attributes.src
+            : typeof asset?.url === "string"
+                ? asset.url
+                : typeof asset?.repoPath === "string"
+                    ? asset.repoPath
+                    : null;
+    const poster = typeof node.props.poster === "string"
+        ? node.props.poster
+        : typeof attributes.poster === "string"
+            ? attributes.poster
+            : null;
+    const alt = typeof node.props.alt === "string"
+        ? node.props.alt
+        : typeof attributes.alt === "string"
+            ? attributes.alt
+            : node.name;
+    if (tagName === "img" || assetKind === "image" || assetMime?.startsWith("image/")) {
+        return { kind: "image", src, poster: null, alt };
+    }
+    if (tagName === "video" || assetKind === "video" || assetMime?.startsWith("video/")) {
+        return { kind: "video", src, poster, alt };
+    }
+    if (tagName === "audio" || assetKind === "audio" || assetMime?.startsWith("audio/")) {
+        return { kind: "audio", src, poster: null, alt };
+    }
+    return null;
+};
+const serializeCanvasCaptureStyle = (style) => {
+    return Object.entries(style)
+        .flatMap(([key, value]) => {
+        if (typeof value !== "string" && typeof value !== "number") {
+            return [];
+        }
+        const cssKey = key.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+        const cssValue = typeof value === "number" && !CANVAS_CAPTURE_UNITLESS_STYLES.has(key) ? `${value}px` : String(value);
+        return `${cssKey}:${escapeCanvasAttribute(cssValue)};`;
+    })
+        .join("");
+};
+const escapeCanvasHtml = (value) => {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;");
+};
+const escapeCanvasAttribute = (value) => {
+    return escapeCanvasHtml(value)
+        .replaceAll("\"", "&quot;")
+        .replaceAll("'", "&#39;");
+};
+const CANVAS_CAPTURE_UNITLESS_STYLES = new Set(["fontWeight", "lineHeight", "opacity", "zIndex"]);
+const resolveReportedTargetUrl = (target, liveUrl, synthetic) => {
+    if (typeof synthetic?.url === "string" && isHtmlDataUrl(synthetic.url)) {
+        return synthetic.url;
+    }
+    if (typeof target?.url === "string" && isHtmlDataUrl(target.url)) {
+        return target.url;
+    }
+    return liveUrl ?? target?.url;
+};
+const resolveReportedTargetTitle = (target, liveTitle, synthetic) => {
+    if (typeof synthetic?.title === "string" && synthetic.title.length > 0) {
+        return synthetic.title;
+    }
+    if (typeof target?.url === "string" && isHtmlDataUrl(target.url) && typeof target.title === "string" && target.title.length > 0) {
+        return target.title;
+    }
+    return liveTitle ?? target?.title;
+};
+const isHtmlDataUrl = (url) => {
+    return url.startsWith("data:text/html");
+};
+const decodeHtmlDataUrl = (url) => {
+    if (!isHtmlDataUrl(url)) {
+        return null;
+    }
+    const commaIndex = url.indexOf(",");
+    if (commaIndex === -1) {
+        return null;
+    }
+    const metadata = url.slice(0, commaIndex).toLowerCase();
+    const payload = url.slice(commaIndex + 1);
+    if (metadata.includes(";base64")) {
+        const decoded = atob(payload);
+        const bytes = Uint8Array.from(decoded, (char) => char.charCodeAt(0));
+        return new TextDecoder().decode(bytes);
+    }
+    try {
+        return decodeURIComponent(payload);
+    }
+    catch {
+        return payload;
+    }
+};
+const executeInTab = async (tabId, func, args) => {
+    return await new Promise((resolve, reject) => {
+        chrome.scripting.executeScript({ target: { tabId }, func: func, args }, (results) => {
+            const lastError = chrome.runtime.lastError;
+            if (lastError) {
+                reject(new Error(lastError.message));
+                return;
+            }
+            const [first] = results ?? [];
+            resolve((first?.result ?? null));
+        });
+    });
+};
+function replaceDocumentWithHtmlScript(input) {
+    document.open();
+    document.write(input.html);
+    document.close();
+    return { title: document.title };
+}
 const withTimeout = async (promise, timeoutMs, message) => {
     return await new Promise((resolve, reject) => {
         const timeoutId = setTimeout(() => {