haltija 1.1.21 → 1.2.2

package/bin/tosijs-dev.mjs

@@ -413,18 +413,62 @@ function printBanner(mode, port) {
   console.log('')
 }
 
-/** Check if electron is available (cached by npx or installed) */
-function isElectronAvailable() {
+/** Resolve the electron binary path without spawning Electron.
+ *  IMPORTANT: Never use `npx electron -e ...` or `electron --version` here —
+ *  those launch a visible Electron window, causing UI flicker on startup. */
+let _cachedElectronBinary = undefined
+function resolveElectronBinary() {
+  if (_cachedElectronBinary !== undefined) return _cachedElectronBinary
+
+  // Helper: given an electron dist dir, return the binary path
+  const binaryInDist = (distDir) => {
+    const binary = platform() === 'darwin'
+      ? join(distDir, 'Electron.app/Contents/MacOS/Electron')
+      : platform() === 'win32'
+        ? join(distDir, 'electron.exe')
+        : join(distDir, 'electron')
+    return existsSync(binary) ? binary : null
+  }
+
+  // 1. Check desktop app's own node_modules
+  const desktopDist = join(__dirname, '../apps/desktop/node_modules/electron/dist')
+  const desktopBin = binaryInDist(desktopDist)
+  if (desktopBin) { _cachedElectronBinary = desktopBin; return desktopBin }
+
+  // 2. Read the electron npm package's path.txt (no process spawn needed)
   try {
-    // Check if electron is in npx cache or node_modules
-    execSyncImported('npx --no electron --version', { 
-      stdio: 'pipe',
-      timeout: 5000 
-    })
-    return true
-  } catch {
-    return false
+    const electronPkgDir = join(__dirname, '../apps/desktop/node_modules/electron')
+    const pathTxt = join(electronPkgDir, 'path.txt')
+    if (existsSync(pathTxt)) {
+      const relPath = readFileSync(pathTxt, 'utf8').trim()
+      const absPath = join(electronPkgDir, relPath)
+      if (existsSync(absPath)) { _cachedElectronBinary = absPath; return absPath }
+    }
+  } catch {}
+
+  // 3. Search npx cache for electron dist directories (no Electron launch)
+  if (platform() !== 'win32') {
+    try {
+      const cacheHits = execSyncImported(
+        `find ${homedir()}/.npm/_npx -name "Electron.app" -path "*/electron/dist/*" -type d 2>/dev/null`,
+        { encoding: 'utf-8', timeout: 3000 }
+      ).trim().split('\n').filter(Boolean)
+      for (const hit of cacheHits) {
+        // hit is .../electron/dist/Electron.app — we want the dist dir
+        const distDir = join(hit, '..')
+        const bin = binaryInDist(distDir)
+        if (bin) { _cachedElectronBinary = bin; return bin }
+      }
+    } catch {}
   }
+
+  _cachedElectronBinary = null
+  return null
+}
+
+/** Check if electron is available (cached by npx or installed) */
+function isElectronAvailable() {
+  return resolveElectronBinary() !== null
 }
 
 /** Launch the Electron desktop app using npx electron */
@@ -438,11 +482,17 @@ function launchApp(desktopDir, port) {
   
   printBanner(ciMode ? 'ci' : 'app', port)
 
-  // Use npx --yes to auto-accept installation if needed (no interactive prompt)
-  const child = spawn('npx', ['--yes', 'electron', desktopDir], {
-    env: { ...env, DEV_CHANNEL_PORT: String(port) },
-    stdio: 'inherit'
-  })
+  // Resolve electron binary directly to avoid npx cache race conditions (ENOTEMPTY)
+  const electronBinary = resolveElectronBinary()
+  const child = electronBinary
+    ? spawn(electronBinary, [desktopDir], {
+        env: { ...env, DEV_CHANNEL_PORT: String(port) },
+        stdio: 'inherit'
+      })
+    : spawn('npx', ['--yes', 'electron', desktopDir], {
+        env: { ...env, DEV_CHANNEL_PORT: String(port) },
+        stdio: 'inherit'
+      })
 
   child.on('error', (err) => {
     console.error(red('Error:') + ` Failed to launch desktop app: ${err.message}`)
@@ -700,9 +750,12 @@ async function checkExistingServer(port) {
   }
 }
 
-/** Kill process on port (cross-platform) */
+/** Kill process on port and any related Electron processes (cross-platform) */
 function killOnPort(port) {
   const myPid = process.pid.toString()
+  let killed = false
+
+  // 1. Kill processes listening on the port (the Haltija server)
   try {
     const output = execSyncImported(`lsof -ti :${port} 2>/dev/null`, { encoding: 'utf-8' }).trim()
     if (output) {
@@ -710,12 +763,34 @@ function killOnPort(port) {
       for (const pid of pids) {
         try {
           execSyncImported(`kill ${pid} 2>/dev/null`)
+          killed = true
         } catch {}
       }
-      return pids.length > 0
     }
   } catch {}
-  return false
+
+  // 2. Kill any Electron processes running the desktop app
+  //    The Electron parent process isn't on the port, so lsof won't find it.
+  //    Without this, npx's cache directory stays locked causing ENOTEMPTY on restart.
+  if (platform() !== 'win32') {
+    try {
+      const output = execSyncImported(
+        `pgrep -f 'Electron.*apps/desktop|electron.*apps/desktop' 2>/dev/null`,
+        { encoding: 'utf-8', timeout: 3000 }
+      ).trim()
+      if (output) {
+        const pids = output.split('\n').filter(Boolean).filter(pid => pid !== myPid)
+        for (const pid of pids) {
+          try {
+            execSyncImported(`kill ${pid} 2>/dev/null`)
+            killed = true
+          } catch {}
+        }
+      }
+    } catch {}
+  }
+
+  return killed
 }
 
 // ============================================
@@ -741,8 +816,8 @@ if (existingServer.running && !forceRestart) {
 if (existingServer.running && forceRestart) {
   console.log(yellow('Restarting...') + ' Stopping existing Haltija server.')
   killOnPort(port)
-  // Brief pause to let port release
-  await new Promise(resolve => setTimeout(resolve, 200))
+  // Pause to let port release and Electron processes fully exit
+  await new Promise(resolve => setTimeout(resolve, 500))
 }
 
 if (headlessMode) {

package/dist/client.js

@@ -1,12 +1,16 @@
 // @bun
 var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);

package/dist/component.js

@@ -3,27 +3,37 @@
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __moduleCache = /* @__PURE__ */ new WeakMap;
+  function __accessProp(key) {
+    return this[key];
+  }
   var __toCommonJS = (from) => {
-    var entry = __moduleCache.get(from), desc;
+    var entry = (__moduleCache ??= new WeakMap).get(from), desc;
     if (entry)
       return entry;
     entry = __defProp({}, "__esModule", { value: true });
-    if (from && typeof from === "object" || typeof from === "function")
-      __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-        get: () => from[key],
-        enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-      }));
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (var key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(entry, key))
+          __defProp(entry, key, {
+            get: __accessProp.bind(from, key),
+            enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+          });
+    }
     __moduleCache.set(from, entry);
     return entry;
   };
+  var __moduleCache;
+  var __returnValue = (v) => v;
+  function __exportSetter(name, newValue) {
+    this[name] = __returnValue.bind(null, newValue);
+  }
   var __export = (target, all) => {
     for (var name in all)
       __defProp(target, name, {
         get: all[name],
         enumerable: true,
         configurable: true,
-        set: (newValue) => all[name] = () => newValue
+        set: __exportSetter.bind(all, name)
       });
   };
 
@@ -36,7 +46,7 @@
   });
 
   // src/version.ts
-  var VERSION = "1.1.21";
+  var VERSION = "1.2.2";
 
   // src/text-selector.ts
   var TEXT_PSEUDO_RE = /:(?:text-is|has-text|text)\(/;
@@ -545,6 +555,40 @@
     const candidates = document.querySelectorAll(parsed.baseSelector);
     return Array.from(candidates).filter((el) => elementTextMatches(el, parsed));
   }
+  function resolveRefOrSelector(ref, selector) {
+    if (ref) {
+      const result2 = refRegistry.resolveWithStatus(ref);
+      if (result2.element) {
+        stats.refsResolved++;
+        return { element: result2.element, targetDesc: `@${ref}` };
+      }
+      stats.refsStale++;
+      const errorMsg = result2.status === "never_assigned" ? `Ref @${ref} was never assigned (highest ref is @${refRegistry.getStats().highWaterMark})` : result2.status === "removed_from_dom" ? `Ref @${ref} points to an element that was removed from the DOM (try refreshing /tree)` : `Ref @${ref} is stale - element was garbage collected (try refreshing /tree)`;
+      return { element: null, targetDesc: `@${ref}`, error: errorMsg };
+    }
+    if (selector) {
+      const el = resolveSelector(selector);
+      return { element: el, targetDesc: selector };
+    }
+    return { element: null, targetDesc: "(none)", error: "ref or selector is required" };
+  }
+  function resolveRefOrSelectorAll(ref, selector) {
+    if (ref) {
+      const result2 = refRegistry.resolveWithStatus(ref);
+      if (result2.element) {
+        stats.refsResolved++;
+        return { elements: [result2.element], targetDesc: `@${ref}` };
+      }
+      stats.refsStale++;
+      const errorMsg = result2.status === "never_assigned" ? `Ref @${ref} was never assigned (highest ref is @${refRegistry.getStats().highWaterMark})` : result2.status === "removed_from_dom" ? `Ref @${ref} points to an element that was removed from the DOM (try refreshing /tree)` : `Ref @${ref} is stale - element was garbage collected (try refreshing /tree)`;
+      return { elements: [], targetDesc: `@${ref}`, error: errorMsg };
+    }
+    if (selector) {
+      const els = resolveSelectorAll(selector);
+      return { elements: els, targetDesc: selector };
+    }
+    return { elements: [], targetDesc: "(none)", error: "ref or selector is required" };
+  }
   function extractElement(el) {
     const rect = el.getBoundingClientRect();
     const attrs = {};
@@ -1650,6 +1694,10 @@
     recording = null;
     testRecording = null;
     originalConsole = {};
+    originalDialogs = {};
+    dialogPolicy = { alert: "dismiss", confirm: "accept", prompt: "dismiss", beforeunload: "allow" };
+    dialogHistory = [];
+    _inHaltijaUI = false;
     widgetHidden = false;
     serverUrl = "wss://localhost:8700/ws/browser";
     windowId;
@@ -1835,12 +1883,14 @@
       this.style.bottom = `${this.homeBottom}px`;
       this.setupKeyboardShortcut();
       this.interceptConsole();
+      this.interceptDialogs();
       this.connect();
     }
     disconnectedCallback() {
       this.killed = true;
       this.disconnect();
       this.restoreConsole();
+      this.restoreDialogs();
       this.clearEventWatchers();
       this.stopMutationWatch();
     }
@@ -3994,6 +4044,16 @@ ${elementSummary}${moreText}`;
       return `Interact with ${tag}`;
     }
     addTestAssertion() {
+      if (!this.testRecording)
+        return;
+      this._inHaltijaUI = true;
+      try {
+        this._addTestAssertionImpl();
+      } finally {
+        this._inHaltijaUI = false;
+      }
+    }
+    _addTestAssertionImpl() {
       if (!this.testRecording)
         return;
       const type = prompt(`What to check?
@@ -4068,6 +4128,14 @@ ${elementSummary}${moreText}`;
       }
     }
     saveTest() {
+      this._inHaltijaUI = true;
+      try {
+        this._saveTestImpl();
+      } finally {
+        this._inHaltijaUI = false;
+      }
+    }
+    _saveTestImpl() {
       if (!this.testRecording || this.testRecording.steps.length === 0) {
         alert("No steps recorded!");
         return;
@@ -5019,9 +5087,80 @@ ${elementSummary}${moreText}`;
         case "interaction":
           this.handleInteractionMessage(msg2);
           break;
+        case "dialog":
+          this.handleDialogMessage(msg2);
+          break;
+        case "video":
+          this.handleVideoMessage(msg2);
+          break;
       }
       this.render();
     }
+    handleDialogMessage(msg2) {
+      const { action: action2, payload: payload2 } = msg2;
+      if (action2 === "configure") {
+        if (payload2.alert !== undefined)
+          this.dialogPolicy.alert = payload2.alert;
+        if (payload2.confirm !== undefined)
+          this.dialogPolicy.confirm = payload2.confirm;
+        if (payload2.prompt !== undefined)
+          this.dialogPolicy.prompt = payload2.prompt;
+        if (payload2.beforeunload !== undefined)
+          this.dialogPolicy.beforeunload = payload2.beforeunload;
+        this.respond(msg2.id, true, { policy: this.dialogPolicy });
+      } else if (action2 === "get-config") {
+        this.respond(msg2.id, true, { policy: this.dialogPolicy });
+      } else if (action2 === "history") {
+        this.respond(msg2.id, true, { history: this.dialogHistory });
+      } else {
+        this.respond(msg2.id, false, undefined, `Unknown dialog action: ${action2}`);
+      }
+    }
+    handleVideoMessage(msg2) {
+      const { action: action2, payload: payload2 } = msg2;
+      const haltija = window.haltija;
+      if (action2 === "start") {
+        if (!haltija?.startVideoCapture) {
+          this.respond(msg2.id, false, undefined, "Video capture requires the Haltija Desktop app. Run: npx haltija@latest -f");
+          return;
+        }
+        haltija.startVideoCapture({ maxDuration: payload2.maxDuration }).then((result2) => {
+          if (result2.success) {
+            this.respond(msg2.id, true, { recordingId: result2.recordingId });
+          } else {
+            this.respond(msg2.id, false, undefined, result2.error || "Failed to start video");
+          }
+        }).catch((err) => {
+          this.respond(msg2.id, false, undefined, `Failed to start video: ${err.message}`);
+        });
+      } else if (action2 === "stop") {
+        if (!haltija?.stopVideoCapture) {
+          this.respond(msg2.id, false, undefined, "Video capture requires the Haltija Desktop app. Run: npx haltija@latest -f");
+          return;
+        }
+        haltija.stopVideoCapture().then((result2) => {
+          if (result2.success) {
+            this.respond(msg2.id, true, { path: result2.path, duration: result2.duration, size: result2.size, format: result2.format });
+          } else {
+            this.respond(msg2.id, false, undefined, result2.error || "Failed to stop video");
+          }
+        }).catch((err) => {
+          this.respond(msg2.id, false, undefined, `Failed to stop video: ${err.message}`);
+        });
+      } else if (action2 === "status") {
+        if (!haltija?.videoStatus) {
+          this.respond(msg2.id, true, { recording: false });
+          return;
+        }
+        haltija.videoStatus().then((result2) => {
+          this.respond(msg2.id, true, result2);
+        }).catch(() => {
+          this.respond(msg2.id, true, { recording: false });
+        });
+      } else {
+        this.respond(msg2.id, false, undefined, `Unknown video action: ${action2}`);
+      }
+    }
     handleSemanticMessage(msg2) {
       const { action: action2, payload: payload2 } = msg2;
       if (action2 === "start" || action2 === "watch") {
@@ -5168,16 +5307,23 @@ ${elementSummary}${moreText}`;
       if (action2 === "refresh") {
         if (payload2.soft) {
           location.reload();
+          this.respond(msg2.id, true);
         } else {
-          if (location.protocol === "blob:" || location.protocol === "data:") {
-            location.reload();
+          const haltija = window.haltija;
+          if (haltija?.hardRefresh) {
+            haltija.hardRefresh().then(() => this.respond(msg2.id, true)).catch(() => {
+              location.reload();
+              this.respond(msg2.id, true);
+            });
+            return;
+          }
+          if (typeof caches !== "undefined") {
+            caches.keys().then((names) => Promise.all(names.map((n) => caches.delete(n)))).then(() => location.reload()).catch(() => location.reload());
           } else {
-            const url = new URL(location.href);
-            url.searchParams.set("_haltija_refresh", Date.now().toString());
-            location.href = url.toString();
+            location.reload();
           }
+          this.respond(msg2.id, true);
         }
-        this.respond(msg2.id, true);
       } else if (action2 === "goto") {
         const haltija = window.haltija;
         if (haltija?.navigate) {
@@ -5238,20 +5384,32 @@ ${elementSummary}${moreText}`;
         const req = payload2;
         try {
           if (req.all) {
-            const elements = resolveSelectorAll(req.selector);
+            const { elements, error } = resolveRefOrSelectorAll(req.ref, req.selector);
+            if (error && elements.length === 0) {
+              this.respond(msg2.id, false, null, error);
+              return;
+            }
             this.respond(msg2.id, true, elements.map(extractElement));
           } else {
-            const el = resolveSelector(req.selector);
-            this.respond(msg2.id, true, el ? extractElement(el) : null);
+            const { element, targetDesc, error } = resolveRefOrSelector(req.ref, req.selector);
+            if (error) {
+              this.respond(msg2.id, false, null, error);
+              return;
+            }
+            this.respond(msg2.id, true, element ? extractElement(element) : null);
           }
         } catch (err) {
           this.respond(msg2.id, false, null, err.message);
         }
       } else if (action2 === "inspect") {
         try {
-          const el = resolveSelector(payload2.selector);
+          const { element: el, targetDesc, error } = resolveRefOrSelector(payload2.ref, payload2.selector);
+          if (error) {
+            this.respond(msg2.id, false, null, error);
+            return;
+          }
           if (!el) {
-            this.respond(msg2.id, false, null, `Element not found: ${payload2.selector}`);
+            this.respond(msg2.id, false, null, `Element not found: ${targetDesc}`);
             return;
           }
           const opts = {
@@ -5264,7 +5422,11 @@ ${elementSummary}${moreText}`;
         }
       } else if (action2 === "inspectAll") {
         try {
-          const elements = resolveSelectorAll(payload2.selector);
+          const { elements, error } = resolveRefOrSelectorAll(payload2.ref, payload2.selector);
+          if (error && elements.length === 0) {
+            this.respond(msg2.id, false, null, error);
+            return;
+          }
           const opts = {
             fullStyles: payload2.fullStyles,
             matchedRules: payload2.matchedRules
@@ -5276,9 +5438,13 @@ ${elementSummary}${moreText}`;
         }
       } else if (action2 === "highlight") {
         try {
-          const el = resolveSelector(payload2.selector);
+          const { element: el, targetDesc, error } = resolveRefOrSelector(payload2.ref, payload2.selector);
+          if (error) {
+            this.respond(msg2.id, false, null, error);
+            return;
+          }
           if (!el) {
-            this.respond(msg2.id, false, null, `Element not found: ${payload2.selector}`);
+            this.respond(msg2.id, false, null, `Element not found: ${targetDesc}`);
             return;
           }
           if (payload2.duration) {
@@ -5286,7 +5452,7 @@ ${elementSummary}${moreText}`;
           } else {
             showHighlight(el, payload2.label, payload2.color);
           }
-          this.respond(msg2.id, true, { highlighted: payload2.selector });
+          this.respond(msg2.id, true, { highlighted: targetDesc });
         } catch (err) {
           this.respond(msg2.id, false, null, err.message);
         }
@@ -5413,10 +5579,21 @@ ${elementSummary}${moreText}`;
               img.src = dataUrl;
             });
           };
+          let targetSelector = payload2?.selector;
+          if (payload2?.ref) {
+            const { element, targetDesc, error } = resolveRefOrSelector(payload2.ref, undefined);
+            if (error) {
+              this.respond(msg2.id, false, null, error);
+              return;
+            }
+            if (element) {
+              targetSelector = element.id ? `#${element.id}` : element.getAttribute("data-testid") ? `[data-testid="${element.getAttribute("data-testid")}"]` : undefined;
+            }
+          }
           const haltija = window.haltija;
           if (haltija?.capturePage) {
             try {
-              const capturePromise = payload2?.selector ? haltija.captureElement(payload2.selector) : haltija.capturePage();
+              const capturePromise = targetSelector ? haltija.captureElement(targetSelector) : haltija.capturePage();
               const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve({ success: false, error: "Screenshot capture timed out after 10s" }), 1e4));
               const result2 = await Promise.race([capturePromise, timeoutPromise]);
               if (result2?.success && result2.data) {
@@ -5439,36 +5616,7 @@ ${elementSummary}${moreText}`;
               return;
             }
           }
-          const html2canvas = window.html2canvas;
-          if (html2canvas) {
-            const target = payload2?.selector ? resolveSelector(payload2.selector) : document.body;
-            if (!target) {
-              this.respond(msg2.id, false, null, `Element not found: ${payload2?.selector}`);
-              return;
-            }
-            const canvas = await html2canvas(target, {
-              useCORS: true,
-              allowTaint: true,
-              logging: false,
-              scale: payload2?.scale || 1
-            });
-            const dataUrl = canvas.toDataURL(mimeType, quality);
-            this.respond(msg2.id, true, {
-              image: dataUrl,
-              viewport,
-              format,
-              width: canvas.width,
-              height: canvas.height,
-              source: "html2canvas"
-            });
-          } else {
-            this.respond(msg2.id, true, {
-              viewport,
-              image: null,
-              note: "Screenshot capture requires the Haltija Desktop app.",
-              source: "viewport-only"
-            });
-          }
+          this.respond(msg2.id, false, null, "Screenshots require the Haltija Desktop app. Run: npx haltija@latest -f");
         } catch (err) {
           this.respond(msg2.id, false, null, err.message);
         }
@@ -6936,6 +7084,67 @@ ${elementSummary}${moreText}`;
       }
       this.respond(responseId, true);
     }
+    interceptDialogs() {
+      this.originalDialogs.alert = window.alert.bind(window);
+      this.originalDialogs.confirm = window.confirm.bind(window);
+      this.originalDialogs.prompt = window.prompt.bind(window);
+      const self = this;
+      window.alert = function(message) {
+        if (self._inHaltijaUI)
+          return self.originalDialogs.alert(message);
+        const msg2 = String(message ?? "");
+        const entry = { type: "alert", message: msg2, response: undefined, timestamp: Date.now() };
+        self.dialogHistory.push(entry);
+        if (self.dialogHistory.length > 50)
+          self.dialogHistory = self.dialogHistory.slice(-25);
+        self.send("dialog", "opened", { type: "alert", message: msg2, windowId: self.windowId });
+      };
+      window.confirm = function(message) {
+        if (self._inHaltijaUI)
+          return self.originalDialogs.confirm(message);
+        const msg2 = String(message ?? "");
+        const accept = self.dialogPolicy.confirm === "accept";
+        const entry = { type: "confirm", message: msg2, response: accept, timestamp: Date.now() };
+        self.dialogHistory.push(entry);
+        if (self.dialogHistory.length > 50)
+          self.dialogHistory = self.dialogHistory.slice(-25);
+        self.send("dialog", "opened", {
+          type: "confirm",
+          message: msg2,
+          response: accept,
+          windowId: self.windowId
+        });
+        return accept;
+      };
+      window.prompt = function(message, defaultValue) {
+        if (self._inHaltijaUI)
+          return self.originalDialogs.prompt(message, defaultValue);
+        const msg2 = String(message ?? "");
+        const policy = self.dialogPolicy.prompt;
+        const response = policy === "dismiss" ? null : policy.response;
+        const entry = { type: "prompt", message: msg2, defaultValue, response, timestamp: Date.now() };
+        self.dialogHistory.push(entry);
+        if (self.dialogHistory.length > 50)
+          self.dialogHistory = self.dialogHistory.slice(-25);
+        self.send("dialog", "opened", {
+          type: "prompt",
+          message: msg2,
+          defaultValue,
+          response,
+          windowId: self.windowId
+        });
+        return response;
+      };
+    }
+    restoreDialogs() {
+      if (this.originalDialogs.alert)
+        window.alert = this.originalDialogs.alert;
+      if (this.originalDialogs.confirm)
+        window.confirm = this.originalDialogs.confirm;
+      if (this.originalDialogs.prompt)
+        window.prompt = this.originalDialogs.prompt;
+      this.originalDialogs = {};
+    }
     interceptConsole() {
       const levels = [
         "log",
@@ -6994,6 +7203,7 @@ ${elementSummary}${moreText}`;
     currentTagName = TAG_NAME;
     window.__haltija_resolveSelector = resolveSelector;
     window.__haltija_resolveSelectorAll = resolveSelectorAll;
+    window.__haltija_refRegistry = refRegistry;
   }
   registerDevChannel();
   var WIDGET_ID = "haltija-widget";