tabwright 1.0.0

package/dist/extension/background.js

@@ -0,0 +1,3994 @@
+//#region ../node_modules/.pnpm/string-dedent@3.0.2/node_modules/string-dedent/dist/dedent.mjs
+var cache = /* @__PURE__ */ new WeakMap();
+var newline = /(\n|\r\n?|\u2028|\u2029)/g;
+var leadingWhitespace = /^\s*/;
+var nonWhitespace = /\S/;
+var slice = Array.prototype.slice;
+var zero = "0".charCodeAt(0);
+var nine = "9".charCodeAt(0);
+var lowerA = "a".charCodeAt(0);
+var lowerF = "f".charCodeAt(0);
+var upperA = "A".charCodeAt(0);
+var upperF = "F".charCodeAt(0);
+function dedent(arg) {
+	if (typeof arg === "string") return process([arg])[0];
+	if (typeof arg === "function") return function() {
+		const args = slice.call(arguments);
+		args[0] = processTemplateStringsArray(args[0]);
+		return arg.apply(this, args);
+	};
+	const strings = processTemplateStringsArray(arg);
+	let s = getCooked(strings, 0);
+	for (let i = 1; i < strings.length; i++) s += arguments[i] + getCooked(strings, i);
+	return s;
+}
+function getCooked(strings, index) {
+	const str = strings[index];
+	if (str === void 0) throw new TypeError(`invalid cooked string at index ${index}`);
+	return str;
+}
+function processTemplateStringsArray(strings) {
+	const cached = cache.get(strings);
+	if (cached) return cached;
+	const raw = process(strings.raw);
+	const cooked = raw.map(cook);
+	Object.defineProperty(cooked, "raw", { value: Object.freeze(raw) });
+	Object.freeze(cooked);
+	cache.set(strings, cooked);
+	return cooked;
+}
+function process(strings) {
+	const splitQuasis = strings.map((quasi) => quasi.split(newline));
+	let common;
+	for (let i = 0; i < splitQuasis.length; i++) {
+		const lines = splitQuasis[i];
+		const firstSplit = i === 0;
+		const lastSplit = i + 1 === splitQuasis.length;
+		if (firstSplit) {
+			if (lines.length === 1 || lines[0].length > 0) throw new Error("invalid content on opening line");
+			lines[1] = "";
+		}
+		if (lastSplit) {
+			if (lines.length === 1 || nonWhitespace.test(lines[lines.length - 1])) throw new Error("invalid content on closing line");
+			lines[lines.length - 2] = "";
+			lines[lines.length - 1] = "";
+		}
+		for (let j = 2; j < lines.length; j += 2) {
+			const text = lines[j];
+			const lineContainsTemplateExpression = j + 1 === lines.length && !lastSplit;
+			const leading = leadingWhitespace.exec(text)[0];
+			if (!lineContainsTemplateExpression && leading.length === text.length) {
+				lines[j] = "";
+				continue;
+			}
+			common = commonStart(leading, common);
+		}
+	}
+	const min = common ? common.length : 0;
+	return splitQuasis.map((lines) => {
+		let quasi = lines[0];
+		for (let i = 1; i < lines.length; i += 2) {
+			const newline = lines[i];
+			const text = lines[i + 1];
+			quasi += newline + text.slice(min);
+		}
+		return quasi;
+	});
+}
+function commonStart(a, b) {
+	if (b === void 0 || a === b) return a;
+	let i = 0;
+	for (const len = Math.min(a.length, b.length); i < len; i++) if (a[i] !== b[i]) break;
+	return a.slice(0, i);
+}
+function cook(raw) {
+	let out = "";
+	let start = 0;
+	let i = 0;
+	while ((i = raw.indexOf("\\", i)) > -1) {
+		out += raw.slice(start, i);
+		if (++i === raw.length) return void 0;
+		const next = raw[i++];
+		switch (next) {
+			case "b":
+				out += "\b";
+				break;
+			case "t":
+				out += "	";
+				break;
+			case "n":
+				out += "\n";
+				break;
+			case "v":
+				out += "\v";
+				break;
+			case "f":
+				out += "\f";
+				break;
+			case "r":
+				out += "\r";
+				break;
+			case "\r": if (i < raw.length && raw[i] === "\n") ++i;
+			case "\n":
+			case "\u2028":
+			case "\u2029": break;
+			case "0":
+				if (isDigit(raw, i)) return void 0;
+				out += "\0";
+				break;
+			case "x": {
+				const n = parseHex(raw, i, i + 2);
+				if (n === -1) return void 0;
+				i += 2;
+				out += String.fromCharCode(n);
+				break;
+			}
+			case "u": {
+				let n;
+				if (i < raw.length && raw[i] === "{") {
+					const end = raw.indexOf("}", ++i);
+					if (end === -1) return void 0;
+					n = parseHex(raw, i, end);
+					i = end + 1;
+				} else {
+					n = parseHex(raw, i, i + 4);
+					i += 4;
+				}
+				if (n === -1 || n > 1114111) return void 0;
+				out += String.fromCodePoint(n);
+				break;
+			}
+			default:
+				if (isDigit(next, 0)) return void 0;
+				out += next;
+		}
+		start = i;
+	}
+	return out + raw.slice(start);
+}
+function isDigit(str, index) {
+	const c = str.charCodeAt(index);
+	return c >= zero && c <= nine;
+}
+function parseHex(str, index, end) {
+	if (end >= str.length) return -1;
+	let n = 0;
+	for (; index < end; index++) {
+		const c = hexToInt(str.charCodeAt(index));
+		if (c === -1) return -1;
+		n = n * 16 + c;
+	}
+	return n;
+}
+function hexToInt(c) {
+	if (c >= zero && c <= nine) return c - zero;
+	if (c >= lowerA && c <= lowerF) return c - lowerA + 10;
+	if (c >= upperA && c <= upperF) return c - upperA + 10;
+	return -1;
+}
+//#endregion
+//#region ../node_modules/.pnpm/zustand@5.0.14_@types+react@19.2.17_react@19.2.7/node_modules/zustand/esm/vanilla.mjs
+var createStoreImpl = (createState) => {
+	let state;
+	const listeners = /* @__PURE__ */ new Set();
+	const setState = (partial, replace) => {
+		const nextState = typeof partial === "function" ? partial(state) : partial;
+		if (!Object.is(nextState, state)) {
+			const previousState = state;
+			state = (replace != null ? replace : typeof nextState !== "object" || nextState === null) ? nextState : Object.assign({}, state, nextState);
+			listeners.forEach((listener) => listener(state, previousState));
+		}
+	};
+	const getState = () => state;
+	const getInitialState = () => initialState;
+	const subscribe = (listener) => {
+		listeners.add(listener);
+		return () => listeners.delete(listener);
+	};
+	const api = {
+		setState,
+		getState,
+		getInitialState,
+		subscribe
+	};
+	const initialState = state = createState(setState, getState, api);
+	return api;
+};
+var createStore = ((createState) => createState ? createStoreImpl(createState) : createStoreImpl);
+//#endregion
+//#region src/toolbar/toolbar.ts
+function initTabwrightToolbarBridge() {
+	if (window.__playwriterToolbarBridgeInstalled) return;
+	window.__playwriterToolbarBridgeInstalled = true;
+	function isToolbarRequest(value) {
+		if (!value || typeof value !== "object") return false;
+		const candidate = value;
+		return candidate.source === "playwriter-toolbar" && (candidate.type === "recording-status" || candidate.type === "recording-toggle") && typeof candidate.requestId === "string";
+	}
+	function isToolbarRuntimeResponse(value, requestId) {
+		if (!value || typeof value !== "object") return false;
+		return value.requestId === requestId;
+	}
+	function getErrorMessage(error) {
+		return error instanceof Error ? error.message : String(error);
+	}
+	function isExtensionContextInvalidated(error) {
+		return getErrorMessage(error).includes("Extension context invalidated");
+	}
+	window.addEventListener("message", (event) => {
+		if (!isToolbarRequest(event.data)) return;
+		const data = event.data;
+		const action = data.type === "recording-toggle" ? "playwriterToolbarToggleRecording" : "playwriterToolbarRecordingStatus";
+		const requestId = data.requestId;
+		const responseType = `${data.type}-result`;
+		const connectedPort = (() => {
+			try {
+				return chrome.runtime.connect({ name: "playwriter-toolbar-recording" });
+			} catch (error) {
+				if (isExtensionContextInvalidated(error)) return null;
+				const message = getErrorMessage(error);
+				console.warn("[Tabwright toolbar bridge] port connect failed", data.type, requestId, message);
+				window.postMessage({
+					source: "playwriter-toolbar-bridge",
+					type: responseType,
+					requestId,
+					result: {
+						success: false,
+						error: message
+					}
+				}, "*");
+				return null;
+			}
+		})();
+		if (!connectedPort) return;
+		const port = connectedPort;
+		const timeoutId = window.setTimeout(() => {
+			failWithMessage({
+				message: `Tabwright toolbar background did not respond (${data.type}, ${requestId})`,
+				disconnect: true
+			});
+		}, 85e3);
+		let settled = false;
+		function cleanup(options) {
+			window.clearTimeout(timeoutId);
+			port.onMessage.removeListener(onPortMessage);
+			port.onDisconnect.removeListener(onDisconnect);
+			if (options.disconnect) port.disconnect();
+		}
+		function postResult(result) {
+			window.postMessage({
+				source: "playwriter-toolbar-bridge",
+				type: responseType,
+				requestId,
+				result
+			}, "*");
+		}
+		function abandonRequest() {
+			if (settled) return;
+			settled = true;
+			cleanup({ disconnect: false });
+		}
+		function failWithMessage(options) {
+			if (settled) return;
+			settled = true;
+			cleanup({ disconnect: options.disconnect });
+			console.warn("[Tabwright toolbar bridge] port request failed", data.type, requestId, options.message);
+			postResult({
+				success: false,
+				error: options.message
+			});
+		}
+		function onPortMessage(response) {
+			if (!isToolbarRuntimeResponse(response, requestId)) return;
+			if (settled) return;
+			settled = true;
+			cleanup({ disconnect: true });
+			postResult(response.result);
+		}
+		function onDisconnect() {
+			const message = (() => {
+				try {
+					return chrome.runtime.lastError?.message || "Tabwright toolbar background port disconnected";
+				} catch (error) {
+					return getErrorMessage(error);
+				}
+			})();
+			if (message.includes("Extension context invalidated")) {
+				abandonRequest();
+				return;
+			}
+			failWithMessage({
+				message,
+				disconnect: false
+			});
+		}
+		port.onMessage.addListener(onPortMessage);
+		port.onDisconnect.addListener(onDisconnect);
+		try {
+			port.postMessage({
+				action,
+				requestId
+			});
+		} catch (error) {
+			if (isExtensionContextInvalidated(error)) {
+				abandonRequest();
+				return;
+			}
+			failWithMessage({
+				message: getErrorMessage(error),
+				disconnect: true
+			});
+		}
+	});
+}
+function initTabwrightToolbar() {
+	if (window.__playwriterToolbarInstalled) return;
+	window.__playwriterToolbarInstalled = true;
+	try {
+		if (window !== window.top) return;
+	} catch {
+		return;
+	}
+	let pinModeActive = false;
+	let pinCount = 0;
+	let recordingActive = false;
+	let recordingBusy = false;
+	let nextBridgeRequestId = 1;
+	let toastTimer = null;
+	let overlayEl = null;
+	let annotationLayerEl = null;
+	let annotationEditorEl = null;
+	let annotationPreview = null;
+	let annotationCount = 0;
+	let annotationLayoutListening = false;
+	const annotationMarkers = [];
+	let pinBtn;
+	let recordBtn;
+	const host = document.createElement("div");
+	host.setAttribute("data-playwriter-toolbar", "1");
+	host.style.cssText = "position:fixed;top:12px;right:12px;z-index:2147483647;pointer-events:none;font-size:0;line-height:0;";
+	const shadow = host.attachShadow({ mode: "closed" });
+	const styleEl = document.createElement("style");
+	styleEl.textContent = `
+    *,*::before,*::after { box-sizing: border-box; margin: 0; padding: 0; }
+    .toolbar {
+      display: flex;
+      align-items: center;
+      gap: 2px;
+      padding: 3px;
+      background: #fff;
+      border-radius: 10px;
+      pointer-events: all;
+      user-select: none;
+      box-shadow: 0px 0px 0.5px rgba(0,0,0,0.18), 0px 3px 8px rgba(0,0,0,0.1), 0px 1px 3px rgba(0,0,0,0.1);
+    }
+    .divider {
+      width: 1px;
+      height: 12px;
+      background: rgba(0, 0, 0, 0.08);
+      margin: 0 1px;
+      flex-shrink: 0;
+    }
+    .btn {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      width: 26px;
+      height: 26px;
+      border: none;
+      border-radius: 7px;
+      background: transparent;
+      color: #000;
+      cursor: pointer;
+      transition: background 0.1s;
+      padding: 0;
+      flex-shrink: 0;
+      outline: none;
+    }
+    .btn:hover {
+      background: rgba(0, 0, 0, 0.04);
+    }
+    .btn.active {
+      background: #0d99ff;
+      color: #fff;
+    }
+    .btn.active:hover {
+      background: #0d99ff;
+      filter: brightness(1.05);
+    }
+    .btn.recording {
+      color: #ef4444;
+    }
+    .btn.recording.active {
+      background: #ef4444;
+      color: #fff;
+    }
+    .btn.recording.active:hover {
+      background: #ef4444;
+      filter: brightness(1.05);
+    }
+    .btn.busy {
+      opacity: 0.55;
+      cursor: wait;
+    }
+    /* When active, the logo inner cursor path needs to match the blue bg
+       so it appears as a "cutout" through the white outer shape */
+    .btn.active .logo-inner { fill: #0d99ff; }
+    .toast {
+      position: fixed;
+      background: #0f172a;
+      border-radius: 8px;
+      padding: 9px 18px;
+      color: rgba(255, 255, 255, 0.85);
+      font-size: 11px;
+      font-family: ui-monospace, 'SF Mono', Menlo, monospace;
+      pointer-events: none;
+      box-shadow: 0 4px 14px rgba(0, 0, 0, 0.35);
+      white-space: nowrap;
+      z-index: 1;
+      --toast-transform: translateX(-50%);
+      animation: toast-in 0.15s ease;
+    }
+    @keyframes toast-in {
+      from { opacity: 0; transform: var(--toast-transform) translateY(4px); }
+      to   { opacity: 1; transform: var(--toast-transform); }
+    }
+    .annotation-popover {
+      position: fixed;
+      width: min(360px, calc(100vw - 24px));
+      padding: 12px;
+      border: 1px solid rgba(15, 23, 42, 0.12);
+      border-radius: 12px;
+      background: rgba(255, 255, 255, 0.98);
+      color: #0f172a;
+      font-family: ui-sans-serif, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      box-shadow: 0 18px 50px rgba(15, 23, 42, 0.18), 0 3px 12px rgba(15, 23, 42, 0.1);
+      z-index: 2;
+      pointer-events: all;
+      animation: annotation-in 0.14s ease;
+      backdrop-filter: blur(10px);
+    }
+    @keyframes annotation-in {
+      from { opacity: 0; transform: translateY(4px) scale(0.98); }
+      to   { opacity: 1; transform: translateY(0) scale(1); }
+    }
+    .annotation-title {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      gap: 8px;
+      margin-bottom: 8px;
+      font-size: 12px;
+      font-weight: 650;
+      letter-spacing: 0;
+    }
+    .annotation-target {
+      max-width: 210px;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+      color: #64748b;
+      font-size: 11px;
+      font-weight: 500;
+    }
+    .annotation-input {
+      display: block;
+      width: 100%;
+      min-height: 76px;
+      max-height: 150px;
+      resize: vertical;
+      border: 1px solid #d8dee8;
+      border-radius: 9px;
+      padding: 9px 10px;
+      color: #0f172a;
+      background: #fff;
+      font: 12px/1.45 ui-sans-serif, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      outline: none;
+    }
+    .annotation-input:focus {
+      border-color: #0d99ff;
+      box-shadow: 0 0 0 3px rgba(13, 153, 255, 0.14);
+    }
+    .annotation-actions {
+      display: flex;
+      justify-content: flex-end;
+      gap: 8px;
+      margin-top: 10px;
+    }
+    .annotation-action {
+      height: 28px;
+      padding: 0 11px;
+      border-radius: 8px;
+      border: 1px solid transparent;
+      font-size: 12px;
+      font-weight: 600;
+      cursor: pointer;
+      background: transparent;
+      color: #334155;
+    }
+    .annotation-action:hover {
+      background: #f1f5f9;
+    }
+    .annotation-action.primary {
+      color: #fff;
+      background: #0d99ff;
+      border-color: #0d99ff;
+    }
+    .annotation-action.primary:hover {
+      background: #087ad1;
+      border-color: #087ad1;
+    }
+  `;
+	const toolbarEl = document.createElement("div");
+	toolbarEl.className = "toolbar";
+	toolbarEl.setAttribute("role", "toolbar");
+	toolbarEl.setAttribute("aria-label", "Tabwright tools");
+	shadow.appendChild(styleEl);
+	shadow.appendChild(toolbarEl);
+	function showToast(msg, anchorRect) {
+		shadow.querySelectorAll(".toast").forEach((el) => {
+			el.remove();
+		});
+		if (toastTimer !== null) clearTimeout(toastTimer);
+		const toastEl = document.createElement("div");
+		toastEl.className = "toast";
+		toastEl.textContent = msg;
+		if (anchorRect) {
+			const GAP = 8;
+			const centerX = anchorRect.left + anchorRect.width / 2;
+			const belowY = anchorRect.bottom + GAP;
+			const fitsBelow = belowY + 36 < window.innerHeight;
+			const top = fitsBelow ? belowY : anchorRect.top - GAP;
+			const transformOrigin = fitsBelow ? "top center" : "bottom center";
+			toastEl.style.left = Math.max(8, Math.min(centerX, window.innerWidth - 8)) + "px";
+			toastEl.style.top = top + "px";
+			const baseTransform = fitsBelow ? "translateX(-50%)" : "translateX(-50%) translateY(-100%)";
+			toastEl.style.setProperty("--toast-transform", baseTransform);
+			toastEl.style.transform = baseTransform;
+			toastEl.style.transformOrigin = transformOrigin;
+		} else {
+			toastEl.style.bottom = "20px";
+			toastEl.style.left = "50%";
+			toastEl.style.transform = "translateX(-50%)";
+		}
+		shadow.appendChild(toastEl);
+		toastTimer = window.setTimeout(() => {
+			toastEl.remove();
+		}, 1900);
+	}
+	function isToolbarBridgeResult(value) {
+		if (!value || typeof value !== "object") return false;
+		const candidate = value;
+		return (candidate.success === void 0 || typeof candidate.success === "boolean") && (candidate.isRecording === void 0 || typeof candidate.isRecording === "boolean") && (candidate.startedAt === void 0 || typeof candidate.startedAt === "number") && (candidate.tabId === void 0 || typeof candidate.tabId === "number") && (candidate.id === void 0 || typeof candidate.id === "string") && (candidate.path === void 0 || typeof candidate.path === "string") && (candidate.duration === void 0 || typeof candidate.duration === "number") && (candidate.size === void 0 || typeof candidate.size === "number") && (candidate.replayId === void 0 || typeof candidate.replayId === "string") && (candidate.replayPath === void 0 || typeof candidate.replayPath === "string") && (candidate.replayDuration === void 0 || typeof candidate.replayDuration === "number") && (candidate.replaySize === void 0 || typeof candidate.replaySize === "number") && (candidate.replayEventCount === void 0 || typeof candidate.replayEventCount === "number") && (candidate.warning === void 0 || typeof candidate.warning === "string") && (candidate.error === void 0 || typeof candidate.error === "string");
+	}
+	function sendToolbarBridgeRequest(type) {
+		const requestId = `playwriter-${Date.now()}-${nextBridgeRequestId++}`;
+		return new Promise((resolve, reject) => {
+			const timeout = window.setTimeout(() => {
+				window.removeEventListener("message", onResponse);
+				console.warn("[Tabwright toolbar] bridge timeout", type, requestId);
+				reject(/* @__PURE__ */ new Error(`Tabwright toolbar bridge did not respond (${type}, ${requestId})`));
+			}, 9e4);
+			function onResponse(event) {
+				const data = event.data;
+				if (!data || typeof data !== "object") return;
+				const candidate = data;
+				if (candidate.source !== "playwriter-toolbar-bridge" || candidate.type !== `${type}-result` || candidate.requestId !== requestId) return;
+				window.clearTimeout(timeout);
+				window.removeEventListener("message", onResponse);
+				if (!isToolbarBridgeResult(candidate.result)) {
+					reject(/* @__PURE__ */ new Error("Invalid Tabwright toolbar bridge response"));
+					return;
+				}
+				resolve(candidate.result);
+			}
+			window.addEventListener("message", onResponse);
+			window.postMessage({
+				source: "playwriter-toolbar",
+				type,
+				requestId
+			}, "*");
+		});
+	}
+	function updateRecordButton() {
+		recordBtn.classList.toggle("active", recordingActive);
+		recordBtn.classList.toggle("busy", recordingBusy);
+		recordBtn.setAttribute("aria-pressed", String(recordingActive));
+		recordBtn.setAttribute("aria-busy", String(recordingBusy));
+		recordBtn.setAttribute("title", recordingActive ? "Stop demonstration recording" : "Start demonstration recording");
+		recordBtn.setAttribute("aria-label", recordingActive ? "Stop Tabwright demonstration recording" : "Start Tabwright demonstration recording");
+		recordBtn.innerHTML = recordingActive ? STOP_RECORDING_SVG : RECORD_SVG;
+		updatePinButton();
+	}
+	function updatePinButton() {
+		if (!pinBtn) return;
+		pinBtn.setAttribute("aria-label", recordingActive ? "Annotate an element in this recording" : "Pin element — click any element to copy inspection code for a tabwright -e call");
+		pinBtn.setAttribute("title", recordingActive ? "Annotate element in recording" : "Pin element (click to copy inspection code)");
+	}
+	function applyRecordingResult(result) {
+		if (result.success === false) throw new Error(result.error || "Recording request failed");
+		if (typeof result.isRecording === "boolean") {
+			const wasRecording = recordingActive;
+			recordingActive = result.isRecording;
+			if (recordingActive && !wasRecording) clearAnnotationBadges();
+			if (!recordingActive && wasRecording) {
+				closeAnnotationEditor();
+				clearAnnotationBadges();
+				setPinMode(false);
+			}
+		}
+	}
+	function getOverlay() {
+		if (!overlayEl) {
+			const EDGE = "color-mix(in oklch, oklch(0.62 0.18 255) 80%, transparent)";
+			const FILL = "color-mix(in oklch, oklch(0.62 0.18 255) 8%, transparent)";
+			const container = document.createElement("div");
+			container.setAttribute("data-playwriter-overlay", "1");
+			container.style.cssText = [
+				"position:fixed",
+				"pointer-events:none",
+				"z-index:2147483646",
+				`background:${FILL}`,
+				"display:none"
+			].join(";");
+			const edgeTop = document.createElement("div");
+			edgeTop.style.cssText = `position:absolute;top:0;left:0;width:100%;height:1px;background:${EDGE};`;
+			const edgeRight = document.createElement("div");
+			edgeRight.style.cssText = `position:absolute;top:0;right:0;width:1px;height:100%;background:${EDGE};`;
+			const edgeBottom = document.createElement("div");
+			edgeBottom.style.cssText = `position:absolute;bottom:0;left:0;width:100%;height:1px;background:${EDGE};`;
+			const edgeLeft = document.createElement("div");
+			edgeLeft.style.cssText = `position:absolute;top:0;left:0;width:1px;height:100%;background:${EDGE};`;
+			container.appendChild(edgeTop);
+			container.appendChild(edgeRight);
+			container.appendChild(edgeBottom);
+			container.appendChild(edgeLeft);
+			document.documentElement.appendChild(container);
+			overlayEl = container;
+		}
+		return overlayEl;
+	}
+	function positionOverlay(target) {
+		const rect = target.getBoundingClientRect();
+		if (!rect.width && !rect.height) return;
+		const overlay = getOverlay();
+		overlay.style.display = "block";
+		overlay.style.top = rect.top + "px";
+		overlay.style.left = rect.left + "px";
+		overlay.style.width = rect.width + "px";
+		overlay.style.height = rect.height + "px";
+	}
+	function hideOverlay() {
+		if (overlayEl) overlayEl.style.display = "none";
+	}
+	function removeOverlay() {
+		if (overlayEl) {
+			overlayEl.remove();
+			overlayEl = null;
+		}
+	}
+	function getTargetAt(x, y) {
+		return document.elementsFromPoint(x, y).find((el) => !el.hasAttribute("data-playwriter-overlay") && !el.hasAttribute("data-playwriter-toolbar") && el !== document.documentElement && el !== document.body) ?? null;
+	}
+	function isOverToolbar(e) {
+		return e.composedPath().some((node) => node === host);
+	}
+	function flashElement(el) {
+		const s = el.style;
+		if (!s) return;
+		const prevOutline = s.outline;
+		const prevOffset = s.outlineOffset;
+		s.outline = "1px solid #22c55e";
+		s.outlineOffset = "2px";
+		window.setTimeout(() => {
+			s.outline = prevOutline;
+			s.outlineOffset = prevOffset;
+		}, 350);
+	}
+	function copyText(text) {
+		navigator.clipboard.writeText(text).catch(() => {
+			try {
+				const ta = document.createElement("textarea");
+				ta.value = text;
+				ta.style.cssText = "position:fixed;top:0;left:0;opacity:0;pointer-events:none;";
+				document.body.appendChild(ta);
+				ta.focus();
+				ta.select();
+				document.execCommand("copy");
+				ta.remove();
+			} catch {}
+		});
+	}
+	function shellQuote(value) {
+		return `'${value.replaceAll("'", "'\\''")}'`;
+	}
+	function replayCapabilityId(replayId) {
+		return `replay-${replayId.replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(-28) || "workflow"}`;
+	}
+	function replayMakeCommand(replayId) {
+		const capabilityId = replayCapabilityId(replayId);
+		return [
+			"tabwright replay make",
+			shellQuote(replayId),
+			shellQuote(capabilityId),
+			"--force",
+			"--goal",
+			shellQuote("<describe the batch task goal>")
+		].join(" ");
+	}
+	function replayRunCommand(replayId) {
+		const capabilityId = replayCapabilityId(replayId);
+		return [
+			"tabwright capability run",
+			shellQuote(capabilityId),
+			"--browser user",
+			"--force",
+			"--confirm",
+			shellQuote(capabilityId),
+			"--input-json",
+			shellQuote("{\"value\":\"...\"}"),
+			"--json"
+		].join(" ");
+	}
+	function replayAiHandoffText(result) {
+		const replayId = result.replayId || result.id;
+		if (!replayId) return null;
+		const path = result.replayPath || result.path;
+		return [
+			`这是 Tabwright replay id：${replayId}`,
+			`Recorded URL: ${window.location.href}`,
+			path ? `Recording path: ${path}` : "",
+			result.replayEventCount !== void 0 ? `Events: ${result.replayEventCount}` : "",
+			"",
+			"我的目标是：<描述要 AI 基于这次录制重复/批量完成什么>",
+			"",
+			"请先编译成 capability：",
+			replayMakeCommand(replayId),
+			"",
+			"这是写操作。先暂停并取得用户明确确认，确认后才可执行：",
+			replayRunCommand(replayId),
+			"",
+			"如果返回 needs_ai，请根据上下文修改脚本后继续跑。"
+		].filter((line) => {
+			return line.length > 0;
+		}).join("\n");
+	}
+	function normalizeText(value) {
+		return value.replace(/\s+/g, " ").trim();
+	}
+	function uniqueStrings(values) {
+		return Array.from(new Set(values.filter((value) => {
+			return value.length > 0;
+		})));
+	}
+	function attrSelector(name, value) {
+		return `[${name}=${JSON.stringify(value)}]`;
+	}
+	function isSimpleCssIdentifier(value) {
+		return /^[A-Za-z_-][A-Za-z0-9_-]*$/.test(value);
+	}
+	function elementText(target) {
+		const text = target instanceof HTMLElement ? normalizeText(target.innerText || target.textContent || "") : normalizeText(target.textContent || "");
+		if (!text || text.length > 180) return;
+		return text;
+	}
+	function labelForTarget(target) {
+		const direct = target.getAttribute("aria-label") || target.getAttribute("title") || target.getAttribute("placeholder") || target.getAttribute("name") || "";
+		if (direct.trim()) return normalizeText(direct);
+		const id = target.getAttribute("id");
+		if (id) {
+			const labelText = normalizeText(document.querySelector(`label[for=${JSON.stringify(id)}]`)?.textContent || "");
+			if (labelText) return labelText;
+		}
+		const closestLabelText = normalizeText(target.closest("label")?.textContent || "");
+		if (closestLabelText) return closestLabelText;
+		return elementText(target);
+	}
+	function selectorHintsForTarget(target) {
+		const tagName = target.tagName.toLowerCase();
+		const classHints = Array.from(target.classList).filter((className) => {
+			return isSimpleCssIdentifier(className) && className.length <= 80;
+		}).slice(0, 3).map((className) => {
+			return `${tagName}.${className}`;
+		});
+		const id = target.getAttribute("id") || "";
+		return uniqueStrings([
+			id ? isSimpleCssIdentifier(id) ? `#${id}` : attrSelector("id", id) : "",
+			target.getAttribute("data-testid") ? attrSelector("data-testid", target.getAttribute("data-testid") || "") : "",
+			target.getAttribute("data-test") ? attrSelector("data-test", target.getAttribute("data-test") || "") : "",
+			target.getAttribute("name") ? `${tagName}${attrSelector("name", target.getAttribute("name") || "")}` : "",
+			target.getAttribute("placeholder") ? `${tagName}${attrSelector("placeholder", target.getAttribute("placeholder") || "")}` : "",
+			target.getAttribute("aria-label") ? `${tagName}${attrSelector("aria-label", target.getAttribute("aria-label") || "")}` : "",
+			...classHints
+		]);
+	}
+	function targetLabelPreview(target) {
+		const label = labelForTarget(target);
+		if (label) return label.length > 44 ? `${label.slice(0, 43)}…` : label;
+		const selector = selectorHintsForTarget(target)[0];
+		if (selector) return selector;
+		return target.tagName.toLowerCase();
+	}
+	function summarizeTarget(target) {
+		const rect = target.getBoundingClientRect();
+		return {
+			tagName: target.tagName.toLowerCase(),
+			label: labelForTarget(target),
+			text: elementText(target),
+			role: target.getAttribute("role") || void 0,
+			name: target.getAttribute("name") || void 0,
+			placeholder: target.getAttribute("placeholder") || void 0,
+			selectorHints: selectorHintsForTarget(target),
+			rect: {
+				x: Math.round(rect.left),
+				y: Math.round(rect.top),
+				width: Math.round(rect.width),
+				height: Math.round(rect.height)
+			}
+		};
+	}
+	function getAnnotationLayer() {
+		if (!annotationLayerEl) {
+			const layer = document.createElement("div");
+			layer.setAttribute("data-playwriter-annotation-layer", "1");
+			layer.style.cssText = [
+				"position:fixed",
+				"inset:0",
+				"z-index:2147483645",
+				"pointer-events:none",
+				"font-family:ui-sans-serif,-apple-system,BlinkMacSystemFont,\"Segoe UI\",sans-serif"
+			].join(";");
+			document.documentElement.appendChild(layer);
+			annotationLayerEl = layer;
+		}
+		return annotationLayerEl;
+	}
+	function createAnnotationRegion(options) {
+		const region = document.createElement("div");
+		if (options.preview) region.setAttribute("data-playwriter-annotation-preview", "1");
+		else if (typeof options.index === "number") region.setAttribute("data-playwriter-annotation-region", String(options.index));
+		region.style.cssText = [
+			"position:fixed",
+			`border:1px solid ${options.preview ? "rgba(99,102,241,0.46)" : "rgba(99,102,241,0.32)"}`,
+			`background:${options.preview ? "rgba(99,102,241,0.075)" : "rgba(99,102,241,0.045)"}`,
+			`box-shadow:inset 0 0 0 1px rgba(255,255,255,0.45),0 0 0 2px ${options.preview ? "rgba(99,102,241,0.095)" : "rgba(99,102,241,0.055)"}`,
+			"border-radius:6px",
+			"pointer-events:none"
+		].join(";");
+		return region;
+	}
+	function positionAnnotationRegion(options) {
+		const rect = options.target.getBoundingClientRect();
+		const visible = rect.width > 0 && rect.height > 0 && rect.bottom >= 0 && rect.right >= 0;
+		options.region.style.display = visible ? "block" : "none";
+		if (!visible) return false;
+		const regionLeft = Math.max(0, rect.left);
+		const regionTop = Math.max(0, rect.top);
+		options.region.style.left = `${regionLeft}px`;
+		options.region.style.top = `${regionTop}px`;
+		options.region.style.width = `${Math.max(1, Math.min(rect.width, window.innerWidth - regionLeft))}px`;
+		options.region.style.height = `${Math.max(1, Math.min(rect.height, window.innerHeight - regionTop))}px`;
+		return true;
+	}
+	function updateAnnotationPreview() {
+		if (!annotationPreview) return;
+		positionAnnotationRegion(annotationPreview);
+	}
+	function removeAnnotationPreview() {
+		if (!annotationPreview) return;
+		annotationPreview.region.remove();
+		annotationPreview = null;
+		if (annotationMarkers.length === 0) removeAnnotationBadgeLayoutListeners();
+	}
+	function showAnnotationPreview(target) {
+		removeAnnotationPreview();
+		const region = createAnnotationRegion({ preview: true });
+		getAnnotationLayer().appendChild(region);
+		annotationPreview = {
+			target,
+			region
+		};
+		ensureAnnotationBadgeLayoutListeners();
+		updateAnnotationPreview();
+	}
+	function clampAnnotationPosition(options) {
+		return Math.max(options.min, Math.min(options.value, options.max));
+	}
+	function chooseAnnotationPlacement(options) {
+		const placements = [
+			{
+				placement: "right",
+				fits: window.innerWidth - options.rect.right - options.gap >= options.bubbleWidth,
+				score: window.innerWidth - options.rect.right
+			},
+			{
+				placement: "left",
+				fits: options.rect.left - options.gap >= options.bubbleWidth,
+				score: options.rect.left
+			},
+			{
+				placement: "bottom",
+				fits: window.innerHeight - options.rect.bottom - options.gap >= options.bubbleHeight,
+				score: window.innerHeight - options.rect.bottom
+			},
+			{
+				placement: "top",
+				fits: options.rect.top - options.gap >= options.bubbleHeight,
+				score: options.rect.top
+			}
+		];
+		const firstFit = placements.find((placement) => {
+			return placement.fits;
+		});
+		if (firstFit) return firstFit.placement;
+		return placements.reduce((best, placement) => {
+			return placement.score > best.score ? placement : best;
+		}).placement;
+	}
+	function updateAnnotationBadges() {
+		updateAnnotationPreview();
+		annotationMarkers.forEach(({ target, region, label }) => {
+			const rect = target.getBoundingClientRect();
+			const visible = positionAnnotationRegion({
+				target,
+				region
+			});
+			label.style.display = visible ? "flex" : "none";
+			if (!visible) return;
+			const padding = 8;
+			const gap = 12;
+			const bubbleWidth = label.offsetWidth || 240;
+			const bubbleHeight = label.offsetHeight || 34;
+			const placement = chooseAnnotationPlacement({
+				rect,
+				bubbleWidth,
+				bubbleHeight,
+				gap
+			});
+			const targetCenterX = rect.left + rect.width / 2;
+			const targetCenterY = rect.top + rect.height / 2;
+			const maxLeft = Math.max(padding, window.innerWidth - bubbleWidth - padding);
+			const maxTop = Math.max(padding, window.innerHeight - bubbleHeight - padding);
+			const position = (() => {
+				if (placement === "right") return {
+					left: clampAnnotationPosition({
+						value: rect.right + gap,
+						min: padding,
+						max: maxLeft
+					}),
+					top: clampAnnotationPosition({
+						value: targetCenterY - bubbleHeight / 2,
+						min: padding,
+						max: maxTop
+					})
+				};
+				if (placement === "left") return {
+					left: clampAnnotationPosition({
+						value: rect.left - gap - bubbleWidth,
+						min: padding,
+						max: maxLeft
+					}),
+					top: clampAnnotationPosition({
+						value: targetCenterY - bubbleHeight / 2,
+						min: padding,
+						max: maxTop
+					})
+				};
+				if (placement === "bottom") return {
+					left: clampAnnotationPosition({
+						value: targetCenterX - bubbleWidth / 2,
+						min: padding,
+						max: maxLeft
+					}),
+					top: clampAnnotationPosition({
+						value: rect.bottom + gap,
+						min: padding,
+						max: maxTop
+					})
+				};
+				return {
+					left: clampAnnotationPosition({
+						value: targetCenterX - bubbleWidth / 2,
+						min: padding,
+						max: maxLeft
+					}),
+					top: clampAnnotationPosition({
+						value: rect.top - gap - bubbleHeight,
+						min: padding,
+						max: maxTop
+					})
+				};
+			})();
+			label.style.left = `${position.left}px`;
+			label.style.top = `${position.top}px`;
+		});
+	}
+	function ensureAnnotationBadgeLayoutListeners() {
+		if (annotationLayoutListening) return;
+		annotationLayoutListening = true;
+		window.addEventListener("resize", updateAnnotationBadges, true);
+		document.addEventListener("scroll", updateAnnotationBadges, true);
+	}
+	function removeAnnotationBadgeLayoutListeners() {
+		if (!annotationLayoutListening) return;
+		annotationLayoutListening = false;
+		window.removeEventListener("resize", updateAnnotationBadges, true);
+		document.removeEventListener("scroll", updateAnnotationBadges, true);
+	}
+	function removeAnnotationMarker(options) {
+		const markerIndex = annotationMarkers.findIndex((marker) => {
+			return marker.id === options.id;
+		});
+		if (markerIndex < 0) return;
+		const marker = annotationMarkers[markerIndex];
+		if (!marker) return;
+		annotationMarkers.splice(markerIndex, 1);
+		marker.region.remove();
+		marker.label.remove();
+		if (options.emitDelete) postAnnotationDeleteEvent({ id: options.id });
+		if (annotationMarkers.length === 0 && !annotationPreview) {
+			removeAnnotationBadgeLayoutListeners();
+			annotationLayerEl?.remove();
+			annotationLayerEl = null;
+		}
+	}
+	function createAnnotationBadge(options) {
+		const region = createAnnotationRegion({
+			index: options.index,
+			preview: false
+		});
+		const label = document.createElement("div");
+		label.setAttribute("data-playwriter-annotation-badge", String(options.index));
+		label.setAttribute("data-playwriter-annotation-id", options.id);
+		label.setAttribute("data-playwriter-annotation-text", options.text);
+		label.title = options.text;
+		label.style.cssText = [
+			"position:fixed",
+			"align-items:center",
+			"gap:6px",
+			"max-width:min(300px,calc(100vw - 16px))",
+			"min-height:28px",
+			"padding:5px 10px 5px 6px",
+			"border:1px solid rgba(99,102,241,0.2)",
+			"border-radius:10px",
+			"background:rgba(255,255,255,0.9)",
+			"color:#312e81",
+			"font-size:12px",
+			"font-weight:560",
+			"line-height:1.25",
+			"box-shadow:0 10px 28px rgba(15,23,42,0.13),0 1px 3px rgba(49,46,129,0.1)",
+			"backdrop-filter:blur(10px)",
+			"opacity:0.92",
+			"pointer-events:auto",
+			"cursor:default"
+		].join(";");
+		const number = document.createElement("span");
+		number.textContent = String(options.index);
+		number.style.cssText = [
+			"display:inline-flex",
+			"align-items:center",
+			"justify-content:center",
+			"width:17px",
+			"height:17px",
+			"border-radius:5px",
+			"background:rgba(79,70,229,0.9)",
+			"color:#fff",
+			"font-size:10px",
+			"font-weight:750",
+			"line-height:1",
+			"flex:0 0 auto"
+		].join(";");
+		const text = document.createElement("span");
+		text.textContent = options.text;
+		text.style.cssText = [
+			"display:block",
+			"overflow:hidden",
+			"text-overflow:ellipsis",
+			"white-space:nowrap",
+			"letter-spacing:0"
+		].join(";");
+		const deleteButton = document.createElement("button");
+		deleteButton.type = "button";
+		deleteButton.textContent = "×";
+		deleteButton.setAttribute("aria-label", `Delete annotation ${options.index}`);
+		deleteButton.title = "Delete annotation";
+		deleteButton.style.cssText = [
+			"display:inline-flex",
+			"align-items:center",
+			"justify-content:center",
+			"width:18px",
+			"height:18px",
+			"margin-left:2px",
+			"border:0",
+			"border-radius:6px",
+			"background:rgba(49,46,129,0.08)",
+			"color:#4338ca",
+			"font-size:14px",
+			"font-weight:700",
+			"line-height:1",
+			"opacity:0",
+			"cursor:pointer",
+			"transition:opacity 0.12s ease,background 0.12s ease,color 0.12s ease",
+			"pointer-events:auto",
+			"flex:0 0 auto"
+		].join(";");
+		label.addEventListener("mouseenter", () => {
+			deleteButton.style.opacity = "1";
+		});
+		label.addEventListener("mouseleave", () => {
+			deleteButton.style.opacity = "0";
+		});
+		label.addEventListener("mousedown", (event) => {
+			event.preventDefault();
+			event.stopPropagation();
+		});
+		label.addEventListener("click", (event) => {
+			event.preventDefault();
+			event.stopPropagation();
+		});
+		deleteButton.addEventListener("mouseenter", () => {
+			deleteButton.style.background = "rgba(239,68,68,0.12)";
+			deleteButton.style.color = "#dc2626";
+		});
+		deleteButton.addEventListener("mouseleave", () => {
+			deleteButton.style.background = "rgba(49,46,129,0.08)";
+			deleteButton.style.color = "#4338ca";
+		});
+		deleteButton.addEventListener("mousedown", (event) => {
+			event.preventDefault();
+			event.stopPropagation();
+		});
+		deleteButton.addEventListener("click", (event) => {
+			event.preventDefault();
+			event.stopPropagation();
+			removeAnnotationMarker({
+				id: options.id,
+				emitDelete: true
+			});
+			showToast("Annotation deleted", label.getBoundingClientRect());
+		});
+		label.appendChild(number);
+		label.appendChild(text);
+		label.appendChild(deleteButton);
+		const layer = getAnnotationLayer();
+		layer.appendChild(region);
+		layer.appendChild(label);
+		annotationMarkers.push({
+			id: options.id,
+			target: options.target,
+			region,
+			label
+		});
+		ensureAnnotationBadgeLayoutListeners();
+		updateAnnotationBadges();
+	}
+	function clearAnnotationBadges() {
+		removeAnnotationPreview();
+		annotationMarkers.splice(0).forEach(({ region, label }) => {
+			region.remove();
+			label.remove();
+		});
+		removeAnnotationBadgeLayoutListeners();
+		annotationLayerEl?.remove();
+		annotationLayerEl = null;
+		annotationCount = 0;
+	}
+	function closeAnnotationEditor() {
+		if (annotationEditorEl) {
+			annotationEditorEl.remove();
+			annotationEditorEl = null;
+		}
+		removeAnnotationPreview();
+	}
+	function postAnnotationEvent(options) {
+		const annotation = {
+			schemaVersion: 1,
+			id: options.id,
+			text: options.text,
+			url: location.href,
+			timestamp: Date.now(),
+			target: summarizeTarget(options.target)
+		};
+		window.postMessage({
+			source: "playwriter-toolbar",
+			type: "recording-annotation",
+			annotation
+		}, "*");
+	}
+	function postAnnotationDeleteEvent(options) {
+		window.postMessage({
+			source: "playwriter-toolbar",
+			type: "recording-annotation-delete",
+			annotation: {
+				schemaVersion: 1,
+				id: options.id,
+				url: location.href,
+				timestamp: Date.now()
+			}
+		}, "*");
+	}
+	function showAnnotationEditor(target, anchorRect) {
+		closeAnnotationEditor();
+		showAnnotationPreview(target);
+		const popover = document.createElement("div");
+		popover.className = "annotation-popover";
+		popover.addEventListener("click", (event) => {
+			event.stopPropagation();
+		});
+		popover.addEventListener("mousedown", (event) => {
+			event.stopPropagation();
+		});
+		const titleRow = document.createElement("div");
+		titleRow.className = "annotation-title";
+		const title = document.createElement("span");
+		title.textContent = "Add annotation";
+		const targetText = document.createElement("span");
+		targetText.className = "annotation-target";
+		targetText.textContent = targetLabelPreview(target);
+		const input = document.createElement("textarea");
+		input.className = "annotation-input";
+		input.placeholder = "What should AI remember here?";
+		const actions = document.createElement("div");
+		actions.className = "annotation-actions";
+		const cancel = document.createElement("button");
+		cancel.type = "button";
+		cancel.className = "annotation-action";
+		cancel.textContent = "Cancel";
+		const save = document.createElement("button");
+		save.type = "button";
+		save.className = "annotation-action primary";
+		save.textContent = "Save";
+		function saveAnnotation() {
+			const text = normalizeText(input.value);
+			if (!text) {
+				input.focus();
+				return;
+			}
+			annotationCount += 1;
+			const id = `ann-${Date.now()}-${annotationCount}`;
+			createAnnotationBadge({
+				id,
+				target,
+				text,
+				index: annotationCount
+			});
+			postAnnotationEvent({
+				id,
+				target,
+				text,
+				index: annotationCount
+			});
+			closeAnnotationEditor();
+			showToast("Annotation saved", anchorRect);
+		}
+		cancel.addEventListener("click", () => {
+			closeAnnotationEditor();
+		});
+		save.addEventListener("click", () => {
+			saveAnnotation();
+		});
+		input.addEventListener("keydown", (event) => {
+			if (event.key === "Escape") {
+				event.preventDefault();
+				closeAnnotationEditor();
+				return;
+			}
+			if (event.key === "Enter" && (event.metaKey || event.ctrlKey)) {
+				event.preventDefault();
+				saveAnnotation();
+			}
+		});
+		titleRow.appendChild(title);
+		titleRow.appendChild(targetText);
+		actions.appendChild(cancel);
+		actions.appendChild(save);
+		popover.appendChild(titleRow);
+		popover.appendChild(input);
+		popover.appendChild(actions);
+		const GAP = 10;
+		const preferredLeft = anchorRect.left;
+		const preferredTop = anchorRect.bottom + GAP;
+		const width = Math.min(360, window.innerWidth - 24);
+		const left = Math.max(12, Math.min(preferredLeft, window.innerWidth - width - 12));
+		const top = preferredTop + 160 < window.innerHeight ? preferredTop : Math.max(12, anchorRect.top - 170);
+		popover.style.left = `${left}px`;
+		popover.style.top = `${top}px`;
+		shadow.appendChild(popover);
+		annotationEditorEl = popover;
+		window.setTimeout(() => {
+			input.focus();
+		}, 0);
+	}
+	function allocatePinName() {
+		const shared = window.__playwriterPinCount;
+		if (typeof shared === "number" && shared > pinCount) pinCount = shared;
+		pinCount++;
+		window.__playwriterPinCount = pinCount;
+		return `playwriterPinnedElem${pinCount}`;
+	}
+	function onMouseMove(e) {
+		if (isOverToolbar(e)) {
+			hideOverlay();
+			return;
+		}
+		const target = getTargetAt(e.clientX, e.clientY);
+		if (target) positionOverlay(target);
+		else hideOverlay();
+	}
+	function buildInspectionCode(n, url) {
+		return `inspectPinnedElement(${JSON.stringify(url).replace(/'/g, "\\u0027")},"globalThis.playwriterPinnedElem${n}")`;
+	}
+	function onClick(e) {
+		if (isOverToolbar(e)) return;
+		e.preventDefault();
+		e.stopImmediatePropagation();
+		const target = getTargetAt(e.clientX, e.clientY);
+		if (!target) return;
+		if (recordingActive) {
+			const rect = target.getBoundingClientRect();
+			setPinMode(false);
+			showAnnotationEditor(target, rect);
+			return;
+		}
+		const name = allocatePinName();
+		const n = pinCount;
+		window[name] = target;
+		flashElement(target);
+		const url = location.href;
+		copyText("tabwright -e '" + buildInspectionCode(n, url) + "'");
+		showToast("Copied Tabwright element reference, use it in your agent prompt", target.getBoundingClientRect());
+		setPinMode(false);
+	}
+	function onKeyDown(e) {
+		if (e.key === "Escape") setPinMode(false);
+	}
+	function setPinMode(on) {
+		pinModeActive = on;
+		pinBtn.classList.toggle("active", on);
+		if (on) {
+			document.documentElement.style.cursor = "crosshair";
+			getOverlay();
+			document.addEventListener("mousemove", onMouseMove, {
+				capture: true,
+				passive: true
+			});
+			document.addEventListener("click", onClick, true);
+			document.addEventListener("keydown", onKeyDown, true);
+		} else {
+			document.documentElement.style.cursor = "";
+			hideOverlay();
+			document.removeEventListener("mousemove", onMouseMove, true);
+			document.removeEventListener("click", onClick, true);
+			document.removeEventListener("keydown", onKeyDown, true);
+		}
+	}
+	const CLIPBOARD_SVG = `<svg xmlns="http://www.w3.org/2000/svg" width="18" height="18" fill="none" viewBox="0 0 424 424" aria-hidden="true"><path d="M 0 212 C 0 112.063 0 62.095 31.037 31.037 C 62.116 0 112.063 0 212 0 C 311.937 0 361.905 0 392.942 31.037 C 424 62.116 424 112.063 424 212 C 424 311.937 424 361.905 392.942 392.942 C 361.926 424 311.937 424 212 424 C 112.063 424 62.095 424 31.037 392.942 C 0 361.926 0 311.937 0 212" fill="currentColor"/><path class="logo-inner" d="M 225.732 260.521 L 277.905 312.673 C 283.311 318.1 286.003 320.793 289.014 322.043 C 293.042 323.718 297.557 323.718 301.585 322.043 C 304.596 320.793 307.309 318.1 312.694 312.694 C 318.1 307.288 320.793 304.596 322.043 301.585 C 323.722 297.563 323.722 293.036 322.043 289.014 C 320.793 286.003 318.1 283.29 312.694 277.905 L 260.521 225.732 L 276.442 209.789 C 292.766 193.465 300.907 185.325 298.999 176.548 C 297.07 167.792 286.237 163.785 264.591 155.814 L 192.384 129.208 C 149.2 113.308 127.618 105.358 116.488 116.488 C 105.358 127.618 113.308 149.2 129.208 192.384 L 155.814 264.591 C 163.785 286.237 167.792 297.07 176.548 298.999 C 185.303 300.928 193.465 292.766 209.789 276.442 Z" fill="white"/></svg>`;
+	const RECORD_SVG = `<svg xmlns="http://www.w3.org/2000/svg" width="13" height="13" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true"><circle cx="12" cy="12" r="7"/></svg>`;
+	const STOP_RECORDING_SVG = `<svg xmlns="http://www.w3.org/2000/svg" width="13" height="13" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true"><rect x="7" y="7" width="10" height="10" rx="1.5"/></svg>`;
+	const CLOSE_SVG = `<svg xmlns="http://www.w3.org/2000/svg" width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/></svg>`;
+	pinBtn = document.createElement("button");
+	pinBtn.className = "btn";
+	pinBtn.setAttribute("aria-label", "Pin element — click any element to copy inspection code for a tabwright -e call");
+	pinBtn.setAttribute("title", "Pin element (click to copy inspection code)");
+	pinBtn.innerHTML = CLIPBOARD_SVG;
+	pinBtn.addEventListener("click", (e) => {
+		e.stopPropagation();
+		setPinMode(!pinModeActive);
+	});
+	recordBtn = document.createElement("button");
+	recordBtn.className = "btn recording";
+	recordBtn.setAttribute("aria-pressed", "false");
+	recordBtn.innerHTML = RECORD_SVG;
+	recordBtn.addEventListener("click", (e) => {
+		e.stopPropagation();
+		if (recordingBusy) return;
+		recordingBusy = true;
+		updateRecordButton();
+		sendToolbarBridgeRequest("recording-toggle").then((result) => {
+			applyRecordingResult(result);
+			if (recordingActive) {
+				showToast("Recording started", recordBtn.getBoundingClientRect());
+				return;
+			}
+			const handoffText = replayAiHandoffText(result);
+			if (handoffText) {
+				copyText(handoffText);
+				showToast("Recording saved · copied for AI", recordBtn.getBoundingClientRect());
+				return;
+			}
+			showToast(`Recording saved${result.path ? `: ${result.path}` : ""}`, recordBtn.getBoundingClientRect());
+		}).catch((error) => {
+			showToast(error instanceof Error ? error.message : String(error), recordBtn.getBoundingClientRect());
+		}).finally(() => {
+			recordingBusy = false;
+			updateRecordButton();
+		});
+	});
+	updateRecordButton();
+	const dividerEl = document.createElement("div");
+	dividerEl.className = "divider";
+	dividerEl.setAttribute("aria-hidden", "true");
+	const closeBtn = document.createElement("button");
+	closeBtn.className = "btn";
+	closeBtn.setAttribute("aria-label", "Close Tabwright toolbar");
+	closeBtn.setAttribute("title", "Close toolbar");
+	closeBtn.innerHTML = CLOSE_SVG;
+	closeBtn.addEventListener("click", (e) => {
+		e.stopPropagation();
+		setPinMode(false);
+		closeAnnotationEditor();
+		clearAnnotationBadges();
+		host.style.display = "none";
+	});
+	toolbarEl.appendChild(pinBtn);
+	toolbarEl.appendChild(recordBtn);
+	toolbarEl.appendChild(dividerEl);
+	toolbarEl.appendChild(closeBtn);
+	document.documentElement.appendChild(host);
+	window.__playwriterToolbarDestroy = function() {
+		setPinMode(false);
+		closeAnnotationEditor();
+		clearAnnotationBadges();
+		removeOverlay();
+		host.remove();
+		delete window.__playwriterToolbarInstalled;
+		delete window.__playwriterToolbarDestroy;
+		delete window.__playwriterPinCount;
+	};
+	sendToolbarBridgeRequest("recording-status").then((result) => {
+		applyRecordingResult(result);
+		updateRecordButton();
+	}).catch(() => {});
+}
+var CURRENT_EXTENSION_FEATURES = Object.values({
+	heartbeat: "heartbeat-v1",
+	createInitialTab: "create-initial-tab-v1",
+	rrwebRecording: "rrweb-recording-v1",
+	toolbarRecording: "toolbar-recording-v1",
+	multiExtension: "multi-extension-v1"
+});
+var RELAY_FEATURE = {
+	extensionFeatureNegotiation: "extension-feature-negotiation-v1",
+	capabilityOptions: "capability-options-v1",
+	capabilityAuth: "capability-auth-v1",
+	capabilityAuthAutoTab: "capability-auth-auto-tab-v1",
+	rrwebRecording: "rrweb-recording-v1",
+	multiExtension: "multi-extension-v1"
+};
+Object.values(RELAY_FEATURE);
+RELAY_FEATURE.capabilityOptions, RELAY_FEATURE.capabilityAuth, RELAY_FEATURE.capabilityAuthAutoTab, RELAY_FEATURE.rrwebRecording;
+//#endregion
+//#region ../tabwright/src/ghost-browser.ts
+/**
+* Handles ghost-browser commands in the extension.
+* Calls the appropriate chrome.* API and returns the result.
+*
+* @param params - Command parameters (namespace, method, args)
+* @param chromeApi - The chrome object (passed to avoid global dependency)
+* @returns Result object with success/error status
+*/
+async function handleGhostBrowserCommand(params, chromeApi) {
+	const { namespace, method, args } = params;
+	try {
+		const api = chromeApi[namespace];
+		if (!api) return {
+			success: false,
+			error: `chrome.${namespace} not available (not running in Ghost Browser?)`
+		};
+		const fn = api[method];
+		if (typeof fn !== "function") {
+			if (method in api) return {
+				success: true,
+				result: api[method]
+			};
+			return {
+				success: false,
+				error: `chrome.${namespace}.${method} is not a function or property`
+			};
+		}
+		return {
+			success: true,
+			result: await new Promise((resolve, reject) => {
+				fn.call(api, ...args, (result) => {
+					if (chromeApi.runtime.lastError) reject(new Error(chromeApi.runtime.lastError.message));
+					else resolve(result);
+				});
+			})
+		};
+	} catch (error) {
+		return {
+			success: false,
+			error: error.message
+		};
+	}
+}
+//#endregion
+//#region src/relay-warning.ts
+var RELAY_RECOVERY_COMMAND = "npm install -g tabwright@latest\ntabwright session list";
+function getRelayReviewIssue(options) {
+	if (options.statuses.some((status) => status === 404)) return "outdated";
+	if (options.statuses.some((status) => status < 200 || status >= 400)) return "unavailable";
+}
+function relayReviewIssueText(options) {
+	if (options.issue === "outdated") return `Browser control is connected, but this Tabwright local service cannot list saved recordings or capabilities. Your files were not deleted. Restart or update the Tabwright CLI.\n\nRun:\n${RELAY_RECOVERY_COMMAND}`;
+	return `Browser control is connected, but saved recordings and capabilities are temporarily unavailable. Your files were not deleted. Restart the Tabwright CLI.\n\nRun:\n${RELAY_RECOVERY_COMMAND}`;
+}
+function relayIssueText(options) {
+	if (options.issue === "outdated") return `Tabwright local service is outdated. Restart or update the Tabwright CLI.\n\nRun:\n${RELAY_RECOVERY_COMMAND}`;
+	if (options.issue === "unavailable") return `Tabwright local service is not responding correctly. Restart or update the Tabwright CLI.\n\nRun:\n${RELAY_RECOVERY_COMMAND}`;
+	return `Tabwright local service is not running. Start or update the Tabwright CLI.\n\nRun:\n${RELAY_RECOVERY_COMMAND}`;
+}
+var RelayConnectionProblemError = class extends Error {
+	issue;
+	constructor(options) {
+		const errorOptions = options.cause instanceof Error ? { cause: options.cause } : void 0;
+		super(relayIssueText({ issue: options.issue }), errorOptions);
+		this.name = "RelayConnectionProblemError";
+		this.issue = options.issue;
+	}
+};
+//#endregion
+//#region src/connection-ownership.ts
+var ConnectionOwnership = class {
+	currentGeneration = 0;
+	current = null;
+	beginAttempt() {
+		this.currentGeneration += 1;
+		return this.currentGeneration;
+	}
+	invalidateAttempt(generation) {
+		if (generation !== this.currentGeneration) return false;
+		this.currentGeneration += 1;
+		return true;
+	}
+	isCurrentAttempt(generation) {
+		return generation === this.currentGeneration;
+	}
+	claimOpenedConnection(options) {
+		if (!this.isCurrentAttempt(options.generation)) return false;
+		this.current = options.connection;
+		return true;
+	}
+	isCurrentConnection(connection) {
+		return this.current === connection;
+	}
+	releaseConnection(connection) {
+		if (!this.isCurrentConnection(connection)) return false;
+		this.current = null;
+		return true;
+	}
+};
+//#endregion
+//#region ../tabwright/dist/ghost-cursor-client.js?raw
+var ghost_cursor_client_default = "(() => {\n  var __defProp = Object.defineProperty;\n  var __getOwnPropNames = Object.getOwnPropertyNames;\n  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;\n  var __hasOwnProp = Object.prototype.hasOwnProperty;\n  function __accessProp(key) {\n    return this[key];\n  }\n  var __toCommonJS = (from) => {\n    var entry = (__moduleCache ??= new WeakMap).get(from), desc;\n    if (entry)\n      return entry;\n    entry = __defProp({}, \"__esModule\", { value: true });\n    if (from && typeof from === \"object\" || typeof from === \"function\") {\n      for (var key of __getOwnPropNames(from))\n        if (!__hasOwnProp.call(entry, key))\n          __defProp(entry, key, {\n            get: __accessProp.bind(from, key),\n            enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable\n          });\n    }\n    __moduleCache.set(from, entry);\n    return entry;\n  };\n  var __moduleCache;\n\n  // src/ghost-cursor-client.ts\n  var exports_ghost_cursor_client = {};\n\n  // src/assets/cursors/screen-studio/pointer-macos-tahoe-data-url.ts\n  var SCREENSTUDIO_POINTER_MACOS_TAHOE_DATA_URL = \"data:image/svg+xml;base64,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\";\n\n  // src/ghost-cursor-client.ts\n  var isTopFrame = (() => {\n    try {\n      return window === window.top;\n    } catch {\n      return false;\n    }\n  })();\n  var CURSOR_ID = \"__playwriter_ghost_cursor__\";\n  var SCREENSTUDIO_POINTER_ASPECT_RATIO = 618 / 958;\n  var SCREENSTUDIO_HOTSPOT_X_RATIO = 0.14;\n  var SCREENSTUDIO_HOTSPOT_Y_RATIO = 0.06;\n  var MINIMAL_TRIANGLE_HOTSPOT_X_RATIO = 0.07;\n  var MINIMAL_TRIANGLE_HOTSPOT_Y_RATIO = 0.06;\n  var MOVE_EASING = \"cubic-bezier(0.65, 0, 0.35, 1)\";\n  var PRESS_EASING = \"cubic-bezier(0.23, 1, 0.32, 1)\";\n  var PRESS_DURATION_MS = 140;\n  var IDLE_HIDE_DELAY_MS = 5000;\n  var IDLE_FADE_OUT_MS = 600;\n  var DEFAULT_OPTIONS = {\n    style: \"minimal\",\n    color: \"#111827\",\n    size: 22,\n    zIndex: 2147483647,\n    easing: MOVE_EASING,\n    minDurationMs: 220,\n    maxDurationMs: 1500,\n    speedPxPerMs: 1.2\n  };\n  var runtime = {\n    outerElement: null,\n    innerElement: null,\n    options: DEFAULT_OPTIONS,\n    x: 0,\n    y: 0,\n    scale: 1,\n    hasPosition: false,\n    enabled: false,\n    idleHidden: false\n  };\n  var idleHideTimer = null;\n  function clamp(options) {\n    const { value, min, max } = options;\n    return Math.min(max, Math.max(min, value));\n  }\n  function mergeOptions(options) {\n    if (!options) {\n      return DEFAULT_OPTIONS;\n    }\n    return {\n      style: options.style ?? DEFAULT_OPTIONS.style,\n      color: options.color ?? DEFAULT_OPTIONS.color,\n      size: options.size ?? DEFAULT_OPTIONS.size,\n      zIndex: options.zIndex ?? DEFAULT_OPTIONS.zIndex,\n      easing: options.easing ?? DEFAULT_OPTIONS.easing,\n      minDurationMs: options.minDurationMs ?? DEFAULT_OPTIONS.minDurationMs,\n      maxDurationMs: options.maxDurationMs ?? DEFAULT_OPTIONS.maxDurationMs,\n      speedPxPerMs: options.speedPxPerMs ?? DEFAULT_OPTIONS.speedPxPerMs\n    };\n  }\n  function getCursorDimensions() {\n    if (runtime.options.style === \"screenstudio\") {\n      const height = runtime.options.size;\n      const width = Math.max(10, Math.round(height * SCREENSTUDIO_POINTER_ASPECT_RATIO));\n      return { width, height };\n    }\n    if (runtime.options.style === \"minimal\") {\n      const size = Math.max(12, runtime.options.size);\n      return { width: size, height: size };\n    }\n    return { width: runtime.options.size, height: runtime.options.size };\n  }\n  function getHotspotOffsetPx() {\n    const dimensions = getCursorDimensions();\n    if (runtime.options.style === \"screenstudio\") {\n      return {\n        x: Math.round(dimensions.width * SCREENSTUDIO_HOTSPOT_X_RATIO),\n        y: Math.round(dimensions.height * SCREENSTUDIO_HOTSPOT_Y_RATIO)\n      };\n    }\n    if (runtime.options.style === \"minimal\") {\n      return {\n        x: Math.round(dimensions.width * MINIMAL_TRIANGLE_HOTSPOT_X_RATIO),\n        y: Math.round(dimensions.height * MINIMAL_TRIANGLE_HOTSPOT_Y_RATIO)\n      };\n    }\n    return {\n      x: Math.round(dimensions.width / 2),\n      y: Math.round(dimensions.height / 2)\n    };\n  }\n  function getBaseOpacity() {\n    if (runtime.options.style === \"screenstudio\") {\n      return \"0.95\";\n    }\n    if (runtime.options.style === \"minimal\") {\n      return \"1\";\n    }\n    return \"0.72\";\n  }\n  function applyTranslate() {\n    if (!runtime.outerElement) {\n      return;\n    }\n    const hotspot = getHotspotOffsetPx();\n    runtime.outerElement.style.transform = `translate3d(${runtime.x - hotspot.x}px, ${runtime.y - hotspot.y}px, 0)`;\n  }\n  function applyScale() {\n    if (!runtime.innerElement) {\n      return;\n    }\n    runtime.innerElement.style.transform = `scale(${runtime.scale})`;\n  }\n  function computeDurationMs(options) {\n    if (!runtime.hasPosition) {\n      return 0;\n    }\n    const dx = options.targetX - runtime.x;\n    const dy = options.targetY - runtime.y;\n    const distance = Math.hypot(dx, dy);\n    const rawDurationMs = distance / runtime.options.speedPxPerMs;\n    return clamp({\n      value: rawDurationMs,\n      min: runtime.options.minDurationMs,\n      max: runtime.options.maxDurationMs\n    });\n  }\n  function createCursorElement() {\n    const outer = document.createElement(\"div\");\n    outer.id = CURSOR_ID;\n    outer.setAttribute(\"aria-hidden\", \"true\");\n    outer.style.position = \"fixed\";\n    outer.style.left = \"0\";\n    outer.style.top = \"0\";\n    outer.style.pointerEvents = \"none\";\n    outer.style.zIndex = `${runtime.options.zIndex}`;\n    outer.style.transitionProperty = \"transform\";\n    outer.style.transitionTimingFunction = runtime.options.easing;\n    outer.style.transitionDuration = \"0ms\";\n    outer.style.willChange = \"transform\";\n    const inner = document.createElement(\"div\");\n    inner.style.transitionProperty = \"transform, opacity\";\n    inner.style.transitionTimingFunction = PRESS_EASING;\n    inner.style.transitionDuration = `${PRESS_DURATION_MS}ms`;\n    inner.style.opacity = getBaseOpacity();\n    outer.appendChild(inner);\n    runtime.outerElement = outer;\n    runtime.innerElement = inner;\n    applyRuntimeVisualOptions();\n    return outer;\n  }\n  function ensureCursorElement() {\n    const existing = document.getElementById(CURSOR_ID);\n    if (existing) {\n      runtime.outerElement = existing;\n      runtime.innerElement = existing.firstElementChild || null;\n      return existing;\n    }\n    const outer = createCursorElement();\n    const root = document.documentElement || document.body;\n    root.appendChild(outer);\n    return outer;\n  }\n  function applyRuntimeVisualOptions() {\n    if (!runtime.innerElement) {\n      return;\n    }\n    const dimensions = getCursorDimensions();\n    runtime.innerElement.style.width = `${dimensions.width}px`;\n    runtime.innerElement.style.height = `${dimensions.height}px`;\n    if (runtime.outerElement) {\n      runtime.outerElement.style.zIndex = `${runtime.options.zIndex}`;\n      runtime.outerElement.style.transitionTimingFunction = runtime.options.easing;\n    }\n    const hotspot = getHotspotOffsetPx();\n    runtime.innerElement.style.transformOrigin = `${hotspot.x}px ${hotspot.y}px`;\n    if (runtime.options.style === \"screenstudio\") {\n      runtime.innerElement.style.borderRadius = \"0\";\n      runtime.innerElement.style.border = \"none\";\n      runtime.innerElement.style.backgroundColor = \"transparent\";\n      runtime.innerElement.style.backgroundImage = `url(\"${SCREENSTUDIO_POINTER_MACOS_TAHOE_DATA_URL}\")`;\n      runtime.innerElement.style.backgroundRepeat = \"no-repeat\";\n      runtime.innerElement.style.backgroundPosition = \"left top\";\n      runtime.innerElement.style.backgroundSize = \"contain\";\n      runtime.innerElement.style.backdropFilter = \"none\";\n      runtime.innerElement.style.filter = \"none\";\n      runtime.innerElement.style.boxShadow = \"none\";\n      runtime.innerElement.style.opacity = getBaseOpacity();\n      return;\n    }\n    if (runtime.options.style === \"minimal\") {\n      const triangleSvg = `<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"32\" height=\"32\" viewBox=\"-1 -1 26 26\"><path fill=\"white\" stroke=\"${runtime.options.color}\" stroke-width=\"1.5\" stroke-linejoin=\"round\" d=\"m23.284 19.124l-6.866-6.895a.4.4 0 0 1-.118-.296a.43.43 0 0 1 .163-.282l4.439-3.077a1.48 1.48 0 0 0 .621-1.48a1.48 1.48 0 0 0-1.036-1.198L1.623.302a1.14 1.14 0 0 0-1.11.282A1.13 1.13 0 0 0 .29 1.649L5.928 20.44a1.48 1.48 0 0 0 1.183 1.035a1.48 1.48 0 0 0 1.48-.621l3.078-4.44a.37.37 0 0 1 .31-.118a.43.43 0 0 1 .296.104l6.91 6.91a1.48 1.48 0 0 0 2.087 0l2.086-2.086a1.48 1.48 0 0 0-.074-2.101\"/></svg>`;\n      const triangleDataUrl = `url(\"data:image/svg+xml,${encodeURIComponent(triangleSvg)}\")`;\n      runtime.innerElement.style.borderRadius = \"0\";\n      runtime.innerElement.style.border = \"none\";\n      runtime.innerElement.style.backgroundColor = \"transparent\";\n      runtime.innerElement.style.backgroundImage = triangleDataUrl;\n      runtime.innerElement.style.backgroundRepeat = \"no-repeat\";\n      runtime.innerElement.style.backgroundSize = \"contain\";\n      runtime.innerElement.style.backgroundPosition = \"left top\";\n      runtime.innerElement.style.backdropFilter = \"none\";\n      runtime.innerElement.style.boxShadow = \"none\";\n      runtime.innerElement.style.filter = \"drop-shadow(0 1px 2px rgba(0, 0, 0, 0.4))\";\n      runtime.innerElement.style.opacity = getBaseOpacity();\n      return;\n    }\n    runtime.innerElement.style.borderRadius = \"999px\";\n    runtime.innerElement.style.border = \"none\";\n    runtime.innerElement.style.backgroundColor = runtime.options.color;\n    runtime.innerElement.style.backgroundImage = \"none\";\n    runtime.innerElement.style.backdropFilter = \"none\";\n    runtime.innerElement.style.filter = \"none\";\n    runtime.innerElement.style.boxShadow = \"0 2px 10px rgba(0, 0, 0, 0.18), inset 0 0 0 2px rgba(255, 255, 255, 0.55)\";\n    runtime.innerElement.style.opacity = getBaseOpacity();\n  }\n  function clearIdleHideTimer() {\n    if (idleHideTimer !== null) {\n      clearTimeout(idleHideTimer);\n      idleHideTimer = null;\n    }\n  }\n  function scheduleIdleHide() {\n    clearIdleHideTimer();\n    idleHideTimer = setTimeout(() => {\n      idleHideTimer = null;\n      if (!runtime.enabled || !runtime.innerElement) {\n        return;\n      }\n      runtime.idleHidden = true;\n      runtime.innerElement.style.transitionDuration = `${IDLE_FADE_OUT_MS}ms`;\n      runtime.innerElement.style.transitionTimingFunction = PRESS_EASING;\n      runtime.innerElement.style.opacity = \"0\";\n    }, IDLE_HIDE_DELAY_MS);\n  }\n  function wakeFromIdle(options) {\n    runtime.x = options.x;\n    runtime.y = options.y;\n    runtime.hasPosition = true;\n    if (runtime.innerElement) {\n      runtime.innerElement.style.transitionDuration = `${PRESS_DURATION_MS}ms`;\n      runtime.innerElement.style.transitionTimingFunction = PRESS_EASING;\n      runtime.innerElement.style.opacity = getBaseOpacity();\n    }\n  }\n  function moveCursor(options) {\n    if (!runtime.enabled) {\n      return;\n    }\n    ensureCursorElement();\n    const durationMs = computeDurationMs({ targetX: options.x, targetY: options.y });\n    if (runtime.outerElement) {\n      runtime.outerElement.style.transitionDuration = `${Math.round(durationMs)}ms`;\n      runtime.outerElement.style.transitionTimingFunction = runtime.options.easing;\n    }\n    runtime.x = options.x;\n    runtime.y = options.y;\n    runtime.hasPosition = true;\n    applyTranslate();\n  }\n  function setPressed(options) {\n    if (!runtime.enabled || !runtime.innerElement) {\n      return;\n    }\n    runtime.scale = options.pressed ? runtime.options.style === \"dot\" ? 0.92 : 0.95 : 1;\n    runtime.innerElement.style.transitionDuration = `${PRESS_DURATION_MS}ms`;\n    runtime.innerElement.style.transitionTimingFunction = PRESS_EASING;\n    runtime.innerElement.style.opacity = options.pressed ? \"1\" : getBaseOpacity();\n    applyScale();\n  }\n  function enable(options) {\n    runtime.options = mergeOptions(options);\n    runtime.enabled = true;\n    ensureCursorElement();\n    applyRuntimeVisualOptions();\n    if (!runtime.hasPosition) {\n      runtime.x = Math.round(window.innerWidth / 2);\n      runtime.y = Math.round(window.innerHeight / 2);\n      runtime.scale = 1;\n      runtime.hasPosition = true;\n    }\n    runtime.idleHidden = false;\n    if (runtime.innerElement) {\n      runtime.innerElement.style.opacity = getBaseOpacity();\n    }\n    applyTranslate();\n    applyScale();\n    scheduleIdleHide();\n  }\n  function disable() {\n    runtime.enabled = false;\n    runtime.scale = 1;\n    runtime.hasPosition = false;\n    runtime.idleHidden = false;\n    clearIdleHideTimer();\n    if (runtime.outerElement) {\n      runtime.outerElement.remove();\n      runtime.outerElement = null;\n      runtime.innerElement = null;\n    }\n  }\n  function applyMouseAction(action) {\n    if (!runtime.enabled) {\n      return;\n    }\n    if (runtime.idleHidden) {\n      runtime.idleHidden = false;\n      wakeFromIdle({ x: action.x, y: action.y });\n    }\n    if (action.type === \"move\" || action.type === \"wheel\") {\n      moveCursor({ x: action.x, y: action.y });\n    } else if (action.type === \"down\") {\n      moveCursor({ x: action.x, y: action.y });\n      setPressed({ pressed: true });\n    } else if (action.type === \"up\") {\n      moveCursor({ x: action.x, y: action.y });\n      setPressed({ pressed: false });\n    }\n    scheduleIdleHide();\n  }\n  var api = {\n    enable,\n    disable,\n    applyMouseAction,\n    isEnabled: () => {\n      return runtime.enabled;\n    }\n  };\n  if (isTopFrame) {\n    globalThis.__playwriterGhostCursor = api;\n    try {\n      if (document.readyState === \"loading\") {\n        document.addEventListener(\"DOMContentLoaded\", () => {\n          try {\n            api.enable();\n          } catch {}\n        }, { once: true });\n      } else {\n        api.enable();\n      }\n    } catch {}\n  }\n})();\n";
+//#endregion
+//#region ../tabwright/dist/bippy.js?raw
+var bippy_default = "(() => {\n  // ../node_modules/.pnpm/bippy@0.5.43_react@19.2.7/node_modules/bippy/dist/rdt-hook.js\n  var e = `0.5.43`;\n  var t = `bippy-${e}`;\n  var n = Object.defineProperty;\n  var r = Object.prototype.hasOwnProperty;\n  var i = () => {};\n  var a = (e2) => {\n    try {\n      Function.prototype.toString.call(e2).indexOf(`^_^`) > -1 && setTimeout(() => {\n        throw Error(`React is running in production mode, but dead code elimination has not been applied. Read how to correctly configure React for production: https://reactjs.org/link/perf-use-production-build`);\n      });\n    } catch {}\n  };\n  var o = (e2 = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__) => !!(e2 && (`getFiberRoots` in e2));\n  var s = false;\n  var c;\n  var l = (e2 = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__) => s ? true : (e2 && typeof e2.inject == `function` && (c = e2.inject.toString()), !!c?.includes(`(injected)`));\n  var u = new Set;\n  var d = new Set;\n  var f = (e2) => {\n    let r2 = new Map, o2 = 0, s2 = { _instrumentationIsActive: false, _instrumentationSource: t, checkDCE: a, hasUnsupportedRendererAttached: false, inject(e3) {\n      let t2 = ++o2;\n      return r2.set(t2, e3), d.add(e3), s2._instrumentationIsActive || (s2._instrumentationIsActive = true, u.forEach((e4) => e4())), t2;\n    }, on: i, onCommitFiberRoot: i, onCommitFiberUnmount: i, onPostCommitFiberRoot: i, renderers: r2, supportsFiber: true, supportsFlight: true };\n    try {\n      n(globalThis, `__REACT_DEVTOOLS_GLOBAL_HOOK__`, { configurable: true, enumerable: true, get() {\n        return s2;\n      }, set(t3) {\n        if (t3 && typeof t3 == `object`) {\n          let n2 = s2.renderers;\n          s2 = t3, n2.size > 0 && (n2.forEach((e3, n3) => {\n            d.add(e3), t3.renderers.set(n3, e3);\n          }), p(e2));\n        }\n      } });\n      let t2 = window.hasOwnProperty, r3 = false;\n      n(window, `hasOwnProperty`, { configurable: true, value: function(...e3) {\n        try {\n          if (!r3 && e3[0] === `__REACT_DEVTOOLS_GLOBAL_HOOK__`)\n            return globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__ = undefined, r3 = true, -0;\n        } catch {}\n        return t2.apply(this, e3);\n      }, writable: true });\n    } catch {\n      p(e2);\n    }\n    return s2;\n  };\n  var p = (e2) => {\n    e2 && u.add(e2);\n    try {\n      let n2 = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;\n      if (!n2)\n        return;\n      if (!n2._instrumentationSource) {\n        n2.checkDCE = a, n2.supportsFiber = true, n2.supportsFlight = true, n2.hasUnsupportedRendererAttached = false, n2._instrumentationSource = t, n2._instrumentationIsActive = false;\n        let e3 = o(n2);\n        if (e3 || (n2.on = i), n2.renderers.size) {\n          n2._instrumentationIsActive = true, u.forEach((e4) => e4());\n          return;\n        }\n        let r2 = n2.inject, c2 = l(n2);\n        c2 && !e3 && (s = true, n2.inject({ scheduleRefresh() {} }) && (n2._instrumentationIsActive = true)), n2.inject = (e4) => {\n          let t2 = r2(e4);\n          return d.add(e4), c2 && n2.renderers.set(t2, e4), n2._instrumentationIsActive = true, u.forEach((e5) => e5()), t2;\n        };\n      }\n      (n2.renderers.size || n2._instrumentationIsActive || l()) && e2?.();\n    } catch {}\n  };\n  var m = () => r.call(globalThis, `__REACT_DEVTOOLS_GLOBAL_HOOK__`);\n  var h = (e2) => m() ? (p(e2), globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__) : f(e2);\n  var g = () => !!(typeof window < `u` && (window.document?.createElement || window.navigator?.product === `ReactNative`));\n  var _ = () => {\n    try {\n      g() && h();\n    } catch {}\n  };\n\n  // ../node_modules/.pnpm/bippy@0.5.43_react@19.2.7/node_modules/bippy/dist/install-hook-only.js\n  _();\n\n  // ../node_modules/.pnpm/bippy@0.5.43_react@19.2.7/node_modules/bippy/dist/core.js\n  var b = (e2) => {\n    switch (e2.tag) {\n      case 5:\n      case 26:\n      case 27:\n        return true;\n      default:\n        return typeof e2.type == `string`;\n    }\n  };\n  var be = (e2) => {\n    switch (e2.tag) {\n      case 1:\n      case 11:\n      case 0:\n      case 14:\n      case 15:\n        return true;\n      default:\n        return false;\n    }\n  };\n  function A(e2, t2, n2 = false) {\n    if (!e2)\n      return null;\n    let r2 = t2(e2);\n    if (r2 instanceof Promise)\n      return (async () => {\n        if (await r2 === true)\n          return e2;\n        let i3 = n2 ? e2.return : e2.child;\n        for (;i3; ) {\n          let e3 = await M(i3, t2, n2);\n          if (e3)\n            return e3;\n          i3 = n2 ? null : i3.sibling;\n        }\n        return null;\n      })();\n    if (r2 === true)\n      return e2;\n    let i2 = n2 ? e2.return : e2.child;\n    for (;i2; ) {\n      let e3 = j(i2, t2, n2);\n      if (e3)\n        return e3;\n      i2 = n2 ? null : i2.sibling;\n    }\n    return null;\n  }\n  var j = (e2, t2, n2 = false) => {\n    if (!e2)\n      return null;\n    if (t2(e2) === true)\n      return e2;\n    let r2 = n2 ? e2.return : e2.child;\n    for (;r2; ) {\n      let e3 = j(r2, t2, n2);\n      if (e3)\n        return e3;\n      r2 = n2 ? null : r2.sibling;\n    }\n    return null;\n  };\n  var M = async (e2, t2, n2 = false) => {\n    if (!e2)\n      return null;\n    if (await t2(e2) === true)\n      return e2;\n    let r2 = n2 ? e2.return : e2.child;\n    for (;r2; ) {\n      let e3 = await M(r2, t2, n2);\n      if (e3)\n        return e3;\n      r2 = n2 ? null : r2.sibling;\n    }\n    return null;\n  };\n  var N = (e2) => {\n    let t2 = e2;\n    return typeof t2 == `function` ? t2 : typeof t2 == `object` && t2 ? N(t2.type || t2.render) : null;\n  };\n  var Ee = (e2) => {\n    let t2 = e2;\n    if (typeof t2 == `string`)\n      return t2;\n    if (typeof t2 != `function` && !(typeof t2 == `object` && t2))\n      return null;\n    let n2 = t2.displayName || t2.name || null;\n    if (n2)\n      return n2;\n    let r2 = N(t2);\n    return r2 && (r2.displayName || r2.name) || null;\n  };\n  var I = new WeakMap;\n  var U = new WeakMap;\n  var Pe = (e2) => {\n    let t2 = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;\n    if (t2?.renderers)\n      for (let n2 of t2.renderers.values())\n        try {\n          let t3 = n2.findFiberByHostInstance?.(e2);\n          if (t3)\n            return t3;\n        } catch {}\n    if (typeof e2 == `object` && e2) {\n      if (`_reactRootContainer` in e2)\n        return e2._reactRootContainer?._internalRoot?.current?.child;\n      for (let t3 in e2)\n        if (t3.startsWith(`__reactContainer$`) || t3.startsWith(`__reactInternalInstance$`) || t3.startsWith(`__reactFiber`))\n          return e2[t3] || null;\n    }\n    return null;\n  };\n  var Z = Error();\n  var Q = new Set;\n\n  // ../node_modules/.pnpm/bippy@0.5.43_react@19.2.7/node_modules/bippy/dist/source.js\n  var i2 = /^[a-zA-Z][a-zA-Z\\d+\\-.]*:/;\n  var a2 = [`rsc://`, `file:///`, `webpack-internal://`, `webpack://`, `node:`, `turbopack://`, `metro://`, `/app-pages-browser/`, `/(app-pages-browser)/`];\n  var o2 = [`<anonymous>`, `eval`, ``];\n  var s2 = /\\.(jsx|tsx|ts|js)$/;\n  var c2 = /(\\.min|bundle|chunk|vendor|vendors|runtime|polyfill|polyfills)\\.(js|mjs|cjs)$|(chunk|bundle|vendor|vendors|runtime|polyfill|polyfills|framework|app|main|index)[-_.][A-Za-z0-9_-]{4,}\\.(js|mjs|cjs)$|[\\da-f]{8,}\\.(js|mjs|cjs)$|[-_.][\\da-f]{20,}\\.(js|mjs|cjs)$|\\/dist\\/|\\/build\\/|\\/.next\\/|\\/out\\/|\\/node_modules\\/|\\.webpack\\.|\\.vite\\.|\\.turbopack\\./i;\n  var l2 = /^\\?[\\w~.-]+(?:=[^&#]*)?(?:&[\\w~.-]+(?:=[^&#]*)?)*$/;\n  var u2 = /\\(at [^)]+\\)$/;\n  var d3 = /(^|@)\\S+:\\d+/;\n  var f3 = /^\\s*at .*(\\S+:\\d+|\\(native\\))/m;\n  var ee2 = /^(eval@)?(\\[native code\\])?$/;\n  var m3 = (e2, t2) => {\n    if (t2?.includeInElement !== false) {\n      let n2 = e2.split(`\n`), r2 = [];\n      for (let e3 of n2)\n        if (/^\\s*at\\s+/.test(e3)) {\n          let t3 = _3(e3, undefined)[0];\n          t3 && r2.push(t3);\n        } else if (/^\\s*in\\s+/.test(e3)) {\n          let t3 = e3.replace(/^\\s*in\\s+/, ``).replace(/\\s*\\(at .*\\)$/, ``);\n          r2.push({ functionName: t3, source: e3 });\n        } else if (e3.match(d3)) {\n          let t3 = v2(e3, undefined)[0];\n          t3 && r2.push(t3);\n        }\n      return g3(r2, t2);\n    }\n    return e2.match(f3) ? _3(e2, t2) : v2(e2, t2);\n  };\n  var h3 = (e2) => {\n    if (!e2.includes(`:`))\n      return [e2, undefined, undefined];\n    let t2 = e2.startsWith(`(`) && /:\\d+\\)$/.test(e2) ? e2.slice(1, -1) : e2, n2 = /(.+?)(?::(\\d+))?(?::(\\d+))?$/.exec(t2);\n    return n2 ? [n2[1], n2[2] || undefined, n2[3] || undefined] : [t2, undefined, undefined];\n  };\n  var g3 = (e2, t2) => t2 && t2.slice != null ? Array.isArray(t2.slice) ? e2.slice(t2.slice[0], t2.slice[1]) : e2.slice(0, t2.slice) : e2;\n  var _3 = (e2, t2) => g3(e2.split(`\n`).filter((e3) => !!e3.match(f3)), t2).map((e3) => {\n    let t3 = e3;\n    t3.includes(`(eval `) && (t3 = t3.replace(/eval code/g, `eval`).replace(/(\\(eval at [^()]*)|(,.*$)/g, ``));\n    let n2 = t3.replace(/^\\s+/, ``).replace(/\\(eval code/g, `(`).replace(/^.*?\\s+/, ``), r2 = n2.match(/ (\\(.+\\)$)/);\n    n2 = r2 ? n2.replace(r2[0], ``) : n2;\n    let i3 = h3(r2 ? r2[1] : n2);\n    return { functionName: r2 && n2 || undefined, fileName: [`eval`, `<anonymous>`].includes(i3[0]) ? undefined : i3[0], lineNumber: i3[1] ? +i3[1] : undefined, columnNumber: i3[2] ? +i3[2] : undefined, source: t3 };\n  });\n  var v2 = (e2, t2) => g3(e2.split(`\n`).filter((e3) => !e3.match(ee2)), t2).map((e3) => {\n    let t3 = e3;\n    if (t3.includes(` > eval`) && (t3 = t3.replace(/ line (\\d+)(?: > eval line \\d+)* > eval:\\d+:\\d+/g, `:$1`)), !t3.includes(`@`) && !t3.includes(`:`))\n      return { functionName: t3 };\n    {\n      let e4 = /(([^\\n\\r\"\\u2028\\u2029]*\".[^\\n\\r\"\\u2028\\u2029]*\"[^\\n\\r@\\u2028\\u2029]*(?:@[^\\n\\r\"\\u2028\\u2029]*\"[^\\n\\r@\\u2028\\u2029]*)*(?:[\\n\\r\\u2028\\u2029][^@]*)?)?[^@]*)@/, n2 = t3.match(e4), r2 = n2 && n2[1] ? n2[1] : undefined, i3 = h3(t3.replace(e4, ``));\n      return { functionName: r2, fileName: i3[0], lineNumber: i3[1] ? +i3[1] : undefined, columnNumber: i3[2] ? +i3[2] : undefined, source: t3 };\n    }\n  });\n  var se2 = 44;\n  var y = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/`;\n  var ce2 = new Uint8Array(64);\n  var le2 = new Uint8Array(128);\n  for (let e2 = 0;e2 < y.length; e2++) {\n    let t2 = y.charCodeAt(e2);\n    ce2[e2] = t2, le2[t2] = e2;\n  }\n  function b2(e2, t2) {\n    let n2 = 0, r2 = 0, i3 = 0;\n    do\n      i3 = le2[e2.next()], n2 |= (i3 & 31) << r2, r2 += 5;\n    while (i3 & 32);\n    let a3 = n2 & 1;\n    return n2 >>>= 1, a3 && (n2 = -2147483648 | -n2), t2 + n2;\n  }\n  function ue2(e2, t2) {\n    return e2.pos >= t2 ? false : e2.peek() !== se2;\n  }\n  var de2 = class {\n    constructor(e2) {\n      this.pos = 0, this.buffer = e2;\n    }\n    next() {\n      return this.buffer.charCodeAt(this.pos++);\n    }\n    peek() {\n      return this.buffer.charCodeAt(this.pos);\n    }\n    indexOf(e2) {\n      let { buffer: t2, pos: n2 } = this, r2 = t2.indexOf(e2, n2);\n      return r2 === -1 ? t2.length : r2;\n    }\n  };\n  function x2(e2) {\n    let { length: t2 } = e2, n2 = new de2(e2), r2 = [], i3 = 0, a3 = 0, o3 = 0, s3 = 0, c3 = 0;\n    do {\n      let e3 = n2.indexOf(`;`), t3 = [], l3 = true, u3 = 0;\n      for (i3 = 0;n2.pos < e3; ) {\n        let r3;\n        i3 = b2(n2, i3), i3 < u3 && (l3 = false), u3 = i3, ue2(n2, e3) ? (a3 = b2(n2, a3), o3 = b2(n2, o3), s3 = b2(n2, s3), ue2(n2, e3) ? (c3 = b2(n2, c3), r3 = [i3, a3, o3, s3, c3]) : r3 = [i3, a3, o3, s3]) : r3 = [i3], t3.push(r3), n2.pos++;\n      }\n      l3 || fe2(t3), r2.push(t3), n2.pos = e3 + 1;\n    } while (n2.pos <= t2);\n    return r2;\n  }\n  function fe2(e2) {\n    e2.sort(pe2);\n  }\n  function pe2(e2, t2) {\n    return e2[0] - t2[0];\n  }\n  var S2 = /^[a-zA-Z][a-zA-Z\\d+\\-.]*:/;\n  var me2 = /^data:application\\/json[^,]+base64,/;\n  var he2 = /(?:\\/\\/[@#][ \\t]+sourceMappingURL=([^\\s'\"]+?)[ \\t]*$)|(?:\\/\\*[@#][ \\t]+sourceMappingURL=([^*]+?)[ \\t]*(?:\\*\\/)[ \\t]*$)/;\n  var C2 = new Map;\n  var w2 = new Map;\n  var T2 = (e2, t2, n2, r2) => {\n    if (n2 < 0 || n2 >= e2.length)\n      return null;\n    let i3 = e2[n2];\n    if (!i3 || i3.length === 0)\n      return null;\n    let a3 = null;\n    for (let e3 of i3)\n      if (e3[0] <= r2)\n        a3 = e3;\n      else\n        break;\n    if (!a3 || a3.length < 4)\n      return null;\n    let [, o3, s3, c3] = a3;\n    if (o3 === undefined || s3 === undefined || c3 === undefined)\n      return null;\n    let l3 = t2[o3];\n    return l3 ? { columnNumber: c3, fileName: l3, lineNumber: s3 + 1 } : null;\n  };\n  var E2 = (e2, t2, n2) => {\n    if (e2.sections) {\n      let r2 = null;\n      for (let i4 of e2.sections)\n        if (t2 > i4.offset.line || t2 === i4.offset.line && n2 >= i4.offset.column)\n          r2 = i4;\n        else\n          break;\n      if (!r2)\n        return null;\n      let i3 = t2 - r2.offset.line, a3 = t2 === r2.offset.line ? n2 - r2.offset.column : n2;\n      return T2(r2.map.mappings, r2.map.sources, i3, a3);\n    }\n    return T2(e2.mappings, e2.sources, t2 - 1, n2);\n  };\n  var ge2 = (e2, t2) => {\n    let n2 = t2.split(`\n`), r2;\n    for (let e3 = n2.length - 1;e3 >= 0 && !r2; e3--) {\n      let t3 = n2[e3].match(he2);\n      t3 && (r2 = t3[1] || t3[2]);\n    }\n    if (!r2)\n      return null;\n    let i3 = S2.test(r2);\n    if (!(me2.test(r2) || i3 || r2.startsWith(`/`))) {\n      let t3 = e2.split(`/`);\n      t3[t3.length - 1] = r2, r2 = t3.join(`/`);\n    }\n    return r2;\n  };\n  var _e2 = (e2) => ({ file: e2.file, mappings: x2(e2.mappings), names: e2.names, sourceRoot: e2.sourceRoot, sources: e2.sources, sourcesContent: e2.sourcesContent, version: 3 });\n  var ve2 = (e2) => {\n    let t2 = e2.sections.map(({ map: e3, offset: t3 }) => ({ map: { ...e3, mappings: x2(e3.mappings) }, offset: t3 })), n2 = new Set;\n    for (let e3 of t2)\n      for (let t3 of e3.map.sources)\n        n2.add(t3);\n    return { file: e2.file, mappings: [], names: [], sections: t2, sourceRoot: undefined, sources: Array.from(n2), sourcesContent: undefined, version: 3 };\n  };\n  var D2 = (e2) => {\n    if (!e2)\n      return false;\n    let t2 = e2.trim();\n    if (!t2)\n      return false;\n    let n2 = t2.match(S2);\n    if (!n2)\n      return true;\n    let r2 = n2[0].toLowerCase();\n    return r2 === `http:` || r2 === `https:`;\n  };\n  var ye2 = async (e2, t2 = fetch) => {\n    if (!D2(e2))\n      return null;\n    let n2 = await t2(e2);\n    if (!n2.ok)\n      return null;\n    let r2 = await n2.text();\n    if (!r2)\n      return null;\n    let i3 = ge2(e2, r2);\n    if (!i3 || !D2(i3))\n      return null;\n    let a3 = await t2(i3);\n    if (!a3.ok)\n      return null;\n    try {\n      let e3 = await a3.json();\n      return `sections` in e3 ? ve2(e3) : _e2(e3);\n    } catch {\n      return null;\n    }\n  };\n  var O2 = async (e2, t2 = true, n2) => {\n    if (t2 && C2.has(e2))\n      return C2.get(e2) ?? null;\n    let r2 = t2 ? w2.get(e2) : undefined;\n    if (r2)\n      return (await r2).sourceMap;\n    let i3 = ye2(e2, n2).then((e3) => ({ sourceMap: e3, isTransientFailure: false }), () => ({ sourceMap: null, isTransientFailure: true }));\n    t2 && w2.set(e2, i3);\n    let { sourceMap: a3, isTransientFailure: o3 } = await i3;\n    return t2 && (w2.delete(e2), o3 || C2.set(e2, a3)), a3;\n  };\n  var be2 = async (e2, t2 = true, n2) => await Promise.all(e2.map(async (e3) => {\n    if (!e3.fileName)\n      return e3;\n    let r2 = await O2(e3.fileName, t2, n2);\n    if (!r2 || typeof e3.lineNumber != `number` || typeof e3.columnNumber != `number`)\n      return e3;\n    let i3 = E2(r2, e3.lineNumber, e3.columnNumber);\n    return i3 ? { ...e3, source: i3.fileName && e3.source ? e3.source.replace(e3.fileName, i3.fileName) : e3.source, fileName: i3.fileName, lineNumber: i3.lineNumber, columnNumber: i3.columnNumber, isSymbolicated: true } : e3;\n  }));\n  var xe2 = (e2) => e2._debugStack instanceof Error && typeof e2._debugStack?.stack == `string`;\n  var Se2 = () => {\n    let n2 = h();\n    for (let t2 of [...Array.from(d), ...Array.from(n2.renderers.values())]) {\n      let e2 = t2.currentDispatcherRef;\n      if (e2 && typeof e2 == `object`)\n        return `H` in e2 ? e2.H : e2.current;\n    }\n    return null;\n  };\n  var Ce2 = (t2) => {\n    for (let n2 of d) {\n      let e2 = n2.currentDispatcherRef;\n      e2 && typeof e2 == `object` && (`H` in e2 ? e2.H = t2 : e2.current = t2);\n    }\n  };\n  var k2 = (e2) => `\n    in ${e2}`;\n  var we2 = (e2, t2) => {\n    let n2 = k2(e2);\n    return t2 && (n2 += ` (at ${t2})`), n2;\n  };\n  var A2 = false;\n  var j2 = (e2, t2) => {\n    if (!e2 || A2)\n      return ``;\n    let r2 = Error.prepareStackTrace;\n    Error.prepareStackTrace = undefined, A2 = true;\n    let i3 = Se2();\n    Ce2(null);\n    let { error: a3, warn: o3 } = console;\n    console.error = () => {}, console.warn = () => {};\n    try {\n      let r3 = { DetermineComponentFrameRoot() {\n        let n2;\n        try {\n          if (t2) {\n            let t3 = function() {\n              throw Error();\n            };\n            if (Object.defineProperty(t3.prototype, `props`, { set: function() {\n              throw Error();\n            } }), typeof Reflect == `object` && Reflect.construct) {\n              try {\n                Reflect.construct(t3, []);\n              } catch (e3) {\n                n2 = e3;\n              }\n              Reflect.construct(e2, [], t3);\n            } else {\n              try {\n                t3.call();\n              } catch (e3) {\n                n2 = e3;\n              }\n              e2.call(t3.prototype);\n            }\n          } else {\n            try {\n              throw Error();\n            } catch (e3) {\n              n2 = e3;\n            }\n            let t3 = e2();\n            t3 && typeof t3.catch == `function` && t3.catch(() => {});\n          }\n        } catch (e3) {\n          if (e3 instanceof Error && n2 instanceof Error && typeof e3.stack == `string`)\n            return [e3.stack, n2.stack];\n        }\n        return [null, null];\n      } };\n      r3.DetermineComponentFrameRoot.displayName = `DetermineComponentFrameRoot`, Object.getOwnPropertyDescriptor(r3.DetermineComponentFrameRoot, `name`)?.configurable && Object.defineProperty(r3.DetermineComponentFrameRoot, `name`, { value: `DetermineComponentFrameRoot` });\n      let [i4, a4] = r3.DetermineComponentFrameRoot();\n      if (i4 && a4) {\n        let t3 = i4.split(`\n`), r4 = a4.split(`\n`), o4 = 0, s4 = 0;\n        for (;o4 < t3.length && !t3[o4].includes(`DetermineComponentFrameRoot`); )\n          o4++;\n        for (;s4 < r4.length && !r4[s4].includes(`DetermineComponentFrameRoot`); )\n          s4++;\n        if (o4 === t3.length || s4 === r4.length)\n          for (o4 = t3.length - 1, s4 = r4.length - 1;o4 >= 1 && s4 >= 0 && t3[o4] !== r4[s4]; )\n            s4--;\n        for (;o4 >= 1 && s4 >= 0; o4--, s4--)\n          if (t3[o4] !== r4[s4]) {\n            if (o4 !== 1 || s4 !== 1)\n              do\n                if (o4--, s4--, s4 < 0 || t3[o4] !== r4[s4]) {\n                  let r5 = `\n${t3[o4].replace(` at new `, ` at `)}`, i5 = Ee(e2);\n                  return i5 && r5.includes(`<anonymous>`) && (r5 = r5.replace(`<anonymous>`, i5)), r5;\n                }\n              while (o4 >= 1 && s4 >= 0);\n            break;\n          }\n      }\n    } finally {\n      A2 = false, Error.prepareStackTrace = r2, Ce2(i3), console.error = a3, console.warn = o3;\n    }\n    let s3 = e2 ? Ee(e2) : ``;\n    return s3 ? k2(s3) : ``;\n  };\n  var M2 = (e2, t2) => {\n    let n2 = e2.tag, r2 = ``;\n    switch (n2) {\n      case 28:\n        r2 = k2(`Activity`);\n        break;\n      case 1:\n        r2 = j2(e2.type, true);\n        break;\n      case 11:\n        r2 = j2(e2.type.render, false);\n        break;\n      case 0:\n      case 15:\n        r2 = j2(e2.type, false);\n        break;\n      case 5:\n      case 26:\n      case 27:\n        r2 = k2(e2.type);\n        break;\n      case 16:\n        r2 = k2(`Lazy`);\n        break;\n      case 13:\n        r2 = e2.child !== t2 && t2 !== null ? k2(`Suspense Fallback`) : k2(`Suspense`);\n        break;\n      case 19:\n        r2 = k2(`SuspenseList`);\n        break;\n      case 30:\n        r2 = k2(`ViewTransition`);\n        break;\n      default:\n        return ``;\n    }\n    return r2;\n  };\n  var N2 = (e2) => {\n    try {\n      let t2 = ``, n2 = e2, r2 = null;\n      do {\n        t2 += M2(n2, r2);\n        let e3 = n2._debugInfo;\n        if (e3 && Array.isArray(e3))\n          for (let n3 = e3.length - 1;n3 >= 0; n3--) {\n            let r3 = e3[n3];\n            typeof r3.name == `string` && (t2 += we2(r3.name, r3.env));\n          }\n        r2 = n2, n2 = n2.return;\n      } while (n2);\n      return t2;\n    } catch (e3) {\n      return e3 instanceof Error ? `\nError generating stack: ${e3.message}\n${e3.stack}` : ``;\n    }\n  };\n  var P2 = (e2) => {\n    let t2 = Error.prepareStackTrace;\n    Error.prepareStackTrace = undefined;\n    let n2 = e2;\n    if (!n2)\n      return ``;\n    Error.prepareStackTrace = t2, n2.startsWith(`Error: react-stack-top-frame\n`) && (n2 = n2.slice(29));\n    let r2 = n2.indexOf(`\n`);\n    if (r2 !== -1 && (n2 = n2.slice(r2 + 1)), r2 = Math.max(n2.indexOf(`react_stack_bottom_frame`), n2.indexOf(`react-stack-bottom-frame`)), r2 !== -1 && (r2 = n2.lastIndexOf(`\n`, r2)), r2 !== -1)\n      n2 = n2.slice(0, r2);\n    else\n      return ``;\n    return n2;\n  };\n  var Te2 = (e2) => !!(e2.functionName && e2.fileName && (e2.fileName.startsWith(`rsc://`) || e2.fileName.startsWith(`about://React/`)));\n  var Ee2 = (e2, t2) => e2.fileName === t2.fileName && e2.lineNumber === t2.lineNumber && e2.columnNumber === t2.columnNumber;\n  var De2 = (e2) => {\n    let t2 = new Map;\n    for (let n2 of e2)\n      for (let e3 of n2.stackFrames) {\n        if (!Te2(e3))\n          continue;\n        let n3 = e3.functionName, r2 = t2.get(n3) ?? [];\n        r2.some((t3) => Ee2(t3, e3)) || (r2.push(e3), t2.set(n3, r2));\n      }\n    return t2;\n  };\n  var Oe2 = (e2, t2, n2) => {\n    if (!e2.functionName)\n      return { ...e2, isServer: true };\n    let r2 = t2.get(e2.functionName);\n    if (!r2 || r2.length === 0)\n      return { ...e2, isServer: true };\n    let i3 = n2.get(e2.functionName) ?? 0, a3 = r2[i3 % r2.length];\n    return n2.set(e2.functionName, i3 + 1), { ...e2, isServer: true, fileName: a3.fileName, lineNumber: a3.lineNumber, columnNumber: a3.columnNumber, source: e2.source?.replace(`(at Server)`, `(${a3.fileName}:${a3.lineNumber}:${a3.columnNumber})`) };\n  };\n  var ke = (e2) => {\n    let t2 = [];\n    return A(e2, (e3) => {\n      if (!xe2(e3))\n        return;\n      let r2 = typeof e3.type == `string` ? e3.type : Ee(e3.type) || `<anonymous>`;\n      t2.push({ componentName: r2, stackFrames: m3(P2(e3._debugStack?.stack)) });\n    }, true), t2;\n  };\n  var F = async (e2, t2 = true, n2) => {\n    let r2 = ke(e2), i3 = m3(N2(e2)), a3 = De2(r2), o3 = new Map;\n    return be2(i3.map((e3) => (e3.source?.includes(`(at Server)`) ?? false) || e3.source != null && u2.test(e3.source) ? Oe2(e3, a3, o3) : e3).filter((e3, t3, n3) => {\n      if (t3 === 0)\n        return true;\n      let r3 = n3[t3 - 1];\n      return e3.functionName !== r3.functionName;\n    }), t2, n2);\n  };\n  var I2 = (e2) => {\n    let t2 = e2._debugSource;\n    return t2 ? typeof t2 == `object` && !!t2 && `fileName` in t2 && typeof t2.fileName == `string` && `lineNumber` in t2 && typeof t2.lineNumber == `number` : false;\n  };\n  var Ae2 = async (e2, t2 = true, n2) => {\n    if (I2(e2))\n      return e2._debugSource || null;\n    let r2 = await F(e2, t2, n2);\n    for (let e3 of r2)\n      if (e3.fileName)\n        return { fileName: e3.fileName, lineNumber: e3.lineNumber, columnNumber: e3.columnNumber, functionName: e3.functionName };\n    return null;\n  };\n  var L2 = (e2) => e2.split(`/`).filter(Boolean).length;\n  var je2 = (e2) => e2.split(`/`).filter(Boolean)[0] ?? null;\n  var Me2 = (e2) => {\n    let t2 = e2.indexOf(`/`, 1);\n    if (t2 === -1 || L2(e2.slice(0, t2)) !== 1)\n      return e2;\n    let n2 = e2.slice(t2);\n    if (!s2.test(n2) || L2(n2) < 2)\n      return e2;\n    let r2 = je2(n2);\n    return !r2 || r2.startsWith(`@`) || r2.length > 4 ? e2 : n2;\n  };\n  var R2 = (e2) => {\n    if (!e2 || o2.some((t3) => t3 === e2))\n      return ``;\n    let t2 = e2, n2 = t2.startsWith(`http://`) || t2.startsWith(`https://`);\n    if (n2)\n      try {\n        t2 = new URL(t2).pathname;\n      } catch {}\n    if (n2 && (t2 = Me2(t2)), t2.startsWith(`about://React/`)) {\n      let e3 = t2.slice(14), n3 = e3.indexOf(`/`), r3 = e3.indexOf(`:`);\n      t2 = n3 !== -1 && (r3 === -1 || n3 < r3) ? e3.slice(n3 + 1) : e3;\n    }\n    let r2 = true;\n    for (;r2; ) {\n      r2 = false;\n      for (let e3 of a2)\n        if (t2.startsWith(e3)) {\n          t2 = t2.slice(e3.length), e3 === `file:///` && (t2 = `/${t2.replace(/^\\/+/, ``)}`), r2 = true;\n          break;\n        }\n    }\n    if (i2.test(t2)) {\n      let e3 = t2.match(i2);\n      e3 && (t2 = t2.slice(e3[0].length));\n    }\n    if (t2.startsWith(`//`)) {\n      let e3 = t2.indexOf(`/`, 2);\n      t2 = e3 === -1 ? `` : t2.slice(e3);\n    }\n    let s3 = t2.indexOf(`?`);\n    if (s3 !== -1) {\n      let e3 = t2.slice(s3);\n      l2.test(e3) && (t2 = t2.slice(0, s3));\n    }\n    return t2;\n  };\n  var Ne2 = (e2) => {\n    let t2 = R2(e2);\n    return !(!t2 || !s2.test(t2) || c2.test(t2));\n  };\n  var z2 = Symbol.for(`react.context`);\n  var Ie2 = Symbol.for(`react.memo_cache_sentinel`);\n  var B2 = [];\n  var H2 = null;\n  var U2 = null;\n  var W = null;\n  var G = 0;\n  var K = null;\n  var q2 = Error(\"Suspense Exception: This is not a real error! It's an implementation detail of `use` to interrupt the current render.\");\n  var Y = () => {\n    let e2 = U2;\n    return e2 !== null && (U2 = e2.next), e2;\n  };\n  var X2 = (e2) => {\n    if (H2 === null)\n      return e2._currentValue;\n    if (W === null)\n      throw Error(`Context reads do not line up with context dependencies.`);\n    if (Object.prototype.hasOwnProperty.call(W, `memoizedValue`)) {\n      let e3 = W.memoizedValue;\n      return W = W.next, e3;\n    }\n    return e2._currentValue;\n  };\n  var Z2 = (e2, t2, n2, r2 = null) => {\n    B2.push({ displayName: r2, primitive: e2, stackError: Error(), value: t2, dispatcherHookName: n2 });\n  };\n  var Be = (e2) => {\n    if (typeof e2 == `object` && e2) {\n      let t2 = e2;\n      if (typeof t2.then == `function`) {\n        let e3 = K !== null && G < K.length ? K[G++] : t2;\n        switch (e3.status) {\n          case `fulfilled`:\n            return Z2(`Promise`, e3.value, `Use`), e3.value;\n          case `rejected`:\n            throw e3.reason;\n        }\n        throw Z2(`Unresolved`, e3, `Use`), q2;\n      }\n      if (t2.$$typeof === z2 && `_currentValue` in t2) {\n        let e3 = t2, n2 = X2(e3);\n        return Z2(`Context (use)`, n2, `Use`, e3.displayName || `Context`), n2;\n      }\n    }\n    throw Error(`An unsupported type was passed to use(): ` + String(e2));\n  };\n  var Ve = (e2) => {\n    let t2 = X2(e2);\n    return Z2(`Context`, t2, `Context`, e2.displayName || null), t2;\n  };\n  var He = (e2) => {\n    let t2 = Y(), n2 = t2 === null ? typeof e2 == `function` ? e2() : e2 : t2.memoizedState;\n    return Z2(`State`, n2, `State`), [n2, () => {}];\n  };\n  var Ue = (e2, t2, n2) => {\n    let r2 = Y(), i3 = r2 === null ? n2 === undefined ? t2 : n2(t2) : r2.memoizedState;\n    return Z2(`Reducer`, i3, `Reducer`), [i3, () => {}];\n  };\n  var We = (e2) => {\n    let t2 = Y(), n2 = t2 === null ? { current: e2 } : t2.memoizedState;\n    return Z2(`Ref`, n2.current, `Ref`), n2;\n  };\n  var Ge = () => {\n    let e2 = Y();\n    return Z2(`CacheRefresh`, e2 === null ? () => {} : e2.memoizedState, `CacheRefresh`), () => {};\n  };\n  var Ke = (e2) => {\n    Y(), Z2(`LayoutEffect`, e2, `LayoutEffect`);\n  };\n  var qe = (e2) => {\n    Y(), Z2(`InsertionEffect`, e2, `InsertionEffect`);\n  };\n  var Je = (e2) => {\n    Y(), Z2(`Effect`, e2, `Effect`);\n  };\n  var Ye = (e2) => {\n    Y();\n    let t2;\n    typeof e2 == `object` && e2 && `current` in e2 && (t2 = e2.current), Z2(`ImperativeHandle`, t2, `ImperativeHandle`);\n  };\n  var Xe = (e2, t2) => {\n    Z2(`DebugValue`, typeof t2 == `function` ? t2(e2) : e2, `DebugValue`);\n  };\n  var Ze = (e2) => {\n    let t2 = Y();\n    return Z2(`Callback`, t2 === null ? e2 : t2.memoizedState[0], `Callback`), e2;\n  };\n  var Qe = (e2) => {\n    let t2 = Y(), n2 = t2 === null ? e2() : t2.memoizedState[0];\n    return Z2(`Memo`, n2, `Memo`), n2;\n  };\n  var $e = (e2, t2) => {\n    let n2 = Y();\n    Y();\n    let r2 = n2 === null ? t2() : n2.memoizedState;\n    return Z2(`SyncExternalStore`, r2, `SyncExternalStore`), r2;\n  };\n  var et = () => {\n    let e2 = Y();\n    Y();\n    let t2 = e2 === null ? false : e2.memoizedState;\n    return Z2(`Transition`, t2, `Transition`), [t2, () => {}];\n  };\n  var tt = (e2) => {\n    let t2 = Y(), n2 = t2 === null ? e2 : t2.memoizedState;\n    return Z2(`DeferredValue`, n2, `DeferredValue`), n2;\n  };\n  var nt = () => {\n    let e2 = Y(), t2 = e2 === null ? `` : e2.memoizedState;\n    return Z2(`Id`, t2, `Id`), t2;\n  };\n  var rt = (e2) => {\n    let t2 = H2;\n    if (t2 == null)\n      return [];\n    let n2 = t2.updateQueue?.memoCache;\n    if (n2 == null)\n      return [];\n    let r2 = n2.data[n2.index];\n    return r2 === undefined && (r2 = n2.data[n2.index] = Array.from({ length: e2 }, () => Ie2)), n2.index++, r2;\n  };\n  var it = (e2) => {\n    let t2 = Y(), n2 = t2 === null ? e2 : t2.memoizedState;\n    return Z2(`Optimistic`, n2, `Optimistic`), [n2, () => {}];\n  };\n  var at = (e2, t2) => {\n    let n2, r2 = null;\n    if (e2 !== null) {\n      let t3 = e2.memoizedState;\n      if (typeof t3 == `object` && t3 && `then` in t3 && typeof t3.then == `function`) {\n        let e3 = t3;\n        switch (e3.status) {\n          case `fulfilled`:\n            n2 = e3.value;\n            break;\n          case `rejected`:\n            r2 = e3.reason;\n            break;\n          default:\n            r2 = q2, n2 = e3;\n        }\n      } else\n        n2 = t3;\n    } else\n      n2 = t2;\n    return { value: n2, error: r2 };\n  };\n  var ot = (e2) => (t2, n2) => {\n    let r2 = Y();\n    Y(), Y();\n    let i3 = Error(), { value: a3, error: o3 } = at(r2, n2);\n    if (B2.push({ displayName: null, primitive: e2, stackError: i3, value: a3, dispatcherHookName: e2 }), o3 !== null)\n      throw o3;\n    return [a3, () => {}, false];\n  };\n  var st = ot(`ActionState`);\n  var Q2 = { readContext: X2, use: Be, useCallback: Ze, useContext: Ve, useEffect: Je, useImperativeHandle: Ye, useLayoutEffect: Ke, useInsertionEffect: qe, useMemo: Qe, useReducer: Ue, useRef: We, useState: He, useDebugValue: Xe, useDeferredValue: tt, useTransition: et, useSyncExternalStore: $e, useId: nt, useHostTransitionStatus: () => {\n    let e2 = X2({ _currentValue: null });\n    return Z2(`HostTransitionStatus`, e2, `HostTransitionStatus`), e2;\n  }, useFormState: ot(`FormState`), useActionState: st, useOptimistic: it, useMemoCache: rt, useCacheRefresh: Ge, useEffectEvent: (e2) => (Y(), Z2(`EffectEvent`, e2, `EffectEvent`), e2) };\n  var ct = typeof Proxy > `u` ? Q2 : new Proxy(Q2, { get(e2, t2) {\n    if (Object.prototype.hasOwnProperty.call(e2, t2))\n      return e2[t2];\n    let n2 = Error(`Missing method in Dispatcher: ` + t2);\n    throw n2.name = `ReactDebugToolsUnsupportedHookError`, n2;\n  } });\n  var gt = new Set([`Context`, `Context (use)`, `DebugValue`, `Promise`, `Unresolved`, `HostTransitionStatus`]);\n  var kt = new Set([`Effect`, `LayoutEffect`, `InsertionEffect`, `ImperativeHandle`, `DebugValue`]);\n\n  // dist/_bippy-entry-68953-1784086938398.js\n  globalThis.__bippy = {\n    getFiberFromHostInstance: Pe,\n    getDisplayName: Ee,\n    traverseFiber: A,\n    isCompositeFiber: be,\n    isHostFiber: b,\n    getSource: Ae2,\n    getOwnerStack: F,\n    normalizeFileName: R2,\n    isSourceFile: Ne2\n  };\n})();\n";
+//#endregion
+//#region src/rrweb-recording.ts
+var activeRrwebRecordings = /* @__PURE__ */ new Map();
+function resolveTabIdFromSessionId(sessionId) {
+	if (!sessionId) {
+		for (const [tabId, tab] of store.getState().tabs) if (tab.state === "connected") return tabId;
+		return;
+	}
+	return getTabBySessionId(sessionId)?.tabId;
+}
+function isRrwebRecorderResponse(value) {
+	if (!value || typeof value !== "object") return false;
+	const candidate = value;
+	return typeof candidate.success === "boolean" && (candidate.error === void 0 || typeof candidate.error === "string") && (candidate.isRecording === void 0 || typeof candidate.isRecording === "boolean") && (candidate.startedAt === void 0 || typeof candidate.startedAt === "number") && (candidate.duration === void 0 || typeof candidate.duration === "number") && (candidate.url === void 0 || typeof candidate.url === "string") && (candidate.eventCount === void 0 || typeof candidate.eventCount === "number");
+}
+function isRrwebEvent(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isRrwebEventBatchMessage(value) {
+	if (!value || typeof value !== "object") return false;
+	const candidate = value;
+	return candidate.action === "playwriterRrwebEvents" && Array.isArray(candidate.events) && candidate.events.every(isRrwebEvent) && (candidate.final === void 0 || typeof candidate.final === "boolean");
+}
+function isRrwebCancelledMessage(value) {
+	if (!value || typeof value !== "object") return false;
+	return value.action === "playwriterRrwebCancelled";
+}
+function isFailedRrwebFrameMessageResult(result) {
+	return !result.response.success;
+}
+async function getRrwebFrameIds(tabId) {
+	try {
+		const frames = await chrome.webNavigation.getAllFrames({ tabId });
+		return Array.from(/* @__PURE__ */ new Set([0, ...(frames || []).map((frame) => {
+			return frame.frameId;
+		})]));
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		logger.debug("Could not enumerate rrweb recorder frames:", tabId, message);
+		return [0];
+	}
+}
+async function sendFrameMessage(options) {
+	const response = await chrome.tabs.sendMessage(options.tabId, options.message, { frameId: options.frameId });
+	if (!isRrwebRecorderResponse(response)) return {
+		success: false,
+		error: "Invalid rrweb recorder response"
+	};
+	return response;
+}
+async function sendTabMessage(options) {
+	return await sendFrameMessage({
+		tabId: options.tabId,
+		frameId: 0,
+		message: options.message
+	});
+}
+async function sendTabMessageToAllFrames(options) {
+	const frameIds = await getRrwebFrameIds(options.tabId);
+	return await Promise.all(frameIds.map(async (frameId) => {
+		try {
+			return {
+				frameId,
+				response: await sendFrameMessage({
+					tabId: options.tabId,
+					frameId,
+					message: options.message
+				})
+			};
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			logger.debug("rrweb recorder frame message failed:", options.tabId, frameId, message);
+			return {
+				frameId,
+				response: {
+					success: false,
+					error: message
+				}
+			};
+		}
+	}));
+}
+function pickPrimaryRecorderResponse(results) {
+	const topFrameResponse = results.find((result) => {
+		return result.frameId === 0 && result.response.success;
+	})?.response;
+	if (topFrameResponse) return topFrameResponse;
+	const firstSuccessfulResponse = results.find((result) => {
+		return result.response.success;
+	})?.response;
+	if (firstSuccessfulResponse) return firstSuccessfulResponse;
+	return {
+		success: false,
+		error: results.find(isFailedRrwebFrameMessageResult)?.response.error || "No rrweb recorder frame responded"
+	};
+}
+async function injectRrwebRecorder(tabId) {
+	await chrome.scripting.executeScript({
+		target: {
+			tabId,
+			allFrames: true
+		},
+		files: ["rrweb-recorder.js"]
+	});
+}
+async function ensureRrwebRecorderReady(tabId) {
+	try {
+		await injectRrwebRecorder(tabId);
+	} catch (error) {
+		logger.debug("rrweb recorder all-frame injection failed before status check:", error);
+	}
+	try {
+		const response = await sendTabMessage({
+			tabId,
+			message: { action: "playwriterRrwebStatus" }
+		});
+		if (response.success) return;
+		throw new Error(response.error);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error("rrweb recorder content script is not available for this tab.", { cause: new Error(message) });
+	}
+}
+async function startRecorderInTab(options) {
+	await ensureRrwebRecorderReady(options.tabId);
+	return pickPrimaryRecorderResponse(await sendTabMessageToAllFrames({
+		tabId: options.tabId,
+		message: {
+			action: "playwriterRrwebStart",
+			params: {
+				...options.params,
+				startedAt: options.startedAt
+			}
+		}
+	}));
+}
+async function handleStartRrwebRecording(params) {
+	const tabId = resolveTabIdFromSessionId(params.sessionId);
+	if (!tabId) return {
+		success: false,
+		error: "No connected tab found for rrweb recording. Click the Tabwright extension icon on the tab you want to record."
+	};
+	if (activeRrwebRecordings.has(tabId)) return {
+		success: false,
+		error: "rrweb recording already in progress for this tab"
+	};
+	const tabInfo = store.getState().tabs.get(tabId);
+	if (!tabInfo || tabInfo.state !== "connected") return {
+		success: false,
+		error: "Tab is not connected"
+	};
+	const startedAt = Date.now();
+	logger.debug("Starting rrweb recording for tab:", tabId, "params:", params);
+	try {
+		const response = await startRecorderInTab({
+			tabId,
+			startedAt,
+			params
+		});
+		if (!response.success) return {
+			success: false,
+			error: response.error || "Failed to start rrweb recorder"
+		};
+		activeRrwebRecordings.set(tabId, {
+			tabId,
+			startedAt,
+			options: params,
+			url: response.url
+		});
+		logger.debug("rrweb recording started for tab:", tabId, "url:", response.url);
+		return {
+			success: true,
+			tabId,
+			startedAt,
+			url: response.url
+		};
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		logger.error("Failed to start rrweb recording:", error);
+		return {
+			success: false,
+			error: errorMessage
+		};
+	}
+}
+async function handleStopRrwebRecording(params) {
+	const tabId = resolveTabIdFromSessionId(params.sessionId);
+	if (!tabId) return {
+		success: false,
+		error: "No connected tab found"
+	};
+	const recording = activeRrwebRecordings.get(tabId);
+	if (!recording) return {
+		success: false,
+		error: "No active rrweb recording for this tab"
+	};
+	logger.debug("Stopping rrweb recording for tab:", tabId);
+	try {
+		const response = pickPrimaryRecorderResponse(await sendTabMessageToAllFrames({
+			tabId,
+			message: { action: "playwriterRrwebStop" }
+		}));
+		if (!response.success) return {
+			success: false,
+			error: response.error || "Failed to stop rrweb recorder"
+		};
+		activeRrwebRecordings.delete(tabId);
+		const duration = response.duration || Date.now() - recording.startedAt;
+		logger.debug("rrweb recording stopped for tab:", tabId, "duration:", duration);
+		return {
+			success: true,
+			tabId,
+			duration
+		};
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		logger.error("Failed to stop rrweb recording:", error);
+		return {
+			success: false,
+			error: errorMessage
+		};
+	}
+}
+async function handleIsRrwebRecording(params) {
+	const tabId = resolveTabIdFromSessionId(params.sessionId);
+	if (!tabId) return { isRecording: false };
+	const recording = activeRrwebRecordings.get(tabId);
+	if (!recording) return {
+		isRecording: false,
+		tabId
+	};
+	try {
+		const response = await sendTabMessage({
+			tabId,
+			message: { action: "playwriterRrwebStatus" }
+		});
+		return {
+			isRecording: response.success ? Boolean(response.isRecording) : false,
+			tabId,
+			startedAt: recording.startedAt,
+			url: response.success ? response.url || recording.url : recording.url
+		};
+	} catch {
+		return {
+			isRecording: false,
+			tabId
+		};
+	}
+}
+async function handleCancelRrwebRecording(params) {
+	const tabId = resolveTabIdFromSessionId(params.sessionId);
+	if (!tabId) return {
+		success: false,
+		error: "No connected tab found"
+	};
+	if (!activeRrwebRecordings.get(tabId)) return { success: true };
+	logger.debug("Cancelling rrweb recording for tab:", tabId);
+	try {
+		await sendTabMessageToAllFrames({
+			tabId,
+			message: { action: "playwriterRrwebCancel" }
+		});
+		activeRrwebRecordings.delete(tabId);
+		if (connectionManager.ws?.readyState === WebSocket.OPEN) sendMessage({
+			method: "rrwebRecordingCancelled",
+			params: { tabId }
+		});
+		return { success: true };
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		logger.error("Failed to cancel rrweb recording:", error);
+		return {
+			success: false,
+			error: errorMessage
+		};
+	}
+}
+async function resumeRrwebRecordingForNavigation(tabId) {
+	const recording = activeRrwebRecordings.get(tabId);
+	if (!recording) return;
+	try {
+		const response = await startRecorderInTab({
+			tabId,
+			startedAt: recording.startedAt,
+			params: recording.options
+		});
+		if (response.success) activeRrwebRecordings.set(tabId, {
+			...recording,
+			url: response.url || recording.url
+		});
+		else logger.debug("Could not resume rrweb recorder after navigation:", response.error);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		logger.debug("Could not resume rrweb recorder after navigation:", message);
+	}
+}
+async function cleanupRrwebRecordingForTab(tabId) {
+	if (!activeRrwebRecordings.has(tabId)) return;
+	try {
+		await sendTabMessageToAllFrames({
+			tabId,
+			message: { action: "playwriterRrwebCancel" }
+		});
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		logger.debug("Failed to cancel rrweb recorder during tab cleanup:", tabId, message);
+	}
+	activeRrwebRecordings.delete(tabId);
+	if (connectionManager.ws?.readyState === WebSocket.OPEN) sendMessage({
+		method: "rrwebRecordingCancelled",
+		params: { tabId }
+	});
+}
+//#endregion
+//#region src/background.ts
+var js = dedent;
+var RELAY_HOST = "127.0.0.1";
+var RELAY_PORT = 19988;
+var FAST_CDP_COMMAND_TIMEOUT_MS = /* @__PURE__ */ new Map([
+	["Browser.getWindowForTarget", 1e4],
+	["Page.enable", 1e4],
+	["Page.getFrameTree", 1e4],
+	["Page.setLifecycleEventsEnabled", 1e4],
+	["Page.createIsolatedWorld", 1e4],
+	["Page.setDownloadBehavior", 1e4],
+	["Log.enable", 1e4],
+	["Network.enable", 1e4],
+	["Emulation.setFocusEmulationEnabled", 1e4],
+	["Emulation.setEmulatedMedia", 1e4],
+	["Runtime.runIfWaitingForDebugger", 1e4],
+	["Target.setAutoAttach", 1e4]
+]);
+async function sendCommandWithTimeout(debuggee, method, params, timeout) {
+	let timeoutId;
+	try {
+		return await Promise.race([chrome.debugger.sendCommand(debuggee, method, params), new Promise((_, reject) => {
+			timeoutId = setTimeout(() => {
+				reject(/* @__PURE__ */ new Error(`CDP command timed out after ${timeout}ms: ${method} (tab may be frozen/hibernated)`));
+			}, timeout);
+		})]);
+	} finally {
+		if (timeoutId) clearTimeout(timeoutId);
+	}
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function relayHttpUrl(pathname) {
+	return new URL(pathname, `http://${RELAY_HOST}:${RELAY_PORT}/`).toString();
+}
+async function fetchRelayHead(options) {
+	try {
+		return await fetch(relayHttpUrl(options.pathname), {
+			method: "HEAD",
+			signal: AbortSignal.timeout(2e3)
+		});
+	} catch (error) {
+		throw new RelayConnectionProblemError({
+			issue: "offline",
+			cause: error
+		});
+	}
+}
+async function checkRelayCompatibility() {
+	if (!(await fetchRelayHead({ pathname: "/version" })).ok) throw new RelayConnectionProblemError({ issue: "unavailable" });
+}
+async function probeRelayReviewState() {
+	try {
+		const issue = getRelayReviewIssue({ statuses: (await Promise.all(["/capabilities", "/rrweb-recordings?limit=1"].map((pathname) => {
+			return fetchRelayHead({ pathname });
+		}))).map((response) => {
+			return response.status;
+		}) });
+		if (!issue) return { status: "ready" };
+		return {
+			status: "degraded",
+			issue,
+			errorText: relayReviewIssueText({ issue })
+		};
+	} catch (cause) {
+		const issue = "unavailable";
+		const errorText = relayReviewIssueText({ issue });
+		logger.debug("Relay review endpoints are unavailable:", cause);
+		return {
+			status: "degraded",
+			issue,
+			errorText
+		};
+	}
+}
+function createInstallId() {
+	const values = /* @__PURE__ */ new Uint32Array(2);
+	crypto.getRandomValues(values);
+	return Array.from(values).map((value) => {
+		return value.toString(36);
+	}).join("");
+}
+function browserNameFromBrands(brands) {
+	const brandNames = brands.map((brand) => {
+		return brand.brand.trim().toLowerCase();
+	});
+	if (brandNames.some((brand) => brand === "brave")) return "Brave";
+	if (brandNames.some((brand) => brand === "microsoft edge")) return "Edge";
+	if (brandNames.some((brand) => brand === "opera")) return "Opera";
+	if (brandNames.some((brand) => brand === "vivaldi")) return "Vivaldi";
+	if (brandNames.some((brand) => brand === "google chrome canary")) return "Chrome Canary";
+	if (brandNames.some((brand) => brand === "google chrome")) return "Chrome";
+	if (brandNames.some((brand) => brand === "chromium")) return "Chromium";
+	return null;
+}
+async function detectBrowserName() {
+	if (chrome.ghostPublicAPI) return "Ghost";
+	const navigatorWithUaData = navigator;
+	const brands = navigatorWithUaData.userAgentData?.brands;
+	const highEntropyName = browserNameFromBrands((await navigatorWithUaData.userAgentData?.getHighEntropyValues?.(["fullVersionList"]).catch(() => {
+		return null;
+	}))?.fullVersionList || []);
+	if (highEntropyName) return highEntropyName;
+	if (brands && brands.length > 0) {
+		const lowEntropyName = browserNameFromBrands(brands);
+		if (lowEntropyName) return lowEntropyName;
+	}
+	const ua = navigator.userAgent.toLowerCase();
+	if (ua.includes("edg/")) return "Edge";
+	if (ua.includes("opr/")) return "Opera";
+	if (ua.includes("vivaldi")) return "Vivaldi";
+	if (ua.includes("brave")) return "Brave";
+	if (ua.includes("chrome")) return "Chrome";
+	return "Chromium";
+}
+var identityPromise = null;
+var installIdPromise = null;
+var tabSessionScope = (() => {
+	const values = /* @__PURE__ */ new Uint32Array(2);
+	crypto.getRandomValues(values);
+	return Array.from(values).map((value) => {
+		return value.toString(36);
+	}).join("");
+})();
+async function getInstallId() {
+	if (installIdPromise) return installIdPromise;
+	installIdPromise = (async () => {
+		const existing = await chrome.storage.local.get("playwriterInstallId");
+		const storedInstallId = typeof existing.playwriterInstallId === "string" ? existing.playwriterInstallId : "";
+		if (storedInstallId) return storedInstallId;
+		const installId = createInstallId();
+		await chrome.storage.local.set({ playwriterInstallId: installId });
+		return installId;
+	})().catch((error) => {
+		installIdPromise = null;
+		throw error;
+	});
+	return installIdPromise;
+}
+async function getExtensionIdentity() {
+	if (identityPromise) return identityPromise;
+	identityPromise = (async () => {
+		const browser = await detectBrowserName();
+		const installId = await getInstallId().catch(() => {
+			return tabSessionScope;
+		});
+		try {
+			const info = await chrome.identity.getProfileUserInfo({ accountStatus: "ANY" });
+			return {
+				browser,
+				email: info.email || "",
+				id: info.id || "",
+				installId
+			};
+		} catch {
+			return {
+				browser,
+				email: "",
+				id: "",
+				installId
+			};
+		}
+	})();
+	return identityPromise;
+}
+var TAB_GROUP_COLOR = "green";
+var TAB_GROUP_TITLE = "Tabwright";
+var childSessions = /* @__PURE__ */ new Map();
+var nextSessionId = 1;
+var tabGroupQueue = Promise.resolve();
+var autoAttachParams = null;
+var toolbarRecordingPendingRequests = /* @__PURE__ */ new Map();
+var nextToolbarRecordingRequestId = 1;
+function isToolbarRecordingMessage(message) {
+	if (!message || typeof message !== "object") return false;
+	const candidate = message;
+	return candidate.action === "playwriterToolbarRecordingStatus" || candidate.action === "playwriterToolbarToggleRecording";
+}
+function isToolbarRecordingPortMessage(message) {
+	if (!isToolbarRecordingMessage(message)) return false;
+	return typeof message.requestId === "string";
+}
+function getToolbarTabSessionId(sender) {
+	const tabId = sender.tab?.id;
+	if (!tabId) return void 0;
+	return store.getState().tabs.get(tabId)?.sessionId;
+}
+function handleToolbarRecordingResponse(message) {
+	logger.debug("Toolbar recording response received:", message.params.requestId, message.params.result);
+	const pending = toolbarRecordingPendingRequests.get(message.params.requestId);
+	if (!pending) {
+		logger.debug("Toolbar recording response has no pending request:", message.params.requestId);
+		return;
+	}
+	clearTimeout(pending.timeoutId);
+	toolbarRecordingPendingRequests.delete(message.params.requestId);
+	pending.resolve(message.params.result);
+}
+function requestToolbarRecording(options) {
+	const sessionId = getToolbarTabSessionId(options.sender);
+	if (!sessionId) return Promise.resolve({
+		success: false,
+		isRecording: false,
+		error: "Tabwright tab is not connected"
+	});
+	if (connectionManager.ws?.readyState !== WebSocket.OPEN) return Promise.resolve({
+		success: false,
+		isRecording: false,
+		error: "Tabwright relay is not connected"
+	});
+	const requestId = `toolbar-recording-${Date.now()}-${nextToolbarRecordingRequestId++}`;
+	logger.debug("Toolbar recording request:", requestId, options.action, "sessionId:", sessionId);
+	return new Promise((resolve, reject) => {
+		const timeoutId = setTimeout(() => {
+			toolbarRecordingPendingRequests.delete(requestId);
+			logger.debug("Toolbar recording request timed out:", requestId, options.action);
+			reject(/* @__PURE__ */ new Error("Timed out waiting for relay recording response"));
+		}, 12e4);
+		toolbarRecordingPendingRequests.set(requestId, {
+			resolve,
+			reject,
+			timeoutId
+		});
+		sendMessage({
+			method: "toolbarRecordingRequest",
+			params: {
+				requestId,
+				action: options.action,
+				sessionId
+			}
+		});
+	});
+}
+async function getToolbarRecordingStatus(sender) {
+	return requestToolbarRecording({
+		sender,
+		action: "status"
+	});
+}
+async function toggleToolbarRecording(sender) {
+	return requestToolbarRecording({
+		sender,
+		action: "toggle"
+	});
+}
+function postToolbarRecordingPortResponse(options) {
+	try {
+		options.port.postMessage(options.response);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		logger.debug("Toolbar recording port response failed:", message);
+	}
+}
+function handleToolbarRecordingPortMessage(options) {
+	const sender = options.port.sender;
+	if (!sender) {
+		postToolbarRecordingPortResponse({
+			port: options.port,
+			response: {
+				requestId: options.message.requestId,
+				result: {
+					success: false,
+					isRecording: false,
+					error: "Tabwright toolbar port has no sender"
+				}
+			}
+		});
+		return;
+	}
+	logger.debug("Toolbar port message received:", options.message.action, "tabId:", sender.tab?.id);
+	(options.message.action === "playwriterToolbarToggleRecording" ? toggleToolbarRecording(sender) : getToolbarRecordingStatus(sender)).then((result) => {
+		logger.debug("Toolbar port message response:", options.message.action, result);
+		postToolbarRecordingPortResponse({
+			port: options.port,
+			response: {
+				requestId: options.message.requestId,
+				result
+			}
+		});
+	}).catch((error) => {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		logger.debug("Toolbar port message failed:", options.message.action, errorMessage);
+		postToolbarRecordingPortResponse({
+			port: options.port,
+			response: {
+				requestId: options.message.requestId,
+				result: {
+					success: false,
+					isRecording: false,
+					error: errorMessage
+				}
+			}
+		});
+	});
+}
+function rejectToolbarRecordingRequests(error) {
+	for (const [requestId, pending] of toolbarRecordingPendingRequests) {
+		clearTimeout(pending.timeoutId);
+		pending.reject(error);
+		toolbarRecordingPendingRequests.delete(requestId);
+	}
+}
+function isToolbarRecordingResponseMessage(message) {
+	if (!message || typeof message !== "object") return false;
+	const candidate = message;
+	return candidate.method === "toolbarRecordingResponse" && typeof candidate.params?.requestId === "string" && Boolean(candidate.params.result);
+}
+function injectToolbar(tabId) {
+	chrome.scripting.executeScript({
+		target: {
+			tabId,
+			allFrames: false
+		},
+		world: "ISOLATED",
+		func: initTabwrightToolbarBridge
+	}).catch((err) => {
+		logger.debug("Could not inject toolbar bridge (restricted page):", err.message);
+	}).then(() => {
+		return chrome.scripting.executeScript({
+			target: {
+				tabId,
+				allFrames: false
+			},
+			world: "MAIN",
+			func: initTabwrightToolbar
+		});
+	}).catch((err) => {
+		logger.debug("Could not inject toolbar (restricted page):", err.message);
+	});
+}
+var ConnectionManager = class {
+	connectionOwnership = new ConnectionOwnership();
+	connectionPromise = null;
+	lastRelayReviewProbeAt = 0;
+	preserveTabsOnDetach = false;
+	get ws() {
+		return this.connectionOwnership.current;
+	}
+	async refreshRelayReviewState(options) {
+		this.lastRelayReviewProbeAt = Date.now();
+		const relayReviewState = await probeRelayReviewState();
+		if (!this.connectionOwnership.isCurrentConnection(options.socket)) return;
+		store.setState({ relayReviewState });
+	}
+	async ensureConnection() {
+		if (this.ws?.readyState === WebSocket.OPEN) return;
+		if (store.getState().connectionState === "extension-replaced") throw new Error("Another Tabwright extension is already connected");
+		if (this.connectionPromise) return this.connectionPromise;
+		const GLOBAL_TIMEOUT_MS = 15e3;
+		const generation = this.connectionOwnership.beginAttempt();
+		let globalTimeoutId;
+		const connectionPromise = Promise.race([this.connect({ generation }), new Promise((_, reject) => {
+			globalTimeoutId = setTimeout(() => {
+				this.connectionOwnership.invalidateAttempt(generation);
+				reject(/* @__PURE__ */ new Error("Connection timeout (global)"));
+			}, GLOBAL_TIMEOUT_MS);
+		})]);
+		this.connectionPromise = connectionPromise;
+		try {
+			await connectionPromise;
+		} finally {
+			if (globalTimeoutId) clearTimeout(globalTimeoutId);
+			if (this.connectionPromise === connectionPromise) this.connectionPromise = null;
+		}
+	}
+	async connect(options) {
+		logger.debug(`Waiting for server at http://${RELAY_HOST}:${RELAY_PORT}...`);
+		const maxAttempts = 5;
+		for (let attempt = 0; attempt < maxAttempts; attempt++) try {
+			await fetch(relayHttpUrl("/"), {
+				method: "HEAD",
+				signal: AbortSignal.timeout(2e3)
+			});
+			logger.debug("Server is available");
+			break;
+		} catch (error) {
+			if (attempt === maxAttempts - 1) throw new RelayConnectionProblemError({
+				issue: "offline",
+				cause: error
+			});
+			logger.debug(`Server not available, retrying... (attempt ${attempt + 1}/${maxAttempts})`);
+			await sleep(1e3);
+		}
+		await checkRelayCompatibility();
+		const identity = await getExtensionIdentity();
+		if (!this.connectionOwnership.isCurrentAttempt(options.generation)) throw new Error("Connection attempt superseded");
+		const relayUrl = new URL(`ws://${RELAY_HOST}:${RELAY_PORT}/extension`);
+		if (identity.browser) relayUrl.searchParams.set("browser", identity.browser);
+		if (identity.email) relayUrl.searchParams.set("email", identity.email);
+		if (identity.id) relayUrl.searchParams.set("id", identity.id);
+		if (identity.installId) relayUrl.searchParams.set("installId", identity.installId);
+		relayUrl.searchParams.set("v", "1.0.0");
+		relayUrl.searchParams.set("protocolVersion", String(1));
+		relayUrl.searchParams.set("features", CURRENT_EXTENSION_FEATURES.join(","));
+		logger.debug("Creating WebSocket connection to:", relayUrl);
+		const socket = new WebSocket(relayUrl.toString());
+		await new Promise((resolve, reject) => {
+			let settled = false;
+			const timeout = setTimeout(() => {
+				if (settled) return;
+				settled = true;
+				logger.debug("WebSocket connection TIMEOUT after 5 seconds");
+				try {
+					socket.close();
+				} catch {}
+				reject(/* @__PURE__ */ new Error("Connection timeout"));
+			}, 5e3);
+			socket.onopen = () => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timeout);
+				if (!this.connectionOwnership.claimOpenedConnection({
+					generation: options.generation,
+					connection: socket
+				})) {
+					try {
+						socket.close(1e3, "Connection attempt superseded");
+					} catch {}
+					reject(/* @__PURE__ */ new Error("Connection attempt superseded"));
+					return;
+				}
+				logger.debug("WebSocket connected");
+				resolve();
+			};
+			socket.onerror = (error) => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timeout);
+				if (!this.connectionOwnership.isCurrentAttempt(options.generation)) {
+					reject(/* @__PURE__ */ new Error("Connection attempt superseded"));
+					return;
+				}
+				logger.debug("WebSocket error during connection:", error);
+				reject(/* @__PURE__ */ new Error("WebSocket connection failed"));
+			};
+			socket.onclose = (event) => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timeout);
+				if (!this.connectionOwnership.isCurrentAttempt(options.generation)) {
+					reject(/* @__PURE__ */ new Error("Connection attempt superseded"));
+					return;
+				}
+				logger.debug("WebSocket closed during connection:", {
+					code: event.code,
+					reason: event.reason
+				});
+				if (event.code === 4002 || event.reason === "Extension Already In Use") reject(/* @__PURE__ */ new Error("Extension Already In Use"));
+				else reject(/* @__PURE__ */ new Error(`WebSocket closed: ${event.reason || event.code}`));
+			};
+		});
+		const isCurrentSocket = () => {
+			return this.connectionOwnership.isCurrentConnection(socket);
+		};
+		const sendCurrentSocketMessage = (message) => {
+			if (!isCurrentSocket()) return;
+			sendMessage(message);
+		};
+		socket.onmessage = async (event) => {
+			if (!isCurrentSocket()) return;
+			let message;
+			try {
+				message = JSON.parse(event.data);
+			} catch (error) {
+				logger.debug("Error parsing message:", error);
+				sendCurrentSocketMessage({ error: {
+					code: -32700,
+					message: `Error parsing message: ${error.message}`
+				} });
+				return;
+			}
+			if (message.method === "ping") {
+				sendCurrentSocketMessage({ method: "pong" });
+				return;
+			}
+			if (isToolbarRecordingResponseMessage(message)) {
+				handleToolbarRecordingResponse(message);
+				return;
+			}
+			if (message.method === "createInitialTab") {
+				try {
+					logger.debug("Creating initial tab for Playwright client");
+					const tab = await createTabInPreferredWindow({
+						url: "about:blank",
+						active: false
+					});
+					if (tab.id) {
+						setTabConnecting(tab.id);
+						const { targetInfo, sessionId } = await attachTab(tab.id, { skipAttachedEvent: true });
+						logger.debug("Initial tab created and connected:", tab.id, "sessionId:", sessionId);
+						sendCurrentSocketMessage({
+							id: message.id,
+							result: {
+								success: true,
+								tabId: tab.id,
+								sessionId,
+								targetInfo
+							}
+						});
+					} else throw new Error("Failed to create tab - no tab ID returned");
+				} catch (error) {
+					logger.debug("Failed to create initial tab:", error);
+					sendCurrentSocketMessage({
+						id: message.id,
+						error: error.message
+					});
+				}
+				return;
+			}
+			if (message.method === "startRecording" || message.method === "stopRecording" || message.method === "cancelRecording") {
+				sendCurrentSocketMessage({
+					id: message.id,
+					result: {
+						success: false,
+						error: "Legacy video recording has been removed. Use rrweb replay recording instead."
+					}
+				});
+				return;
+			}
+			if (message.method === "isRecording") {
+				sendCurrentSocketMessage({
+					id: message.id,
+					result: { isRecording: false }
+				});
+				return;
+			}
+			if (message.method === "startRrwebRecording") {
+				try {
+					const result = await handleStartRrwebRecording(message.params);
+					sendCurrentSocketMessage({
+						id: message.id,
+						result
+					});
+				} catch (error) {
+					const errorMessage = error instanceof Error ? error.message : String(error);
+					logger.error("Failed to start rrweb recording:", error);
+					sendCurrentSocketMessage({
+						id: message.id,
+						result: {
+							success: false,
+							error: errorMessage
+						}
+					});
+				}
+				return;
+			}
+			if (message.method === "stopRrwebRecording") {
+				try {
+					const result = await handleStopRrwebRecording(message.params);
+					sendCurrentSocketMessage({
+						id: message.id,
+						result
+					});
+				} catch (error) {
+					const errorMessage = error instanceof Error ? error.message : String(error);
+					logger.error("Failed to stop rrweb recording:", error);
+					sendCurrentSocketMessage({
+						id: message.id,
+						result: {
+							success: false,
+							error: errorMessage
+						}
+					});
+				}
+				return;
+			}
+			if (message.method === "isRrwebRecording") {
+				try {
+					const result = await handleIsRrwebRecording(message.params);
+					sendCurrentSocketMessage({
+						id: message.id,
+						result
+					});
+				} catch (error) {
+					logger.error("Failed to check rrweb recording status:", error);
+					sendCurrentSocketMessage({
+						id: message.id,
+						result: { isRecording: false }
+					});
+				}
+				return;
+			}
+			if (message.method === "cancelRrwebRecording") {
+				try {
+					const result = await handleCancelRrwebRecording(message.params);
+					sendCurrentSocketMessage({
+						id: message.id,
+						result
+					});
+				} catch (error) {
+					const errorMessage = error instanceof Error ? error.message : String(error);
+					logger.error("Failed to cancel rrweb recording:", error);
+					sendCurrentSocketMessage({
+						id: message.id,
+						result: {
+							success: false,
+							error: errorMessage
+						}
+					});
+				}
+				return;
+			}
+			if (message.method === "ghost-browser") {
+				const params = message.params;
+				const result = await handleGhostBrowserCommand(params, chrome);
+				if (!result.success) logger.error("Ghost Browser API error:", result.error);
+				if (result.success && params.namespace === "ghostPublicAPI" && params.method === "openTab") {
+					const tabId = result.result;
+					if (tabId) {
+						logger.debug("Auto-connecting Ghost Browser tab:", tabId);
+						setTabConnecting(tabId);
+						await sleep(100);
+						await attachTab(tabId);
+					}
+				}
+				sendCurrentSocketMessage({
+					id: message.id,
+					result
+				});
+				return;
+			}
+			const response = { id: message.id };
+			try {
+				response.result = await handleCommand(message);
+			} catch (error) {
+				logger.debug("Error handling command:", error);
+				response.error = error.message;
+			}
+			sendCurrentSocketMessage(response);
+		};
+		socket.onclose = (event) => {
+			if (!isCurrentSocket()) return;
+			this.handleClose({
+				socket,
+				reason: event.reason,
+				code: event.code
+			});
+		};
+		socket.onerror = (event) => {
+			if (!isCurrentSocket()) return;
+			logger.debug("WebSocket error:", event);
+		};
+		chrome.debugger.onEvent.addListener(onDebuggerEvent);
+		chrome.debugger.onDetach.addListener(onDebuggerDetach);
+		this.refreshRelayReviewState({ socket });
+		logger.debug("Connection established");
+	}
+	handleClose(options) {
+		if (!this.connectionOwnership.releaseConnection(options.socket)) return;
+		const { reason, code } = options;
+		rejectToolbarRecordingRequests(/* @__PURE__ */ new Error(`Tabwright relay disconnected: ${reason || code}`));
+		try {
+			const mem = performance.memory;
+			if (mem) {
+				const formatMB = (b) => (b / 1024 / 1024).toFixed(2) + "MB";
+				logger.warn(`DISCONNECT MEMORY: used=${formatMB(mem.usedJSHeapSize)} total=${formatMB(mem.totalJSHeapSize)} limit=${formatMB(mem.jsHeapSizeLimit)}`);
+			}
+		} catch {}
+		logger.warn(`DISCONNECT: WS closed code=${code} reason=${reason || "none"} stack=${getCallStack()}`);
+		chrome.debugger.onEvent.removeListener(onDebuggerEvent);
+		chrome.debugger.onDetach.removeListener(onDebuggerDetach);
+		const isExtensionReplaced = reason === "Extension Replaced" || code === 4001;
+		const isExtensionInUse = reason === "Extension Already In Use" || code === 4002;
+		this.preserveTabsOnDetach = !(isExtensionReplaced || isExtensionInUse);
+		const { tabs } = store.getState();
+		for (const [tabId] of tabs) chrome.debugger.detach({ tabId }).catch((err) => {
+			logger.debug("Error detaching from tab:", tabId, err.message);
+		});
+		childSessions.clear();
+		if (isExtensionReplaced) {
+			logger.debug("Disconnected: another Tabwright extension connected (this one was idle)");
+			store.setState({
+				tabs: /* @__PURE__ */ new Map(),
+				connectionState: "extension-replaced",
+				errorText: "Another Tabwright extension took over the connection"
+			});
+			return;
+		}
+		if (isExtensionInUse) {
+			logger.debug("Rejected: another Tabwright extension is actively in use");
+			store.setState({
+				tabs: /* @__PURE__ */ new Map(),
+				connectionState: "extension-replaced",
+				errorText: "Another Tabwright extension is actively in use"
+			});
+			return;
+		}
+		store.setState((state) => {
+			const newTabs = new Map(state.tabs);
+			for (const [tabId, tab] of newTabs) newTabs.set(tabId, {
+				...tab,
+				state: "connecting"
+			});
+			return {
+				tabs: newTabs,
+				connectionState: "idle",
+				errorText: void 0
+			};
+		});
+	}
+	async maintainLoop() {
+		while (true) {
+			const openSocket = this.ws;
+			if (openSocket?.readyState === WebSocket.OPEN) {
+				if (Date.now() - this.lastRelayReviewProbeAt >= 3e4) this.refreshRelayReviewState({ socket: openSocket });
+				await sleep(1e3);
+				continue;
+			}
+			if (store.getState().connectionState === "extension-replaced") {
+				try {
+					const data = await (await fetch(`http://${RELAY_HOST}:${RELAY_PORT}/extension/status`, {
+						method: "GET",
+						signal: AbortSignal.timeout(2e3)
+					})).json();
+					if (!data.connected) {
+						store.setState({
+							connectionState: "idle",
+							errorText: void 0
+						});
+						logger.debug("Extension slot is free (connected:", data.connected, "activeTargets:", data.activeTargets, "), cleared error state");
+					} else logger.debug("Extension slot still taken (activeTargets:", data.activeTargets, "), will retry...");
+				} catch {
+					logger.debug("Server not available, will retry...");
+				}
+				await sleep(3e3);
+				continue;
+			}
+			const currentTabs = store.getState().tabs;
+			if (Array.from(currentTabs.values()).some((t) => t.state === "connected")) store.setState((state) => {
+				const newTabs = new Map(state.tabs);
+				for (const [tabId, tab] of newTabs) if (tab.state === "connected") newTabs.set(tabId, {
+					...tab,
+					state: "connecting"
+				});
+				return { tabs: newTabs };
+			});
+			try {
+				await this.ensureConnection();
+				store.setState({ connectionState: "connected" });
+				const tabsToReattach = Array.from(store.getState().tabs.entries()).filter(([_, tab]) => tab.state === "connecting").map(([tabId]) => tabId);
+				for (const tabId of tabsToReattach) {
+					const currentTab = store.getState().tabs.get(tabId);
+					if (!currentTab || currentTab.state !== "connecting") {
+						logger.debug("Skipping reattach, tab state changed:", tabId, currentTab?.state);
+						continue;
+					}
+					try {
+						await chrome.tabs.get(tabId);
+						await attachTab(tabId);
+						logger.debug("Successfully re-attached tab:", tabId);
+					} catch (error) {
+						logger.debug("Failed to re-attach tab:", tabId, error.message);
+						store.setState((state) => {
+							const newTabs = new Map(state.tabs);
+							newTabs.delete(tabId);
+							return { tabs: newTabs };
+						});
+					}
+				}
+				this.preserveTabsOnDetach = false;
+			} catch (error) {
+				const errorMessage = error instanceof Error ? error.message : String(error);
+				logger.debug("Connection attempt failed:", errorMessage);
+				if (error instanceof RelayConnectionProblemError) store.setState({
+					connectionState: "relay-warning",
+					errorText: error.message
+				});
+				else if (errorMessage === "Extension Already In Use") store.setState({
+					connectionState: "extension-replaced",
+					errorText: "Another Tabwright extension is actively in use"
+				});
+				else store.setState({ connectionState: "idle" });
+			}
+			await sleep(3e3);
+		}
+	}
+};
+var connectionManager = new ConnectionManager();
+var store = createStore(() => ({
+	tabs: /* @__PURE__ */ new Map(),
+	connectionState: "idle",
+	relayReviewState: { status: "unknown" },
+	currentTabId: void 0,
+	preferredWindowId: void 0,
+	errorText: void 0
+}));
+globalThis.toggleExtensionForActiveTab = toggleExtensionForActiveTab;
+globalThis.disconnectEverything = disconnectEverything;
+globalThis.getExtensionState = () => store.getState();
+var MAX_LOG_STRING_LENGTH = 2e3;
+function truncateLogString(value) {
+	if (value.length <= MAX_LOG_STRING_LENGTH) return value;
+	return `${value.slice(0, MAX_LOG_STRING_LENGTH)}…[truncated ${value.length - MAX_LOG_STRING_LENGTH} chars]`;
+}
+function safeSerialize(arg) {
+	if (arg === void 0) return "undefined";
+	if (arg === null) return "null";
+	if (typeof arg === "function") return `[Function: ${arg.name || "anonymous"}]`;
+	if (typeof arg === "symbol") return String(arg);
+	if (typeof arg === "string") return truncateLogString(arg);
+	if (arg instanceof Error) return truncateLogString(arg.stack || arg.message || String(arg));
+	if (typeof arg === "object") try {
+		const seen = /* @__PURE__ */ new WeakSet();
+		return truncateLogString(JSON.stringify(arg, (key, value) => {
+			if (typeof value === "object" && value !== null) {
+				if (seen.has(value)) return "[Circular]";
+				seen.add(value);
+				if (value instanceof Map) return {
+					dataType: "Map",
+					value: Array.from(value.entries())
+				};
+				if (value instanceof Set) return {
+					dataType: "Set",
+					value: Array.from(value.values())
+				};
+			}
+			return value;
+		}));
+	} catch {
+		return truncateLogString(String(arg));
+	}
+	return truncateLogString(String(arg));
+}
+function sendLog(level, args) {
+	sendMessage({
+		method: "log",
+		params: {
+			level,
+			args: args.map(safeSerialize)
+		}
+	});
+}
+var logger = {
+	log: (...args) => {
+		console.log(...args);
+		sendLog("log", args);
+	},
+	debug: (...args) => {
+		console.debug(...args);
+		sendLog("debug", args);
+	},
+	info: (...args) => {
+		console.info(...args);
+		sendLog("info", args);
+	},
+	warn: (...args) => {
+		console.warn(...args);
+		sendLog("warn", args);
+	},
+	error: (...args) => {
+		console.error(...args);
+		sendLog("error", args);
+	}
+};
+function getCallStack() {
+	return ((/* @__PURE__ */ new Error()).stack || "").split("\n").slice(2, 6).join(" <- ").replace(/\s+/g, " ");
+}
+self.addEventListener("error", (event) => {
+	const stack = event.error?.stack || `${event.message} at ${event.filename}:${event.lineno}:${event.colno}`;
+	logger.error("Uncaught error:", stack);
+});
+self.addEventListener("unhandledrejection", (event) => {
+	const reason = event.reason;
+	const stack = reason?.stack || String(reason);
+	logger.error("Unhandled promise rejection:", stack);
+});
+var messageCount = 0;
+function sendMessage(message) {
+	if (connectionManager.ws?.readyState === WebSocket.OPEN) try {
+		connectionManager.ws.send(JSON.stringify(message));
+		if (++messageCount % 100 === 0) checkMemory();
+	} catch (error) {
+		console.debug("ERROR sending message:", error, "message type:", message.method || "response");
+	}
+}
+async function getPreferredWindowId() {
+	const { preferredWindowId, currentTabId } = store.getState();
+	if (preferredWindowId !== void 0) try {
+		await chrome.windows.get(preferredWindowId);
+		return preferredWindowId;
+	} catch {
+		store.setState({ preferredWindowId: void 0 });
+	}
+	if (currentTabId !== void 0) try {
+		const tab = await chrome.tabs.get(currentTabId);
+		if (tab.windowId !== void 0) return tab.windowId;
+	} catch {}
+	try {
+		return (await chrome.windows.getLastFocused({ populate: false })).id;
+	} catch {
+		return;
+	}
+}
+async function createTabInPreferredWindow(options) {
+	const windowId = await getPreferredWindowId();
+	const createProperties = {
+		url: options.url,
+		active: options.active,
+		...windowId !== void 0 ? { windowId } : {}
+	};
+	try {
+		return await chrome.tabs.create(createProperties);
+	} catch (error) {
+		logger.debug("Could not create tab in preferred window, falling back:", error.message);
+		return await chrome.tabs.create({
+			url: options.url,
+			active: options.active
+		});
+	}
+}
+async function syncTabGroup() {
+	try {
+		const { connectionState } = store.getState();
+		const isRelayConnected = connectionState === "connected";
+		const connectedTabIds = Array.from(store.getState().tabs.entries()).filter(([_, info]) => info.state === "connected" || info.state === "connecting" && isRelayConnected).map(([tabId]) => tabId);
+		const existingGroups = await chrome.tabGroups.query({ title: TAB_GROUP_TITLE });
+		if (connectedTabIds.length === 0) {
+			for (const group of existingGroups) {
+				const tabIdsToUngroup = (await chrome.tabs.query({ groupId: group.id })).map((t) => t.id).filter((id) => id !== void 0);
+				if (tabIdsToUngroup.length > 0) await chrome.tabs.ungroup(tabIdsToUngroup);
+				logger.debug("Cleared Tabwright group:", group.id);
+			}
+			return;
+		}
+		let groupId = existingGroups[0]?.id;
+		if (existingGroups.length > 1) {
+			const [keep, ...duplicates] = existingGroups;
+			groupId = keep.id;
+			for (const group of duplicates) {
+				const tabIdsToUngroup = (await chrome.tabs.query({ groupId: group.id })).map((t) => t.id).filter((id) => id !== void 0);
+				if (tabIdsToUngroup.length > 0) await chrome.tabs.ungroup(tabIdsToUngroup);
+				logger.debug("Removed duplicate Tabwright group:", group.id);
+			}
+		}
+		const tabsInGroup = (await chrome.tabs.query({})).filter((t) => t.groupId === groupId && t.id !== void 0);
+		const tabIdsInGroup = new Set(tabsInGroup.map((t) => t.id));
+		const tabsToAdd = connectedTabIds.filter((id) => !tabIdsInGroup.has(id));
+		const tabsToRemove = Array.from(tabIdsInGroup).filter((id) => !connectedTabIds.includes(id));
+		if (tabsToRemove.length > 0) try {
+			await chrome.tabs.ungroup(tabsToRemove);
+			logger.debug("Removed tabs from group:", tabsToRemove);
+		} catch (e) {
+			logger.debug("Failed to ungroup tabs:", tabsToRemove, e.message);
+		}
+		if (tabsToAdd.length > 0) if (groupId === void 0) {
+			const newGroupId = await chrome.tabs.group({ tabIds: tabsToAdd });
+			await chrome.tabGroups.update(newGroupId, {
+				title: TAB_GROUP_TITLE,
+				color: TAB_GROUP_COLOR
+			});
+			logger.debug("Created tab group:", newGroupId, "with tabs:", tabsToAdd);
+		} else {
+			await chrome.tabs.group({
+				tabIds: tabsToAdd,
+				groupId
+			});
+			await chrome.tabGroups.update(groupId, {
+				title: TAB_GROUP_TITLE,
+				color: TAB_GROUP_COLOR
+			});
+			logger.debug("Added tabs to existing group:", tabsToAdd);
+		}
+		else if (groupId !== void 0) await chrome.tabGroups.update(groupId, {
+			title: TAB_GROUP_TITLE,
+			color: TAB_GROUP_COLOR
+		});
+	} catch (error) {
+		logger.debug("Failed to sync tab group:", error.message);
+	}
+}
+function getTabBySessionId(sessionId) {
+	for (const [tabId, tab] of store.getState().tabs) if (tab.sessionId === sessionId) return {
+		tabId,
+		tab
+	};
+}
+function getTabByTargetId(targetId) {
+	for (const [tabId, tab] of store.getState().tabs) if (tab.targetId === targetId) return {
+		tabId,
+		tab
+	};
+}
+function emitChildDetachesForTab(tabId) {
+	Array.from(childSessions.entries()).filter(([_, parentTab]) => parentTab.tabId === tabId).forEach(([childSessionId, parentTab]) => {
+		sendMessage({
+			method: "forwardCDPEvent",
+			params: {
+				method: "Target.detachedFromTarget",
+				params: parentTab.targetId ? {
+					sessionId: childSessionId,
+					targetId: parentTab.targetId
+				} : { sessionId: childSessionId }
+			}
+		});
+		logger.debug("Cleaning up child session:", childSessionId, "for tab:", tabId);
+		childSessions.delete(childSessionId);
+	});
+}
+function getTabForCommand(msg) {
+	const sessionId = msg.params.sessionId;
+	if (sessionId) {
+		const found = getTabBySessionId(sessionId);
+		if (found) return found;
+		const child = childSessions.get(sessionId);
+		if (child) {
+			const tab = store.getState().tabs.get(child.tabId);
+			if (tab) return {
+				tabId: child.tabId,
+				tab
+			};
+		}
+	}
+	const paramsSessionId = msg.params.params && "sessionId" in msg.params.params && typeof msg.params.params.sessionId === "string" ? msg.params.params.sessionId : void 0;
+	if (paramsSessionId) {
+		const found = getTabBySessionId(paramsSessionId);
+		if (found) return found;
+		const child = childSessions.get(paramsSessionId);
+		if (child) {
+			const tab = store.getState().tabs.get(child.tabId);
+			if (tab) return {
+				tabId: child.tabId,
+				tab
+			};
+		}
+	}
+	const targetId = msg.params.params && "targetId" in msg.params.params && typeof msg.params.params.targetId === "string" ? msg.params.params.targetId : void 0;
+	if (targetId) return getTabByTargetId(targetId);
+}
+async function handleCommand(msg) {
+	if (msg.method !== "forwardCDPCommand") return;
+	const resolved = getTabForCommand(msg);
+	let targetTabId = resolved?.tabId;
+	let targetTab = resolved?.tab;
+	const debuggee = targetTabId ? { tabId: targetTabId } : void 0;
+	if (msg.params.method === "Target.setAutoAttach" && !msg.params.sessionId) {
+		const params = msg.params.params;
+		if (!params) return {};
+		autoAttachParams = params;
+		const connectedTabIds = Array.from(store.getState().tabs.entries()).filter(([_, info]) => info.state === "connected").map(([tabId]) => tabId);
+		await Promise.all(connectedTabIds.map(async (tabId) => {
+			try {
+				await sendCommandWithTimeout({ tabId }, "Target.setAutoAttach", params, 1e4);
+			} catch (error) {
+				logger.debug("Failed to set auto-attach for tab:", tabId, error);
+			}
+		}));
+		return {};
+	}
+	switch (msg.params.method) {
+		case "Runtime.enable": {
+			if (!debuggee) throw new Error(`No debuggee found for Runtime.enable (sessionId: ${msg.params.sessionId})`);
+			const runtimeSession = {
+				...debuggee,
+				sessionId: msg.params.sessionId !== targetTab?.sessionId ? msg.params.sessionId : void 0
+			};
+			try {
+				await sendCommandWithTimeout(runtimeSession, "Runtime.disable", void 0, 1e4);
+				await sleep(50);
+			} catch (e) {
+				logger.debug("Error disabling Runtime (ignoring):", e);
+			}
+			return await sendCommandWithTimeout(runtimeSession, "Runtime.enable", msg.params.params, 1e4);
+		}
+		case "Target.createTarget": {
+			const url = msg.params.params?.url || "about:blank";
+			logger.debug("Creating new tab with URL:", url);
+			const tab = await createTabInPreferredWindow({
+				url,
+				active: false
+			});
+			if (!tab.id) throw new Error("Failed to create tab");
+			setTabConnecting(tab.id);
+			logger.debug("Created tab:", tab.id, "waiting for it to load...");
+			await sleep(100);
+			const { targetInfo } = await attachTab(tab.id);
+			return { targetId: targetInfo.targetId };
+		}
+		case "Target.closeTarget":
+			if (!targetTabId) {
+				logger.log(`Target not found: ${msg.params.params?.targetId}`);
+				return { success: false };
+			}
+			await chrome.tabs.remove(targetTabId);
+			return { success: true };
+	}
+	if (!debuggee || !targetTab) {
+		if (msg.params.method === "Target.detachFromTarget") return {};
+		throw new Error(`No tab found for method ${msg.params.method} sessionId: ${msg.params.sessionId} params: ${JSON.stringify(msg.params.params || null)}`);
+	}
+	logger.debug("CDP command:", msg.params.method, "for tab:", targetTabId);
+	const debuggerSession = {
+		...debuggee,
+		sessionId: msg.params.sessionId !== targetTab.sessionId ? msg.params.sessionId : void 0
+	};
+	const timeout = FAST_CDP_COMMAND_TIMEOUT_MS.get(msg.params.method);
+	if (timeout) return await sendCommandWithTimeout(debuggerSession, msg.params.method, msg.params.params, timeout);
+	return await chrome.debugger.sendCommand(debuggerSession, msg.params.method, msg.params.params);
+}
+function onDebuggerEvent(source, method, params) {
+	const tab = source.tabId ? store.getState().tabs.get(source.tabId) : void 0;
+	if (!tab) return;
+	logger.debug("Forwarding CDP event:", method, "from tab:", source.tabId);
+	if (method === "Target.attachedToTarget" && params?.sessionId) {
+		const targetUrl = params.targetInfo?.url;
+		if (isRestrictedUrl(targetUrl)) {
+			logger.debug("Ignoring restricted child target:", targetUrl, "sessionId:", params.sessionId, "for tab:", source.tabId);
+			if (source.tabId) chrome.debugger.sendCommand({ tabId: source.tabId }, "Target.detachFromTarget", { sessionId: params.sessionId }).catch((e) => {
+				logger.debug("Failed to detach restricted child target (expected):", e);
+			});
+			return;
+		}
+		logger.debug("Child target attached:", params.sessionId, "for tab:", source.tabId);
+		const targetId = params.targetInfo?.targetId;
+		childSessions.set(params.sessionId, {
+			tabId: source.tabId,
+			targetId
+		});
+	}
+	if (method === "Target.detachedFromTarget" && params?.sessionId) {
+		const mainTab = getTabBySessionId(params.sessionId);
+		if (mainTab) {
+			logger.debug("Main tab detached via CDP event:", mainTab.tabId, "sessionId:", params.sessionId);
+			store.setState((state) => {
+				const newTabs = new Map(state.tabs);
+				newTabs.delete(mainTab.tabId);
+				return { tabs: newTabs };
+			});
+			emitChildDetachesForTab(mainTab.tabId);
+		} else {
+			logger.debug("Child target detached:", params.sessionId);
+			childSessions.delete(params.sessionId);
+		}
+	}
+	sendMessage({
+		method: "forwardCDPEvent",
+		params: {
+			sessionId: source.sessionId || tab.sessionId,
+			method,
+			params
+		}
+	});
+}
+function onDebuggerDetach(source, reason) {
+	const tabId = source.tabId;
+	if (!tabId || !store.getState().tabs.has(tabId)) {
+		logger.debug("Ignoring debugger detach event for untracked tab:", tabId);
+		return;
+	}
+	if (connectionManager.preserveTabsOnDetach) {
+		logger.debug("Ignoring debugger detach during relay reconnect:", tabId, reason);
+		return;
+	}
+	logger.warn(`DISCONNECT: onDebuggerDetach tabId=${tabId} reason=${reason}`);
+	const detachTabFromPlaywright = (detachedTabId, tab) => {
+		sendMessage({
+			method: "forwardCDPEvent",
+			params: {
+				method: "Target.detachedFromTarget",
+				params: {
+					sessionId: tab.sessionId,
+					targetId: tab.targetId
+				}
+			}
+		});
+		emitChildDetachesForTab(detachedTabId);
+	};
+	if (reason === chrome.debugger.DetachReason.CANCELED_BY_USER) {
+		for (const [detachedTabId, tab] of store.getState().tabs.entries()) detachTabFromPlaywright(detachedTabId, tab);
+		store.setState({
+			tabs: /* @__PURE__ */ new Map(),
+			connectionState: "idle",
+			errorText: void 0
+		});
+		return;
+	}
+	const tab = store.getState().tabs.get(tabId);
+	if (tab) detachTabFromPlaywright(tabId, tab);
+	store.setState((state) => {
+		const newTabs = new Map(state.tabs);
+		newTabs.delete(tabId);
+		return { tabs: newTabs };
+	});
+}
+async function removeRestrictedIframes(tabId) {
+	try {
+		const totalRemoved = (await chrome.scripting.executeScript({
+			target: {
+				tabId,
+				allFrames: true
+			},
+			func: (ownExtIds) => {
+				const roots = [document];
+				document.querySelectorAll("*").forEach((el) => {
+					const shadow = el.shadowRoot;
+					if (shadow) roots.push(shadow);
+				});
+				let removed = 0;
+				for (const root of roots) root.querySelectorAll("iframe").forEach((iframe) => {
+					const src = iframe.src || iframe.getAttribute("src") || "";
+					if (!src.startsWith("chrome-extension://")) return;
+					const extId = src.replace("chrome-extension://", "").split("/")[0];
+					if (ownExtIds.includes(extId)) return;
+					iframe.remove();
+					removed++;
+				});
+				return removed;
+			},
+			args: [OUR_EXTENSION_IDS]
+		})).reduce((sum, r) => sum + (r.result ?? 0), 0);
+		if (totalRemoved > 0) logger.debug(`Removed ${totalRemoved} restricted chrome-extension:// iframe(s) from tab:`, tabId);
+		return totalRemoved;
+	} catch (e) {
+		logger.debug("Could not remove restricted iframes (expected on some pages):", e.message);
+		return 0;
+	}
+}
+async function attachTab(tabId, { skipAttachedEvent = false } = {}) {
+	const debuggee = { tabId };
+	let debuggerAttached = false;
+	try {
+		logger.debug("Attaching debugger to tab:", tabId);
+		const maxAttachAttempts = 3;
+		for (let attempt = 1; attempt <= maxAttachAttempts; attempt++) try {
+			await chrome.debugger.attach(debuggee, "1.3");
+			break;
+		} catch (attachError) {
+			const msg = attachError.message ?? "";
+			if (!(msg.includes("chrome-extension://") || msg.includes("different extension")) || attempt === maxAttachAttempts) throw attachError;
+			logger.debug(`Debugger attach blocked by chrome-extension:// iframe (attempt ${attempt}/${maxAttachAttempts}), removing and retrying:`, tabId);
+			await removeRestrictedIframes(tabId);
+			await sleep(50);
+		}
+		debuggerAttached = true;
+		logger.debug("Debugger attached successfully to tab:", tabId);
+		await chrome.debugger.sendCommand(debuggee, "Page.enable");
+		if (autoAttachParams) try {
+			await chrome.debugger.sendCommand(debuggee, "Target.setAutoAttach", autoAttachParams);
+		} catch (error) {
+			logger.debug("Failed to apply auto-attach for tab:", tabId, error);
+		}
+		const contextMenuScript = js`
+      document.addEventListener('contextmenu', (e) => {
+        window.__playwriter_lastRightClicked = e.target;
+      }, true);
+    `;
+		await chrome.debugger.sendCommand(debuggee, "Page.addScriptToEvaluateOnNewDocument", { source: contextMenuScript });
+		await chrome.debugger.sendCommand(debuggee, "Runtime.evaluate", { expression: contextMenuScript });
+		try {
+			await chrome.debugger.sendCommand(debuggee, "Page.addScriptToEvaluateOnNewDocument", { source: ghost_cursor_client_default });
+			await chrome.debugger.sendCommand(debuggee, "Runtime.evaluate", { expression: ghost_cursor_client_default });
+		} catch (err) {
+			logger.debug("Could not inject ghost cursor (restricted page):", err.message);
+		}
+		const targetInfo = (await chrome.debugger.sendCommand(debuggee, "Target.getTargetInfo")).targetInfo;
+		if (!targetInfo.url || targetInfo.url === "" || targetInfo.url === ":") logger.error("WARNING: Target.attachedToTarget will be sent with empty URL! tabId:", tabId, "targetInfo:", JSON.stringify(targetInfo));
+		const attachOrder = nextSessionId;
+		const sessionId = `pw-tab-${tabSessionScope}-${nextSessionId++}`;
+		store.setState((state) => {
+			const newTabs = new Map(state.tabs);
+			newTabs.set(tabId, {
+				sessionId,
+				targetId: targetInfo.targetId,
+				state: "connected",
+				attachOrder
+			});
+			return {
+				tabs: newTabs,
+				connectionState: "connected",
+				errorText: void 0
+			};
+		});
+		if (!skipAttachedEvent) sendMessage({
+			method: "forwardCDPEvent",
+			params: {
+				method: "Target.attachedToTarget",
+				params: {
+					sessionId,
+					targetInfo: {
+						...targetInfo,
+						attached: true
+					},
+					waitingForDebugger: false
+				}
+			}
+		});
+		logger.debug("Tab attached successfully:", tabId, "sessionId:", sessionId, "targetId:", targetInfo.targetId, "url:", targetInfo.url, "skipAttachedEvent:", skipAttachedEvent);
+		injectToolbar(tabId);
+		return {
+			targetInfo,
+			sessionId
+		};
+	} catch (error) {
+		if (debuggerAttached) {
+			logger.debug("Cleaning up debugger after partial attach failure:", tabId);
+			chrome.debugger.detach(debuggee).catch(() => {});
+		}
+		throw error;
+	}
+}
+function detachTab(tabId, shouldDetachDebugger) {
+	const tab = store.getState().tabs.get(tabId);
+	if (!tab) {
+		logger.debug("detachTab: tab not found in map:", tabId);
+		return;
+	}
+	cleanupRrwebRecordingForTab(tabId);
+	chrome.scripting.executeScript({
+		target: { tabId },
+		world: "MAIN",
+		func: () => {
+			window.__playwriterToolbarDestroy?.();
+		}
+	}).catch(() => {});
+	chrome.scripting.executeScript({
+		target: { tabId },
+		world: "MAIN",
+		func: () => {
+			globalThis.__playwriterGhostCursor?.disable?.();
+		}
+	}).catch(() => {});
+	logger.warn(`DISCONNECT: detachTab tabId=${tabId} shouldDetach=${shouldDetachDebugger} stack=${getCallStack()}`);
+	if (tab.sessionId && tab.targetId) sendMessage({
+		method: "forwardCDPEvent",
+		params: {
+			method: "Target.detachedFromTarget",
+			params: {
+				sessionId: tab.sessionId,
+				targetId: tab.targetId
+			}
+		}
+	});
+	store.setState((state) => {
+		const newTabs = new Map(state.tabs);
+		newTabs.delete(tabId);
+		return { tabs: newTabs };
+	});
+	emitChildDetachesForTab(tabId);
+	if (shouldDetachDebugger) chrome.debugger.detach({ tabId }).catch((err) => {
+		logger.debug("Error detaching debugger from tab:", tabId, err.message);
+	});
+}
+async function connectTab(tabId) {
+	try {
+		logger.debug(`Starting connection to tab ${tabId}`);
+		setTabConnecting(tabId);
+		await connectionManager.ensureConnection();
+		await attachTab(tabId);
+		logger.debug(`Successfully connected to tab ${tabId}`);
+	} catch (error) {
+		logger.debug(`Failed to connect to tab ${tabId}:`, error);
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		const isExtensionInUse = errorMessage === "Extension Already In Use" || errorMessage === "Another Tabwright extension is already connected";
+		const isWsError = errorMessage === "Connection timeout" || errorMessage.startsWith("WebSocket");
+		if (isExtensionInUse) {
+			logger.debug(`Another extension is in use, entering polling mode`);
+			store.setState((state) => {
+				const newTabs = new Map(state.tabs);
+				newTabs.delete(tabId);
+				return {
+					tabs: newTabs,
+					connectionState: "extension-replaced",
+					errorText: "Another Tabwright extension is actively in use"
+				};
+			});
+		} else if (error instanceof RelayConnectionProblemError || isWsError) {
+			logger.debug(`Relay connection problem, showing warning for tab ${tabId}`);
+			store.setState((state) => {
+				const newTabs = new Map(state.tabs);
+				newTabs.delete(tabId);
+				return {
+					tabs: newTabs,
+					connectionState: "relay-warning",
+					errorText: error instanceof RelayConnectionProblemError ? error.message : relayIssueText({ issue: "offline" })
+				};
+			});
+		} else {
+			let tabStillExists = true;
+			try {
+				await chrome.tabs.get(tabId);
+			} catch {
+				tabStillExists = false;
+			}
+			if (!tabStillExists) {
+				logger.debug(`Tab ${tabId} was closed during connect, dropping error state`);
+				store.setState((state) => {
+					const newTabs = new Map(state.tabs);
+					newTabs.delete(tabId);
+					return { tabs: newTabs };
+				});
+				return;
+			}
+			if (!store.getState().tabs.has(tabId)) {
+				logger.debug(`Tab ${tabId} was detached during connect, dropping error state`);
+				return;
+			}
+			store.setState((state) => {
+				const newTabs = new Map(state.tabs);
+				newTabs.set(tabId, {
+					state: "error",
+					errorText: `Error: ${errorMessage}`
+				});
+				return { tabs: newTabs };
+			});
+		}
+	}
+}
+function setTabConnecting(tabId) {
+	store.setState((state) => {
+		const newTabs = new Map(state.tabs);
+		const existing = newTabs.get(tabId);
+		newTabs.set(tabId, {
+			...existing,
+			state: "connecting"
+		});
+		return { tabs: newTabs };
+	});
+}
+async function disconnectTab(tabId) {
+	logger.debug(`Disconnecting tab ${tabId}`);
+	const { tabs } = store.getState();
+	if (!tabs.has(tabId)) {
+		logger.debug("Tab not in tabs map, ignoring disconnect");
+		return;
+	}
+	detachTab(tabId, true);
+}
+async function toggleExtensionForActiveTab() {
+	const tab = (await chrome.tabs.query({
+		active: true,
+		currentWindow: true
+	}))[0];
+	if (!tab?.id) throw new Error("No active tab found");
+	await onActionClicked(tab);
+	await new Promise((resolve) => {
+		const check = () => {
+			if (store.getState().tabs.get(tab.id)?.state === "connecting") {
+				setTimeout(check, 100);
+				return;
+			}
+			resolve();
+		};
+		check();
+	});
+	const state = store.getState();
+	return {
+		isConnected: state.tabs.has(tab.id) && state.tabs.get(tab.id)?.state === "connected",
+		state
+	};
+}
+async function disconnectEverything() {
+	tabGroupQueue = tabGroupQueue.then(async () => {
+		const { tabs } = store.getState();
+		for (const tabId of tabs.keys()) await disconnectTab(tabId);
+	});
+	await tabGroupQueue;
+}
+async function resetDebugger() {
+	let targets = await chrome.debugger.getTargets();
+	targets = targets.filter((x) => x.tabId && x.attached);
+	logger.log(`found ${targets.length} existing debugger targets. detaching them before background script starts`);
+	for (const target of targets) await chrome.debugger.detach({ tabId: target.tabId });
+}
+var OUR_EXTENSION_IDS = ["jfeammnjpkecdekppnclgkkffahnhfhe", "pebbngnfojnignonigcnkdilknapkgid"];
+function isRestrictedUrl(url) {
+	if (!url) return false;
+	if (url.startsWith("chrome-extension://")) {
+		const extensionId = url.replace("chrome-extension://", "").split("/")[0];
+		return !OUR_EXTENSION_IDS.includes(extensionId);
+	}
+	return [
+		"chrome://",
+		"devtools://",
+		"edge://",
+		"https://chrome.google.com/",
+		"https://chromewebstore.google.com/"
+	].some((prefix) => url.startsWith(prefix));
+}
+var icons = {
+	connected: {
+		path: {
+			"16": "/icons/icon-green-16.png",
+			"32": "/icons/icon-green-32.png",
+			"48": "/icons/icon-green-48.png",
+			"128": "/icons/icon-green-128.png"
+		},
+		title: "Connected - Click to disconnect",
+		badgeText: "",
+		badgeColor: [
+			64,
+			64,
+			64,
+			255
+		]
+	},
+	connecting: {
+		path: {
+			"16": "/icons/icon-gray-16.png",
+			"32": "/icons/icon-gray-32.png",
+			"48": "/icons/icon-gray-48.png",
+			"128": "/icons/icon-gray-128.png"
+		},
+		title: "Waiting for MCP WS server...",
+		badgeText: "...",
+		badgeColor: [
+			64,
+			64,
+			64,
+			255
+		]
+	},
+	idle: {
+		path: {
+			"16": "/icons/icon-black-16.png",
+			"32": "/icons/icon-black-32.png",
+			"48": "/icons/icon-black-48.png",
+			"128": "/icons/icon-black-128.png"
+		},
+		title: "Click to attach debugger",
+		badgeText: "",
+		badgeColor: [
+			64,
+			64,
+			64,
+			255
+		]
+	},
+	restricted: {
+		path: {
+			"16": "/icons/icon-gray-16.png",
+			"32": "/icons/icon-gray-32.png",
+			"48": "/icons/icon-gray-48.png",
+			"128": "/icons/icon-gray-128.png"
+		},
+		title: "Cannot attach to this page",
+		badgeText: "",
+		badgeColor: [
+			64,
+			64,
+			64,
+			255
+		]
+	},
+	extensionReplaced: {
+		path: {
+			"16": "/icons/icon-gray-16.png",
+			"32": "/icons/icon-gray-32.png",
+			"48": "/icons/icon-gray-48.png",
+			"128": "/icons/icon-gray-128.png"
+		},
+		title: "Another Tabwright extension connected - Click to retry",
+		badgeText: "!",
+		badgeColor: [
+			220,
+			38,
+			38,
+			255
+		]
+	},
+	relayWarning: {
+		path: {
+			"16": "/icons/icon-gray-16.png",
+			"32": "/icons/icon-gray-32.png",
+			"48": "/icons/icon-gray-48.png",
+			"128": "/icons/icon-gray-128.png"
+		},
+		title: relayIssueText({ issue: "unavailable" }),
+		badgeText: "!",
+		badgeColor: [
+			245,
+			158,
+			11,
+			255
+		]
+	},
+	relayReviewDegraded: {
+		path: {
+			"16": "/icons/icon-green-16.png",
+			"32": "/icons/icon-green-32.png",
+			"48": "/icons/icon-green-48.png",
+			"128": "/icons/icon-green-128.png"
+		},
+		title: relayReviewIssueText({ issue: "unavailable" }),
+		badgeText: "!",
+		badgeColor: [
+			245,
+			158,
+			11,
+			255
+		]
+	},
+	tabError: {
+		path: {
+			"16": "/icons/icon-gray-16.png",
+			"32": "/icons/icon-gray-32.png",
+			"48": "/icons/icon-gray-48.png",
+			"128": "/icons/icon-gray-128.png"
+		},
+		title: "Error",
+		badgeText: "!",
+		badgeColor: [
+			220,
+			38,
+			38,
+			255
+		]
+	}
+};
+async function updateIcons() {
+	const { connectionState, relayReviewState, tabs, errorText } = store.getState();
+	const connectedCount = Array.from(tabs.values()).filter((t) => t.state === "connected").length;
+	const allTabs = await chrome.tabs.query({});
+	const tabUrlMap = new Map(allTabs.map((tab) => [tab.id, tab.url]));
+	const allTabIds = [void 0, ...allTabs.map((tab) => tab.id).filter((id) => id !== void 0)];
+	for (const tabId of allTabIds) {
+		const tabInfo = tabId !== void 0 ? tabs.get(tabId) : void 0;
+		const tabUrl = tabId !== void 0 ? tabUrlMap.get(tabId) : void 0;
+		const iconConfig = (() => {
+			if (connectionState === "extension-replaced") return icons.extensionReplaced;
+			if (connectionState === "relay-warning") return icons.relayWarning;
+			if (connectionState === "connected" && relayReviewState.status === "degraded") return icons.relayReviewDegraded;
+			if (tabId !== void 0 && isRestrictedUrl(tabUrl)) return icons.restricted;
+			if (tabInfo?.state === "error") return icons.tabError;
+			if (tabInfo?.state === "connecting") return icons.connecting;
+			if (tabInfo?.state === "connected") return icons.connected;
+			return icons.idle;
+		})();
+		const title = (() => {
+			if (connectionState === "extension-replaced" && errorText) return errorText;
+			if (connectionState === "relay-warning" && errorText) return errorText;
+			if (connectionState === "connected" && relayReviewState.status === "degraded") return relayReviewState.errorText;
+			if (tabInfo?.errorText) return tabInfo.errorText;
+			return iconConfig.title;
+		})();
+		const badgeText = (() => {
+			if (iconConfig === icons.connected || iconConfig === icons.idle || iconConfig === icons.restricted) return connectedCount > 0 ? String(connectedCount) : "";
+			return iconConfig.badgeText;
+		})();
+		chrome.action.setIcon({
+			tabId,
+			path: iconConfig.path
+		});
+		chrome.action.setTitle({
+			tabId,
+			title
+		});
+		if (iconConfig.badgeColor) chrome.action.setBadgeBackgroundColor({
+			tabId,
+			color: iconConfig.badgeColor
+		});
+		chrome.action.setBadgeText({
+			tabId,
+			text: badgeText
+		});
+	}
+}
+async function onTabRemoved(tabId) {
+	popupSourceTabMap.delete(tabId);
+	const { tabs } = store.getState();
+	if (!tabs.has(tabId)) return;
+	logger.debug(`Connected tab ${tabId} was closed, disconnecting`);
+	await disconnectTab(tabId);
+}
+async function onTabActivated(activeInfo) {
+	store.setState({
+		currentTabId: activeInfo.tabId,
+		preferredWindowId: activeInfo.windowId
+	});
+}
+async function onActionClicked(tab) {
+	if (!tab.id) {
+		logger.debug("No tab ID available");
+		return;
+	}
+	if (tab.windowId !== void 0) store.setState({
+		currentTabId: tab.id,
+		preferredWindowId: tab.windowId
+	});
+	if (isRestrictedUrl(tab.url)) {
+		logger.debug("Cannot attach to restricted URL:", tab.url);
+		return;
+	}
+	const { tabs, connectionState } = store.getState();
+	const tabInfo = tabs.get(tab.id);
+	if (connectionState === "extension-replaced") {
+		logger.debug("Clearing extension-replaced state, attempting to reconnect");
+		store.setState({
+			connectionState: "idle",
+			errorText: void 0
+		});
+		await connectTab(tab.id);
+		return;
+	}
+	if (connectionState === "relay-warning") {
+		logger.debug("Clearing relay-warning state, attempting to reconnect");
+		store.setState({
+			connectionState: "idle",
+			errorText: void 0
+		});
+		await connectTab(tab.id);
+		return;
+	}
+	if (tabInfo?.state === "error") {
+		logger.debug("Tab has error - disconnecting to clear state");
+		await disconnectTab(tab.id);
+		return;
+	}
+	if (tabInfo?.state === "connecting") {
+		logger.debug("Tab is already connecting, ignoring click");
+		return;
+	}
+	if (tabInfo?.state === "connected") await disconnectTab(tab.id);
+	else await connectTab(tab.id);
+}
+resetDebugger();
+connectionManager.maintainLoop();
+chrome.contextMenus.remove("playwriter-pin-element").catch(() => {}).finally(() => {
+	chrome.contextMenus?.create({
+		id: "playwriter-pin-element",
+		title: "Copy Tabwright Element Reference",
+		contexts: ["all"],
+		visible: false
+	});
+});
+chrome.contextMenus.remove("playwriter-copy-react-source").catch(() => {}).finally(() => {
+	chrome.contextMenus?.create({
+		id: "playwriter-copy-react-source",
+		title: "Copy React Component Source Path",
+		contexts: ["all"],
+		visible: false
+	});
+});
+function updateContextMenuVisibility() {
+	const { currentTabId, tabs } = store.getState();
+	const isConnected = currentTabId !== void 0 && tabs.get(currentTabId)?.state === "connected";
+	chrome.contextMenus?.update("playwriter-pin-element", { visible: isConnected });
+	chrome.contextMenus?.update("playwriter-copy-react-source", { visible: isConnected });
+}
+function buildPinnedElementInspectionCode(options) {
+	return `inspectPinnedElement(${JSON.stringify(options.url).replace(/'/g, "\\u0027")},"globalThis.${options.pinName}")`;
+}
+chrome.runtime.onInstalled.addListener((details) => {});
+function serializeTabs(tabs) {
+	return JSON.stringify(Array.from(tabs.entries()));
+}
+store.subscribe((state, prevState) => {
+	logger.log(state);
+	updateIcons();
+	updateContextMenuVisibility();
+	if (serializeTabs(state.tabs) !== serializeTabs(prevState.tabs)) tabGroupQueue = tabGroupQueue.then(syncTabGroup).catch((e) => {
+		logger.debug("syncTabGroup error:", e);
+	});
+});
+logger.debug(`Using relay host: ${RELAY_HOST}, port: ${RELAY_PORT}`);
+var lastMemoryUsage = 0;
+var lastMemoryCheck = Date.now();
+var MEMORY_WARNING_THRESHOLD = 50 * 1024 * 1024;
+var MEMORY_CRITICAL_THRESHOLD = 100 * 1024 * 1024;
+var MEMORY_GROWTH_THRESHOLD = 10 * 1024 * 1024;
+function checkMemory() {
+	try {
+		const memory = performance.memory;
+		if (!memory) return;
+		const used = memory.usedJSHeapSize;
+		const total = memory.totalJSHeapSize;
+		const limit = memory.jsHeapSizeLimit;
+		const now = Date.now();
+		const timeDelta = now - lastMemoryCheck;
+		const memoryDelta = used - lastMemoryUsage;
+		const formatMB = (bytes) => (bytes / 1024 / 1024).toFixed(2) + "MB";
+		const growthRate = timeDelta > 0 ? memoryDelta / timeDelta * 1e3 : 0;
+		if (used > MEMORY_CRITICAL_THRESHOLD) logger.error(`MEMORY CRITICAL: used=${formatMB(used)} total=${formatMB(total)} limit=${formatMB(limit)} growth=${formatMB(memoryDelta)} rate=${formatMB(growthRate)}/s`);
+		else if (used > MEMORY_WARNING_THRESHOLD) logger.warn(`MEMORY WARNING: used=${formatMB(used)} total=${formatMB(total)} limit=${formatMB(limit)} growth=${formatMB(memoryDelta)} rate=${formatMB(growthRate)}/s`);
+		else if (memoryDelta > MEMORY_GROWTH_THRESHOLD && timeDelta < 6e4) logger.warn(`MEMORY SPIKE: grew ${formatMB(memoryDelta)} in ${(timeDelta / 1e3).toFixed(1)}s (used=${formatMB(used)})`);
+		lastMemoryUsage = used;
+		lastMemoryCheck = now;
+	} catch (e) {}
+}
+setInterval(checkMemory, 5e3);
+checkMemory();
+chrome.tabs.onRemoved.addListener(onTabRemoved);
+chrome.tabs.onActivated.addListener(onTabActivated);
+chrome.action.onClicked.addListener(onActionClicked);
+chrome.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
+	updateIcons();
+	if (changeInfo.groupId !== void 0) tabGroupQueue = tabGroupQueue.then(async () => {
+		const groupId = (await chrome.tabGroups.query({ title: TAB_GROUP_TITLE }))[0]?.id;
+		if (groupId === void 0) return;
+		const { tabs } = store.getState();
+		if (changeInfo.groupId === groupId) {
+			if (!tabs.has(tabId) && !isRestrictedUrl(tab.url)) {
+				logger.debug("Tab manually added to Tabwright group:", tabId);
+				await connectTab(tabId);
+			}
+		} else if (tabs.has(tabId)) {
+			if (tabs.get(tabId)?.state === "connecting") {
+				logger.debug("Tab removed from group while connecting, ignoring:", tabId);
+				return;
+			}
+			logger.debug("Tab manually removed from Tabwright group:", tabId);
+			await disconnectTab(tabId);
+		}
+	}).catch((e) => {
+		logger.debug("onTabUpdated handler error:", e);
+	});
+});
+var popupSourceTabMap = /* @__PURE__ */ new Map();
+chrome.webNavigation.onCreatedNavigationTarget.addListener((details) => {
+	popupSourceTabMap.set(details.tabId, details.sourceTabId);
+	setTimeout(() => {
+		popupSourceTabMap.delete(details.tabId);
+	}, 1e4);
+});
+chrome.windows.onCreated.addListener(async (popupWindow) => {
+	if (popupWindow.type !== "popup" || popupWindow.id === void 0) return;
+	try {
+		let popupTabs = [];
+		for (let attempt = 0; attempt < 5; attempt++) {
+			popupTabs = await chrome.tabs.query({ windowId: popupWindow.id });
+			if (popupTabs.length > 0) break;
+			await sleep(20);
+		}
+		const tabIds = popupTabs.map((t) => t.id).filter((id) => {
+			return id !== void 0;
+		});
+		if (tabIds.length === 0) {
+			logger.debug(`Popup window ${popupWindow.id} has no tabs after retry, skipping`);
+			return;
+		}
+		const { tabs: connectedTabs } = store.getState();
+		let sourceTabId;
+		for (const tabId of tabIds) {
+			const candidate = popupSourceTabMap.get(tabId);
+			if (candidate !== void 0 && connectedTabs.has(candidate)) {
+				sourceTabId = candidate;
+				break;
+			}
+		}
+		for (const tabId of tabIds) popupSourceTabMap.delete(tabId);
+		if (sourceTabId === void 0) {
+			logger.debug(`Popup window ${popupWindow.id} not opened by a Tabwright-connected tab, leaving alone (tabs=${JSON.stringify(tabIds)})`);
+			return;
+		}
+		let destinationWindowId;
+		try {
+			const sourceTab = await chrome.tabs.get(sourceTabId);
+			if (sourceTab.windowId === void 0) {
+				const focused = await chrome.windows.getLastFocused({ populate: false });
+				if (focused.id === void 0 || focused.id === popupWindow.id) return;
+				destinationWindowId = focused.id;
+			} else destinationWindowId = sourceTab.windowId;
+		} catch (e) {
+			logger.debug(`Source tab ${sourceTabId} no longer exists, skipping relocation:`, e);
+			return;
+		}
+		logger.debug(`Relocating ${tabIds.length} popup tab(s) from window ${popupWindow.id} into source window ${destinationWindowId} (sourceTabId=${sourceTabId})`);
+		await chrome.tabs.move(tabIds, {
+			windowId: destinationWindowId,
+			index: -1
+		});
+		try {
+			await chrome.windows.remove(popupWindow.id);
+		} catch {}
+		for (const tabId of tabIds) {
+			if (connectedTabs.has(tabId)) continue;
+			try {
+				await connectTab(tabId);
+			} catch (e) {
+				logger.warn(`Failed to auto-connect relocated popup tab ${tabId}:`, e);
+			}
+		}
+	} catch (e) {
+		logger.warn("Failed to relocate popup window:", e);
+	}
+});
+chrome.contextMenus?.onClicked.addListener(async (info, tab) => {
+	if (!tab?.id) return;
+	const tabInfo = store.getState().tabs.get(tab.id);
+	if (!tabInfo || tabInfo.state !== "connected") {
+		logger.debug("Tab not connected, ignoring");
+		return;
+	}
+	const debuggee = { tabId: tab.id };
+	if (info.menuItemId === "playwriter-pin-element") try {
+		const jsAllocatePin = js`
+        (function() {
+          window.__playwriterPinCount = (window.__playwriterPinCount || 0) + 1;
+          return window.__playwriterPinCount;
+        })()
+      `;
+		const name = `playwriterPinnedElem${(await chrome.debugger.sendCommand(debuggee, "Runtime.evaluate", {
+			expression: jsAllocatePin,
+			returnByValue: true
+		})).result?.value ?? 1}`;
+		const jsAssignPin = js`
+        if (window.__playwriter_lastRightClicked) {
+          window.${name} = window.__playwriter_lastRightClicked;
+          '${name}';
+        } else {
+          throw new Error('No element was right-clicked');
+        }
+      `;
+		const result = await chrome.debugger.sendCommand(debuggee, "Runtime.evaluate", {
+			expression: jsAssignPin,
+			returnByValue: true
+		});
+		if (result.exceptionDetails) {
+			logger.error("Failed to pin element:", result.exceptionDetails.text);
+			return;
+		}
+		const clipboardText = "tabwright -e '" + buildPinnedElementInspectionCode({
+			pinName: name,
+			url: tab.url || ""
+		}) + "'";
+		const jsPinFlashAndCopy = js`
+        (() => {
+          const el = window.${name};
+          if (!el) return;
+          const orig = el.getAttribute('style') || '';
+          el.setAttribute('style', orig + '; outline: 3px solid #22c55e !important; outline-offset: 2px !important; box-shadow: 0 0 0 3px #22c55e !important;');
+          setTimeout(() => el.setAttribute('style', orig), 300);
+          return navigator.clipboard.writeText(${JSON.stringify(clipboardText)});
+        })()
+      `;
+		await chrome.debugger.sendCommand(debuggee, "Runtime.evaluate", {
+			expression: jsPinFlashAndCopy,
+			awaitPromise: true,
+			userGesture: true
+		});
+		logger.debug("Pinned element as:", name);
+	} catch (error) {
+		logger.error("Failed to pin element:", error.message);
+	}
+	if (info.menuItemId === "playwriter-copy-react-source") try {
+		if (!(await chrome.debugger.sendCommand(debuggee, "Runtime.evaluate", {
+			expression: "!!globalThis.__bippy",
+			returnByValue: true
+		})).result?.value) await chrome.debugger.sendCommand(debuggee, "Runtime.evaluate", { expression: bippy_default });
+		const jsResolveSource = js`
+        (async () => {
+          const el = window.__playwriter_lastRightClicked;
+          if (!el) return JSON.stringify({ error: 'No element was right-clicked' });
+
+          const bippy = globalThis.__bippy;
+          if (!bippy) return JSON.stringify({ error: 'bippy not loaded' });
+
+          // bippy.normalizeFileName strips "/app-pages-browser/" but not the parenthesized
+          // form "/(app-pages-browser)/" that Next.js webpack actually uses. This regex
+          // strips all Next.js webpack layer prefixes: (app-pages-browser), (ssr), (rsc),
+          // (action-browser), (pages-dir-browser), (pages-dir-edge), (pages-dir-node).
+          // Also strips leading "./" that often follows the layer prefix.
+          const cleanFileName = (name) => {
+            let f = bippy.normalizeFileName(name);
+            f = f.replace(/^\/?\\([-\\w]+\\)\\//, '');
+            f = f.replace(/^\\.[\\/]/, '');
+            return f;
+          };
+
+          let fiber;
+          try { fiber = bippy.getFiberFromHostInstance(el); } catch {}
+          if (!fiber) return JSON.stringify({ error: 'No React fiber found. Is this a React app?' });
+
+          // Walk up to find nearest composite fiber with source info
+          let current = fiber;
+          for (let i = 0; i < 50 && current; i++) {
+            try {
+              if (bippy.isCompositeFiber(current)) {
+                const source = await bippy.getSource(current);
+                if (source && source.fileName && bippy.isSourceFile(source.fileName)) {
+                  return JSON.stringify({
+                    fileName: cleanFileName(source.fileName),
+                    lineNumber: source.lineNumber || null,
+                    columnNumber: source.columnNumber || null,
+                    componentName: source.functionName || bippy.getDisplayName(current.type) || null,
+                  });
+                }
+                // Try owner stack as fallback for this fiber
+                const ownerStack = await bippy.getOwnerStack(current);
+                for (const frame of ownerStack) {
+                  if (frame.fileName && bippy.isSourceFile(frame.fileName)) {
+                    return JSON.stringify({
+                      fileName: cleanFileName(frame.fileName),
+                      lineNumber: frame.lineNumber || null,
+                      columnNumber: frame.columnNumber || null,
+                      componentName: frame.functionName || bippy.getDisplayName(current.type) || null,
+                    });
+                  }
+                }
+              }
+            } catch {}
+            current = current.return;
+          }
+          return JSON.stringify({ error: 'No React source location found. Is this a dev build with source maps?' });
+        })()
+      `;
+		const sourceResult = await chrome.debugger.sendCommand(debuggee, "Runtime.evaluate", {
+			expression: jsResolveSource,
+			returnByValue: true,
+			awaitPromise: true
+		});
+		if (sourceResult.exceptionDetails) {
+			logger.error("Failed to get React source:", sourceResult.exceptionDetails.text);
+			return;
+		}
+		const parsed = JSON.parse(sourceResult.result?.value || "{}");
+		if (!parsed.fileName && !parsed.error) parsed.error = "React source result missing fileName";
+		if (parsed.error) {
+			const jsFlashRed = js`
+          (() => {
+            const el = window.__playwriter_lastRightClicked;
+            if (!el) return;
+            const orig = el.getAttribute('style') || '';
+            el.setAttribute('style', orig + '; outline: 3px solid #ef4444 !important; outline-offset: 2px !important;');
+            setTimeout(() => el.setAttribute('style', orig), 600);
+          })()
+        `;
+			await chrome.debugger.sendCommand(debuggee, "Runtime.evaluate", { expression: jsFlashRed });
+			logger.debug("React source not found:", parsed.error);
+			return;
+		}
+		const clipboardText = (() => {
+			if (parsed.lineNumber) return `${parsed.fileName}:${parsed.lineNumber}`;
+			return parsed.fileName;
+		})();
+		const jsFlashGreenAndCopy = js`
+        (() => {
+          const el = window.__playwriter_lastRightClicked;
+          if (!el) return;
+          const orig = el.getAttribute('style') || '';
+          el.setAttribute('style', orig + '; outline: 3px solid #22c55e !important; outline-offset: 2px !important; box-shadow: 0 0 0 3px #22c55e !important;');
+          setTimeout(() => el.setAttribute('style', orig), 300);
+          return navigator.clipboard.writeText(${JSON.stringify(clipboardText)});
+        })()
+      `;
+		await chrome.debugger.sendCommand(debuggee, "Runtime.evaluate", {
+			expression: jsFlashGreenAndCopy,
+			awaitPromise: true,
+			userGesture: true
+		});
+		logger.debug("Copied React source path:", clipboardText, "component:", parsed.componentName);
+	} catch (error) {
+		logger.error("Failed to copy React source:", error.message);
+	}
+});
+updateIcons();
+chrome.runtime.onConnect.addListener((port) => {
+	if (port.name !== "playwriter-toolbar-recording") return;
+	port.onMessage.addListener((message) => {
+		if (!isToolbarRecordingPortMessage(message)) {
+			logger.debug("Ignoring invalid toolbar recording port message");
+			return;
+		}
+		handleToolbarRecordingPortMessage({
+			port,
+			message
+		});
+	});
+});
+chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
+	if (isToolbarRecordingMessage(message)) {
+		logger.debug("Toolbar runtime message received:", message.action, "tabId:", sender.tab?.id);
+		(message.action === "playwriterToolbarToggleRecording" ? toggleToolbarRecording(sender) : getToolbarRecordingStatus(sender)).then((result) => {
+			logger.debug("Toolbar runtime message response:", message.action, result);
+			sendResponse(result);
+		}).catch((error) => {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			logger.debug("Toolbar runtime message failed:", message.action, errorMessage);
+			sendResponse({
+				success: false,
+				error: errorMessage,
+				isRecording: false
+			});
+		});
+		return true;
+	}
+	if (isRrwebEventBatchMessage(message)) {
+		const tabId = sender.tab?.id;
+		if (!tabId) {
+			logger.debug("Ignoring rrweb event batch without sender tab");
+			return false;
+		}
+		if (connectionManager.ws?.readyState === WebSocket.OPEN) sendMessage({
+			method: "rrwebRecordingData",
+			params: {
+				tabId,
+				events: message.events,
+				final: message.final
+			}
+		});
+		else logger.debug(`Dropping rrweb event batch for tab ${tabId} because WebSocket is not ready`);
+		return false;
+	}
+	if (isRrwebCancelledMessage(message)) {
+		const tabId = sender.tab?.id;
+		if (!tabId) {
+			logger.debug("Ignoring rrweb cancellation without sender tab");
+			return false;
+		}
+		if (connectionManager.ws?.readyState === WebSocket.OPEN) sendMessage({
+			method: "rrwebRecordingCancelled",
+			params: { tabId }
+		});
+		return false;
+	}
+	return false;
+});
+chrome.webNavigation.onDOMContentLoaded.addListener((details) => {
+	const { tabs } = store.getState();
+	const tabInfo = tabs.get(details.tabId);
+	if (!tabInfo || tabInfo.state !== "connected") return;
+	if (details.frameId === 0) injectToolbar(details.tabId);
+	resumeRrwebRecordingForNavigation(details.tabId);
+});
+//#endregion