@btraut/browser-bridge 0.1.0

package/extension/dist/content.js

@@ -0,0 +1,780 @@
+"use strict";
+(() => {
+  // packages/extension/src/content.ts
+  var runDriveAction = async (action, params) => {
+    const buildError = (code, message, details) => ({
+      ok: false,
+      error: {
+        code,
+        message,
+        retryable: false,
+        ...details ? { details } : {}
+      }
+    });
+    const ok = (result) => ({ ok: true, result });
+    const escapeSelector = (value) => {
+      if (typeof CSS !== "undefined" && typeof CSS.escape === "function") {
+        return CSS.escape(value);
+      }
+      return value.replace(/[\\"']/g, "\\$&");
+    };
+    const isVisible = (element) => {
+      if (!(element instanceof HTMLElement)) {
+        return false;
+      }
+      const style = window.getComputedStyle(element);
+      if (style.visibility === "hidden" || style.display === "none") {
+        return false;
+      }
+      const rect = element.getBoundingClientRect();
+      if (rect.width === 0 && rect.height === 0) {
+        return false;
+      }
+      if (element.offsetWidth === 0 && element.offsetHeight === 0 && element.getClientRects().length === 0) {
+        return false;
+      }
+      let current = element;
+      while (current) {
+        const style2 = window.getComputedStyle(current);
+        if (style2.display === "none") {
+          return false;
+        }
+        if (style2.visibility === "hidden" || style2.visibility === "collapse") {
+          return false;
+        }
+        const opacity = Number.parseFloat(style2.opacity ?? "1");
+        if (Number.isFinite(opacity) && opacity <= 0) {
+          return false;
+        }
+        current = current.parentElement;
+      }
+      return true;
+    };
+    const buildUrlMatcher = (pattern) => {
+      const maxLength = 256;
+      if (pattern.length > maxLength) {
+        return {
+          ok: false,
+          error: buildError(
+            "INVALID_ARGUMENT",
+            `url_matches pattern exceeds ${maxLength} characters.`
+          )
+        };
+      }
+      const nestedQuantifiers = /\((?:[^()\\]|\\.)*[+*{](?:[^()\\]|\\.)*\)[+*{]/.test(pattern);
+      const repeatedWildcards = /(\.\*.*\.\*)|(\.\+.*\.\+)/.test(pattern);
+      if (nestedQuantifiers || repeatedWildcards) {
+        return {
+          ok: false,
+          error: buildError(
+            "INVALID_ARGUMENT",
+            "url_matches pattern rejected due to unsafe regex complexity."
+          )
+        };
+      }
+      try {
+        const regex = new RegExp(pattern);
+        return { ok: true, matcher: (url) => regex.test(url) };
+      } catch {
+        return { ok: true, matcher: (url) => url.includes(pattern) };
+      }
+    };
+    const findByText = (text) => {
+      const tree = document.createTreeWalker(
+        document.body,
+        NodeFilter.SHOW_ELEMENT
+      );
+      let node = tree.nextNode();
+      while (node) {
+        const element = node;
+        if (element.textContent && element.textContent.includes(text)) {
+          return element;
+        }
+        node = tree.nextNode();
+      }
+      return null;
+    };
+    const findByRole = (locator) => {
+      const role = locator.role;
+      if (!role || typeof role !== "object") {
+        return null;
+      }
+      const roleName = role.name;
+      const roleValue = role.value;
+      if (typeof roleName !== "string" || roleName.length === 0) {
+        return null;
+      }
+      const candidates = Array.from(
+        document.querySelectorAll(`[role="${escapeSelector(roleName)}"]`)
+      );
+      if (typeof roleValue !== "string" || roleValue.length === 0) {
+        return candidates[0] ?? null;
+      }
+      return candidates.find((candidate) => {
+        const label = candidate.getAttribute("aria-label") ?? "";
+        const text = candidate.textContent ?? "";
+        return label.includes(roleValue) || text.includes(roleValue);
+      }) ?? null;
+    };
+    const resolveLocator = (locator) => {
+      if (!locator) {
+        return null;
+      }
+      const ref = locator.ref;
+      if (typeof ref === "string" && ref.length > 0) {
+        const normalized = ref.startsWith("@") ? ref : `@${ref}`;
+        const selector = `[data-bv-ref="${escapeSelector(normalized)}"]`;
+        const found = document.querySelector(selector);
+        if (found) {
+          return found;
+        }
+      }
+      const testid = locator.testid;
+      if (typeof testid === "string" && testid.length > 0) {
+        const selector = `[data-testid="${escapeSelector(testid)}"]`;
+        const found = document.querySelector(selector);
+        if (found) {
+          return found;
+        }
+      }
+      const css = locator.css;
+      if (typeof css === "string" && css.length > 0) {
+        const found = document.querySelector(css);
+        if (found) {
+          return found;
+        }
+      }
+      const byRole = findByRole(locator);
+      if (byRole) {
+        return byRole;
+      }
+      const text = locator.text;
+      if (typeof text === "string" && text.length > 0) {
+        return findByText(text);
+      }
+      return null;
+    };
+    const coerceBoolean = (value) => {
+      if (typeof value === "boolean") {
+        return value;
+      }
+      const normalized = value.trim().toLowerCase();
+      return ["true", "1", "yes", "y", "on", "checked"].includes(normalized);
+    };
+    const dispatchValueEvents = (element) => {
+      element.dispatchEvent(new Event("input", { bubbles: true }));
+      element.dispatchEvent(new Event("change", { bubbles: true }));
+    };
+    const selectOption = (select, value) => {
+      const option = Array.from(select.options).find(
+        (entry) => entry.value === value || entry.text === value
+      );
+      if (!option) {
+        return false;
+      }
+      select.value = option.value;
+      dispatchValueEvents(select);
+      return true;
+    };
+    const selectOptionByIndex = (select, index) => {
+      if (!Number.isInteger(index)) {
+        return false;
+      }
+      if (index < 0 || index >= select.options.length) {
+        return false;
+      }
+      select.selectedIndex = index;
+      dispatchValueEvents(select);
+      return true;
+    };
+    const setTextValue = (element, value, clear) => {
+      const tag = element.tagName.toLowerCase();
+      if (tag === "input" || tag === "textarea") {
+        const input = element;
+        if (clear) {
+          input.value = "";
+        }
+        input.value = `${input.value}${value}`;
+        dispatchValueEvents(input);
+        return true;
+      }
+      if (element.isContentEditable) {
+        if (clear) {
+          element.textContent = "";
+        }
+        element.textContent = `${element.textContent ?? ""}${value}`;
+        dispatchValueEvents(element);
+        return true;
+      }
+      return false;
+    };
+    const detectFieldType = (element) => {
+      if (element instanceof HTMLSelectElement) {
+        return "select";
+      }
+      if (element instanceof HTMLInputElement) {
+        const type = element.type.toLowerCase();
+        if (type === "checkbox") {
+          return "checkbox";
+        }
+        if (type === "radio") {
+          return "radio";
+        }
+        return "text";
+      }
+      if (element instanceof HTMLTextAreaElement) {
+        return "text";
+      }
+      if (element instanceof HTMLElement && element.isContentEditable) {
+        return "contentEditable";
+      }
+      return "text";
+    };
+    const submitIfRequested = (element) => {
+      const form = element.closest("form");
+      if (form && form instanceof HTMLFormElement) {
+        form.requestSubmit();
+      } else if (element instanceof HTMLElement) {
+        element.dispatchEvent(
+          new KeyboardEvent("keydown", { key: "Enter", bubbles: true })
+        );
+      }
+    };
+    const sleep = (ms) => new Promise((resolve) => window.setTimeout(resolve, ms));
+    const dispatchPointer = (element, type, x, y) => {
+      element.dispatchEvent(
+        new PointerEvent(type, {
+          bubbles: true,
+          cancelable: true,
+          clientX: x,
+          clientY: y,
+          button: 0
+        })
+      );
+    };
+    const dispatchDrag = (element, type, x, y, dataTransfer) => {
+      try {
+        element.dispatchEvent(
+          new DragEvent(type, {
+            bubbles: true,
+            cancelable: true,
+            clientX: x,
+            clientY: y,
+            dataTransfer
+          })
+        );
+      } catch {
+        element.dispatchEvent(
+          new Event(type, { bubbles: true, cancelable: true })
+        );
+      }
+    };
+    const keyToCode = (key) => {
+      const map = {
+        Enter: "Enter",
+        Tab: "Tab",
+        Escape: "Escape",
+        Esc: "Escape",
+        Backspace: "Backspace",
+        Delete: "Delete",
+        ArrowUp: "ArrowUp",
+        ArrowDown: "ArrowDown",
+        ArrowLeft: "ArrowLeft",
+        ArrowRight: "ArrowRight",
+        Home: "Home",
+        End: "End",
+        PageUp: "PageUp",
+        PageDown: "PageDown",
+        " ": "Space",
+        Space: "Space"
+      };
+      if (map[key]) {
+        return map[key];
+      }
+      if (key.length === 1) {
+        if (/[a-zA-Z]/.test(key)) {
+          return `Key${key.toUpperCase()}`;
+        }
+        if (/[0-9]/.test(key)) {
+          return `Digit${key}`;
+        }
+      }
+      return key;
+    };
+    const normalizeModifiers = (modifiers) => {
+      const state = { ctrl: false, alt: false, shift: false, meta: false };
+      if (Array.isArray(modifiers)) {
+        modifiers.forEach((modifier) => {
+          if (typeof modifier !== "string") {
+            return;
+          }
+          const normalized = modifier.toLowerCase();
+          if (normalized === "ctrl") {
+            state.ctrl = true;
+          } else if (normalized === "alt") {
+            state.alt = true;
+          } else if (normalized === "shift") {
+            state.shift = true;
+          } else if (normalized === "meta") {
+            state.meta = true;
+          }
+        });
+        return state;
+      }
+      if (modifiers && typeof modifiers === "object") {
+        const record = modifiers;
+        state.ctrl = Boolean(record.ctrl);
+        state.alt = Boolean(record.alt);
+        state.shift = Boolean(record.shift);
+        state.meta = Boolean(record.meta);
+      }
+      return state;
+    };
+    const activeEditableElement = () => {
+      const active = document.activeElement;
+      if (!active || !(active instanceof HTMLElement)) {
+        return null;
+      }
+      const tag = active.tagName.toLowerCase();
+      if (tag === "input" || tag === "textarea" || active.isContentEditable) {
+        return active;
+      }
+      return null;
+    };
+    const parseParams = () => params ?? {};
+    try {
+      switch (action) {
+        case "drive.navigate": {
+          const { url } = parseParams();
+          if (typeof url !== "string" || url.length === 0) {
+            return buildError(
+              "INVALID_ARGUMENT",
+              "url must be a non-empty string."
+            );
+          }
+          window.location.href = url;
+          return ok();
+        }
+        case "drive.click": {
+          const { locator, click_count } = parseParams();
+          const target = resolveLocator(locator);
+          if (!target) {
+            return buildError("LOCATOR_NOT_FOUND", "Failed to resolve locator.");
+          }
+          const count = typeof click_count === "number" && Number.isFinite(click_count) ? Math.max(1, Math.floor(click_count)) : 1;
+          window.setTimeout(() => {
+            try {
+              for (let i = 0; i < count; i += 1) {
+                target.click();
+              }
+            } catch {
+            }
+          }, 0);
+          return ok();
+        }
+        case "drive.hover": {
+          const { locator, delay_ms } = parseParams();
+          const target = resolveLocator(locator);
+          if (!target) {
+            return buildError("LOCATOR_NOT_FOUND", "Failed to resolve locator.");
+          }
+          const rect = target.getBoundingClientRect();
+          const centerX = rect.left + rect.width / 2;
+          const centerY = rect.top + rect.height / 2;
+          const eventInit = {
+            bubbles: true,
+            cancelable: true,
+            clientX: centerX,
+            clientY: centerY
+          };
+          target.dispatchEvent(new MouseEvent("mouseover", eventInit));
+          target.dispatchEvent(
+            new MouseEvent("mouseenter", { ...eventInit, bubbles: false })
+          );
+          target.dispatchEvent(new MouseEvent("mousemove", eventInit));
+          if (typeof delay_ms === "number" && Number.isFinite(delay_ms)) {
+            const waitMs = Math.min(Math.max(delay_ms, 0), 1e4);
+            if (waitMs > 0) {
+              await sleep(waitMs);
+            }
+          }
+          const html = document.documentElement?.outerHTML ?? "";
+          return ok({ format: "html", snapshot: html });
+        }
+        case "drive.select": {
+          const { locator, value, text, index } = parseParams();
+          const target = resolveLocator(locator);
+          if (!target) {
+            return buildError("LOCATOR_NOT_FOUND", "Failed to resolve locator.");
+          }
+          if (!(target instanceof HTMLSelectElement)) {
+            return buildError(
+              "INVALID_ARGUMENT",
+              "Target is not a select element."
+            );
+          }
+          let applied = false;
+          if (typeof index === "number" && Number.isFinite(index)) {
+            applied = selectOptionByIndex(target, Math.trunc(index));
+          }
+          if (!applied && typeof value === "string") {
+            applied = selectOption(target, value);
+          }
+          if (!applied && typeof text === "string") {
+            applied = selectOption(target, text);
+          }
+          if (!applied) {
+            return buildError(
+              "INVALID_ARGUMENT",
+              "No matching option found for select."
+            );
+          }
+          return ok();
+        }
+        case "drive.type": {
+          const { locator, text, clear, submit } = parseParams();
+          if (typeof text !== "string") {
+            return buildError("INVALID_ARGUMENT", "text must be a string.");
+          }
+          let target = resolveLocator(
+            locator
+          );
+          if (!target) {
+            const active = activeEditableElement();
+            if (active) {
+              target = active;
+            }
+          }
+          if (!target || !(target instanceof HTMLElement)) {
+            return buildError("LOCATOR_NOT_FOUND", "Failed to resolve locator.");
+          }
+          target.focus();
+          const tag = target.tagName.toLowerCase();
+          const shouldClear = Boolean(clear);
+          if (tag === "input" || tag === "textarea") {
+            const input = target;
+            if (shouldClear) {
+              input.value = "";
+            }
+            input.value = `${input.value}${text}`;
+            input.dispatchEvent(new Event("input", { bubbles: true }));
+            input.dispatchEvent(new Event("change", { bubbles: true }));
+          } else if (target.isContentEditable) {
+            if (shouldClear) {
+              target.textContent = "";
+            }
+            target.textContent = `${target.textContent ?? ""}${text}`;
+            target.dispatchEvent(new Event("input", { bubbles: true }));
+          } else {
+            return buildError(
+              "INVALID_ARGUMENT",
+              "Target is not editable (input, textarea, or contenteditable)."
+            );
+          }
+          if (submit) {
+            const form = target.closest("form");
+            if (form && form instanceof HTMLFormElement) {
+              form.requestSubmit();
+            } else {
+              target.dispatchEvent(
+                new KeyboardEvent("keydown", {
+                  key: "Enter",
+                  bubbles: true
+                })
+              );
+            }
+          }
+          return ok();
+        }
+        case "drive.fill_form": {
+          const { fields } = parseParams();
+          if (!Array.isArray(fields) || fields.length === 0) {
+            return buildError(
+              "INVALID_ARGUMENT",
+              "fields must be a non-empty array."
+            );
+          }
+          let filled = 0;
+          const errors = [];
+          fields.forEach((field, index) => {
+            if (!field || typeof field !== "object") {
+              errors.push(`Field ${index} is not an object.`);
+              return;
+            }
+            const record = field;
+            const selector = record.selector;
+            const locator = record.locator && typeof record.locator === "object" ? record.locator : void 0;
+            let element = null;
+            if (locator) {
+              element = resolveLocator(locator);
+            }
+            if (!element && typeof selector === "string" && selector.length > 0) {
+              element = document.querySelector(selector);
+            }
+            if (!element) {
+              errors.push(`Field ${index} could not be resolved.`);
+              return;
+            }
+            const value = record.value;
+            if (typeof value !== "string" && typeof value !== "boolean") {
+              errors.push(`Field ${index} has invalid value.`);
+              return;
+            }
+            const type = typeof record.type === "string" && record.type.length > 0 ? record.type : "auto";
+            const resolvedType = type === "auto" ? detectFieldType(element) : type;
+            const submit = Boolean(record.submit);
+            let applied = false;
+            if (resolvedType === "select") {
+              if (element instanceof HTMLSelectElement) {
+                applied = selectOption(element, String(value));
+              }
+            } else if (resolvedType === "checkbox" || resolvedType === "radio") {
+              if (element instanceof HTMLInputElement) {
+                const shouldCheck = typeof value === "boolean" ? value : coerceBoolean(value);
+                element.checked = shouldCheck;
+                dispatchValueEvents(element);
+                applied = true;
+              }
+            } else {
+              if (element instanceof HTMLElement) {
+                applied = setTextValue(element, String(value), true);
+              }
+            }
+            if (!applied) {
+              errors.push(`Field ${index} could not be filled.`);
+              return;
+            }
+            if (submit) {
+              submitIfRequested(element);
+            }
+            filled += 1;
+          });
+          return ok({
+            filled,
+            attempted: fields.length,
+            errors: errors.length > 0 ? errors : []
+          });
+        }
+        case "drive.drag": {
+          const { from, to, steps } = parseParams();
+          const fromEl = resolveLocator(from);
+          if (!fromEl) {
+            return buildError(
+              "LOCATOR_NOT_FOUND",
+              "Failed to resolve drag source."
+            );
+          }
+          const toEl = resolveLocator(to);
+          if (!toEl) {
+            return buildError(
+              "LOCATOR_NOT_FOUND",
+              "Failed to resolve drag target."
+            );
+          }
+          const fromRect = fromEl.getBoundingClientRect();
+          const toRect = toEl.getBoundingClientRect();
+          const startX = fromRect.left + fromRect.width / 2;
+          const startY = fromRect.top + fromRect.height / 2;
+          const endX = toRect.left + toRect.width / 2;
+          const endY = toRect.top + toRect.height / 2;
+          const totalSteps = typeof steps === "number" && Number.isFinite(steps) ? Math.max(1, Math.min(50, Math.floor(steps))) : 12;
+          let dataTransfer;
+          try {
+            dataTransfer = new DataTransfer();
+          } catch {
+            dataTransfer = void 0;
+          }
+          dispatchPointer(fromEl, "pointerdown", startX, startY);
+          dispatchDrag(fromEl, "dragstart", startX, startY, dataTransfer);
+          for (let i = 1; i <= totalSteps; i += 1) {
+            const progress = i / totalSteps;
+            const x = startX + (endX - startX) * progress;
+            const y = startY + (endY - startY) * progress;
+            const target = document.elementFromPoint(x, y) ?? toEl;
+            dispatchPointer(target, "pointermove", x, y);
+            dispatchDrag(target, "dragover", x, y, dataTransfer);
+            await sleep(10);
+          }
+          const dropTarget = document.elementFromPoint(endX, endY) ?? toEl;
+          dispatchDrag(dropTarget, "drop", endX, endY, dataTransfer);
+          dispatchPointer(dropTarget, "pointerup", endX, endY);
+          dispatchDrag(fromEl, "dragend", endX, endY, dataTransfer);
+          return ok();
+        }
+        case "drive.key_press": {
+          const { key, modifiers } = parseParams();
+          if (typeof key !== "string" || key.length === 0) {
+            return buildError(
+              "INVALID_ARGUMENT",
+              "key must be a non-empty string."
+            );
+          }
+          const target = document.activeElement instanceof HTMLElement ? document.activeElement : document.body;
+          if (!target) {
+            return buildError("INVALID_ARGUMENT", "No target for key press.");
+          }
+          const mods = normalizeModifiers(modifiers);
+          const eventInit = {
+            key,
+            code: keyToCode(key),
+            bubbles: true,
+            cancelable: true,
+            ctrlKey: mods.ctrl,
+            altKey: mods.alt,
+            shiftKey: mods.shift,
+            metaKey: mods.meta
+          };
+          target.dispatchEvent(new KeyboardEvent("keydown", eventInit));
+          target.dispatchEvent(new KeyboardEvent("keyup", eventInit));
+          return ok();
+        }
+        case "drive.key": {
+          const { key, modifiers, repeat } = parseParams();
+          if (typeof key !== "string" || key.length === 0) {
+            return buildError(
+              "INVALID_ARGUMENT",
+              "key must be a non-empty string."
+            );
+          }
+          const target = document.activeElement instanceof HTMLElement ? document.activeElement : document.body;
+          if (!target) {
+            return buildError("INVALID_ARGUMENT", "No target for key press.");
+          }
+          const mods = normalizeModifiers(modifiers);
+          const eventInit = {
+            key,
+            code: keyToCode(key),
+            bubbles: true,
+            cancelable: true,
+            ctrlKey: mods.ctrl,
+            altKey: mods.alt,
+            shiftKey: mods.shift,
+            metaKey: mods.meta
+          };
+          const count = typeof repeat === "number" && Number.isFinite(repeat) ? Math.max(1, Math.min(50, Math.floor(repeat))) : 1;
+          for (let i = 0; i < count; i += 1) {
+            target.dispatchEvent(new KeyboardEvent("keydown", eventInit));
+            target.dispatchEvent(new KeyboardEvent("keyup", eventInit));
+          }
+          return ok();
+        }
+        case "drive.scroll": {
+          const { delta_x, delta_y, top, left, behavior } = parseParams();
+          const scrollBehavior = behavior === "smooth" || behavior === "auto" ? behavior : void 0;
+          if (typeof top === "number" || typeof left === "number") {
+            window.scrollTo({
+              top: typeof top === "number" ? top : void 0,
+              left: typeof left === "number" ? left : void 0,
+              behavior: scrollBehavior
+            });
+            return ok();
+          }
+          if (typeof delta_x === "number" || typeof delta_y === "number") {
+            window.scrollBy({
+              left: typeof delta_x === "number" ? delta_x : 0,
+              top: typeof delta_y === "number" ? delta_y : 0,
+              behavior: scrollBehavior
+            });
+            return ok();
+          }
+          return buildError(
+            "INVALID_ARGUMENT",
+            "scroll requires delta_x/delta_y or top/left."
+          );
+        }
+        case "drive.wait_for": {
+          const { condition, timeout_ms } = parseParams();
+          if (!condition || typeof condition !== "object") {
+            return buildError("INVALID_ARGUMENT", "condition must be an object.");
+          }
+          const kind = condition.kind;
+          const value = condition.value;
+          if (typeof kind !== "string" || !["locator_visible", "text_present", "url_matches"].includes(kind)) {
+            return buildError(
+              "INVALID_ARGUMENT",
+              "condition.kind must be locator_visible, text_present, or url_matches."
+            );
+          }
+          if (typeof value !== "string" || value.length === 0) {
+            return buildError(
+              "INVALID_ARGUMENT",
+              "condition.value must be a non-empty string."
+            );
+          }
+          const timeout = typeof timeout_ms === "number" && Number.isFinite(timeout_ms) ? Math.max(0, timeout_ms) : 3e4;
+          const start = Date.now();
+          const urlMatcher = kind === "url_matches" ? buildUrlMatcher(value) : null;
+          if (urlMatcher && !urlMatcher.ok) {
+            return urlMatcher.error;
+          }
+          const checkCondition = () => {
+            if (kind === "text_present") {
+              return (document.body?.innerText ?? "").includes(value);
+            }
+            if (kind === "url_matches") {
+              return urlMatcher ? urlMatcher.matcher(window.location.href) : window.location.href.includes(value);
+            }
+            const selector = value;
+            const element = document.querySelector(selector);
+            return Boolean(element && isVisible(element));
+          };
+          return await new Promise((resolve) => {
+            const tick = () => {
+              if (checkCondition()) {
+                resolve(ok());
+                return;
+              }
+              if (Date.now() - start >= timeout) {
+                resolve(
+                  buildError("TIMEOUT", `wait_for timed out after ${timeout}ms.`)
+                );
+                return;
+              }
+              window.setTimeout(tick, 100);
+            };
+            tick();
+          });
+        }
+        default:
+          return buildError("INVALID_ARGUMENT", `Unsupported action ${action}.`);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return buildError("EVALUATION_FAILED", message);
+    }
+  };
+  var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+  if (typeof chrome !== "undefined" && chrome.runtime?.onMessage) {
+    chrome.runtime.onMessage.addListener(
+      (message, _sender, sendResponse) => {
+        if (!isRecord(message) || typeof message.action !== "string") {
+          sendResponse({
+            ok: false,
+            error: {
+              code: "INVALID_ARGUMENT",
+              message: "Invalid content script request.",
+              retryable: false
+            }
+          });
+          return;
+        }
+        void runDriveAction(
+          message.action,
+          message.params
+        ).then(sendResponse).catch((error) => {
+          const messageText = error instanceof Error ? error.message : "Unknown error";
+          sendResponse({
+            ok: false,
+            error: {
+              code: "EVALUATION_FAILED",
+              message: messageText,
+              retryable: false
+            }
+          });
+        });
+        return true;
+      }
+    );
+  }
+})();
+//# sourceMappingURL=content.js.map