@ranganathmk/trq 0.1.0

package/dist/studio/main/main.cjs

@@ -0,0 +1,2525 @@
+var __trq_meta_url__ = require("url").pathToFileURL(__filename).href;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/main/main.ts
+var import_electron2 = require("electron");
+var import_node_path7 = __toESM(require("node:path"));
+
+// src/main/ipc.ts
+var import_node_fs6 = require("node:fs");
+var import_node_path6 = __toESM(require("node:path"));
+var import_electron = require("electron");
+
+// ../core/dist/index.js
+var import_module = require("module");
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_url = require("node:url");
+var import_node_fs = require("node:fs");
+var import_node_fs2 = require("node:fs");
+var import_node_fs3 = require("node:fs");
+var import_node_path2 = __toESM(require("node:path"), 1);
+var import_puppeteer = __toESM(require("puppeteer"), 1);
+var import_node_path3 = __toESM(require("node:path"), 1);
+var import_node_url2 = require("node:url");
+var import_puppeteer2 = __toESM(require("puppeteer"), 1);
+var import_node_fs4 = require("node:fs");
+var import_node_path4 = __toESM(require("node:path"), 1);
+var import_node_url3 = require("node:url");
+var import_puppeteer3 = __toESM(require("puppeteer"), 1);
+var import_node_fs5 = require("node:fs");
+var import_node_path5 = __toESM(require("node:path"), 1);
+var import_node_url4 = require("node:url");
+var require2 = (0, import_module.createRequire)(__trq_meta_url__);
+var __defProp2 = Object.defineProperty;
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames2(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp2(target, name, { get: all[name], enumerable: true });
+};
+var page_context_exports = {};
+__export(page_context_exports, {
+  cdpPageContext: () => cdpPageContext,
+  puppeteerPageContext: () => puppeteerPageContext
+});
+function puppeteerPageContext(page, client) {
+  return {
+    client,
+    evaluate: (fnOrExpr, ...args) => page.evaluate(fnOrExpr, ...args),
+    url: () => page.url(),
+    goto: async (url, opts) => {
+      await page.goto(url, { waitUntil: "networkidle2", timeout: opts?.timeout ?? 3e4 });
+    },
+    waitForLoad: async (timeout) => {
+      await page.waitForNavigation({ timeout: timeout ?? 3e4 }).catch(() => {
+      });
+    }
+  };
+}
+function cdpPageContext(client, options = {}) {
+  let currentUrl = options.initialUrl ?? "about:blank";
+  let mainFrameId = null;
+  void client.send("Page.getFrameTree").then((tree) => {
+    const t = tree;
+    mainFrameId = t.frameTree?.frame?.id ?? null;
+    if (t.frameTree?.frame?.url) currentUrl = t.frameTree.frame.url;
+  }).catch(() => {
+  });
+  client.on("Page.frameNavigated", (raw) => {
+    const e = raw;
+    if (e.frame.parentId) return;
+    if (mainFrameId && e.frame.id !== mainFrameId) return;
+    currentUrl = e.frame.url;
+  });
+  client.on("Page.navigatedWithinDocument", (raw) => {
+    const e = raw;
+    if (mainFrameId && e.frameId !== mainFrameId) return;
+    currentUrl = e.url;
+  });
+  const waitForLoad = (timeout = 3e4) => new Promise((resolve) => {
+    const t = setTimeout(() => {
+      client.off?.("Page.loadEventFired", onLoad);
+      resolve();
+    }, timeout);
+    const onLoad = () => {
+      clearTimeout(t);
+      client.off?.("Page.loadEventFired", onLoad);
+      resolve();
+    };
+    client.on("Page.loadEventFired", onLoad);
+  });
+  const evaluateExpr = async (expression) => {
+    const r = await client.send("Runtime.evaluate", {
+      expression,
+      awaitPromise: true,
+      returnByValue: true
+    });
+    if (r.exceptionDetails) {
+      const desc = r.exceptionDetails.exception?.description ?? r.exceptionDetails.text ?? "evaluate failed";
+      throw new Error(desc);
+    }
+    return r.result?.value;
+  };
+  return {
+    client,
+    evaluate: (fnOrExpr, ...args) => {
+      if (typeof fnOrExpr === "string") {
+        return evaluateExpr(fnOrExpr);
+      }
+      const body = fnOrExpr.toString();
+      const jsonArgs = args.map((a) => JSON.stringify(a)).join(",");
+      const expression = `(${body})(${jsonArgs})`;
+      return evaluateExpr(expression);
+    },
+    url: () => currentUrl,
+    goto: async (url, opts) => {
+      const loaded = waitForLoad(opts?.timeout ?? 3e4);
+      await client.send("Page.navigate", { url });
+      await loaded;
+      await new Promise((r) => setTimeout(r, 200));
+    },
+    waitForLoad
+  };
+}
+var init_page_context = __esm({
+  "src/page-context.ts"() {
+    "use strict";
+  }
+});
+var Session = class _Session {
+  constructor(dir, manifest) {
+    this.dir = dir;
+    this.manifest = manifest;
+  }
+  writeChain = Promise.resolve();
+  static async create(rootDir, name, initialUrl) {
+    const dir = import_node_path2.default.join(rootDir, name);
+    if ((0, import_node_fs3.existsSync)(dir)) {
+      throw new Error(`Session already exists: ${name}`);
+    }
+    await import_node_fs2.promises.mkdir(dir, { recursive: true });
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const manifest = {
+      id: `ses_${randomId()}`,
+      name,
+      createdAt: now,
+      updatedAt: now,
+      stepCount: 0,
+      initialUrl: initialUrl ?? null,
+      lastUrl: initialUrl ?? null
+    };
+    await import_node_fs2.promises.writeFile(import_node_path2.default.join(dir, "manifest.json"), JSON.stringify(manifest, null, 2));
+    await import_node_fs2.promises.writeFile(import_node_path2.default.join(dir, "events.jsonl"), "");
+    return new _Session(dir, manifest);
+  }
+  static async load(rootDir, name) {
+    const dir = import_node_path2.default.join(rootDir, name);
+    const raw = await import_node_fs2.promises.readFile(import_node_path2.default.join(dir, "manifest.json"), "utf8");
+    return new _Session(dir, JSON.parse(raw));
+  }
+  static async list(rootDir) {
+    if (!(0, import_node_fs3.existsSync)(rootDir)) return [];
+    const names = await import_node_fs2.promises.readdir(rootDir);
+    const out = [];
+    for (const name of names) {
+      const mp = import_node_path2.default.join(rootDir, name, "manifest.json");
+      if (!(0, import_node_fs3.existsSync)(mp)) continue;
+      try {
+        out.push(JSON.parse(await import_node_fs2.promises.readFile(mp, "utf8")));
+      } catch {
+      }
+    }
+    return out.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+  }
+  // Builds an event ID from its 1-based position. Used by all mutations so
+  // IDs stay sequential — after a delete or insert, every event keeps a
+  // position-matching id (evt_0001..evt_000N with no gaps).
+  idFor(pos1Based) {
+    return `evt_${String(pos1Based).padStart(4, "0")}`;
+  }
+  appendEvent(event) {
+    const next = this.writeChain.then(async () => {
+      this.manifest.stepCount++;
+      const id = this.idFor(this.manifest.stepCount);
+      const stamped = { ...event, id };
+      await import_node_fs2.promises.appendFile(import_node_path2.default.join(this.dir, "events.jsonl"), JSON.stringify(stamped) + "\n");
+      this.manifest.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (this.manifest.initialUrl === null) this.manifest.initialUrl = event.url;
+      this.manifest.lastUrl = event.url;
+      await this.flushManifest();
+      return stamped;
+    });
+    this.writeChain = next.catch(() => {
+    });
+    return next;
+  }
+  // Replace fields on an existing event (matched by id). Selectors, value,
+  // assertion spec, etc. The id itself and the event's index are preserved.
+  // Use this for fixing brittle selectors, correcting an input value, etc.
+  async replaceEvent(id, patch) {
+    const next = this.writeChain.then(async () => {
+      const events = await this.readEvents();
+      const idx = events.findIndex((e) => e.id === id);
+      if (idx === -1) throw new Error(`No event with id ${id}`);
+      const merged = { ...events[idx], ...patch, id };
+      events[idx] = merged;
+      await this.writeAllEvents(events);
+      this.manifest.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await this.flushManifest();
+      return merged;
+    });
+    this.writeChain = next.catch(() => {
+    });
+    return next;
+  }
+  // Delete an event by id. Subsequent events are renumbered so IDs stay
+  // sequential (evt_0001..evt_000N with no gaps). stepCount = new length.
+  async removeEvent(id) {
+    const next = this.writeChain.then(async () => {
+      const events = await this.readEvents();
+      const idx = events.findIndex((e) => e.id === id);
+      if (idx === -1) throw new Error(`No event with id ${id}`);
+      events.splice(idx, 1);
+      this.renumber(events);
+      this.manifest.stepCount = events.length;
+      this.manifest.lastUrl = events[events.length - 1]?.url ?? this.manifest.lastUrl;
+      this.manifest.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await this.writeAllEvents(events);
+      await this.flushManifest();
+    });
+    this.writeChain = next.catch(() => {
+    });
+    return next;
+  }
+  // Insert a new event at the given 0-based index (so 0 means "before first",
+  // events.length means "at end"). The whole event list is renumbered to
+  // stay sequential. Returns the stamped event with its post-renumber id.
+  async insertEventAt(idx, event) {
+    const next = this.writeChain.then(async () => {
+      const events = await this.readEvents();
+      const safeIdx = Math.max(0, Math.min(idx, events.length));
+      const stamped = { ...event, id: "evt_xxxx" };
+      events.splice(safeIdx, 0, stamped);
+      this.renumber(events);
+      this.manifest.stepCount = events.length;
+      if (this.manifest.initialUrl === null) this.manifest.initialUrl = event.url;
+      this.manifest.lastUrl = events[events.length - 1].url;
+      this.manifest.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await this.writeAllEvents(events);
+      await this.flushManifest();
+      return events[safeIdx];
+    });
+    this.writeChain = next.catch(() => {
+    });
+    return next;
+  }
+  renumber(events) {
+    for (let i = 0; i < events.length; i++) {
+      events[i].id = this.idFor(i + 1);
+    }
+  }
+  // Create a new session containing events 1..throughStep (inclusive,
+  // 1-based) from this session. Copies config.json. Useful for forking a
+  // recording at a known-good step to retry a divergent path.
+  async branch(rootDir, newName, throughStep) {
+    const events = await this.readEvents();
+    const target = Math.max(0, Math.min(throughStep, events.length));
+    const sliced = events.slice(0, target);
+    const branched = await _Session.create(rootDir, newName, this.manifest.initialUrl);
+    const lines = [];
+    for (let i = 0; i < sliced.length; i++) {
+      const id = `evt_${String(i + 1).padStart(4, "0")}`;
+      const e = { ...sliced[i], id };
+      lines.push(JSON.stringify(e));
+    }
+    await import_node_fs2.promises.writeFile(import_node_path2.default.join(branched.dir, "events.jsonl"), lines.length ? lines.join("\n") + "\n" : "");
+    branched.manifest.stepCount = sliced.length;
+    branched.manifest.lastUrl = sliced[sliced.length - 1]?.url ?? branched.manifest.initialUrl;
+    branched.manifest.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await branched.flushManifest();
+    const cfg = await this.readConfig();
+    if (Object.keys(cfg).length > 0) await branched.writeConfig(cfg);
+    return branched;
+  }
+  async writeAllEvents(events) {
+    const body = events.length ? events.map((e) => JSON.stringify(e)).join("\n") + "\n" : "";
+    await import_node_fs2.promises.writeFile(import_node_path2.default.join(this.dir, "events.jsonl"), body);
+  }
+  async flushManifest() {
+    await import_node_fs2.promises.writeFile(
+      import_node_path2.default.join(this.dir, "manifest.json"),
+      JSON.stringify(this.manifest, null, 2)
+    );
+  }
+  async readEvents() {
+    const raw = await import_node_fs2.promises.readFile(import_node_path2.default.join(this.dir, "events.jsonl"), "utf8");
+    return raw.split("\n").map((l) => l.trim()).filter(Boolean).map((l) => JSON.parse(l));
+  }
+  async readConfig() {
+    const p = import_node_path2.default.join(this.dir, "config.json");
+    if (!(0, import_node_fs3.existsSync)(p)) return {};
+    try {
+      return JSON.parse(await import_node_fs2.promises.readFile(p, "utf8"));
+    } catch {
+      return {};
+    }
+  }
+  async writeConfig(cfg) {
+    await import_node_fs2.promises.writeFile(
+      import_node_path2.default.join(this.dir, "config.json"),
+      JSON.stringify(cfg, null, 2)
+    );
+  }
+};
+function randomId() {
+  return Math.random().toString(36).slice(2, 8) + Date.now().toString(36).slice(-4);
+}
+async function safeSend(client, method, params) {
+  try {
+    await client.send(method, params);
+  } catch (err) {
+    console.warn(`[config] ${method} failed: ${err.message}`);
+  }
+}
+async function applyConfig(client, cfg, options = {}) {
+  if (cfg.viewport) {
+    await safeSend(client, "Emulation.setDeviceMetricsOverride", {
+      width: cfg.viewport.width,
+      height: cfg.viewport.height,
+      deviceScaleFactor: cfg.viewport.deviceScaleFactor ?? 1,
+      mobile: cfg.viewport.mobile ?? false,
+      // Critical: without this, Chromium expands the visible BrowserView area
+      // to match the device-metrics size, overlapping any UI below it. The
+      // visible bounds are owned by view.setBounds elsewhere; this command
+      // should only affect what the page reports as its viewport.
+      dontSetVisibleSize: true
+    });
+  }
+  if (cfg.locale) {
+    await safeSend(client, "Emulation.setLocaleOverride", { locale: cfg.locale });
+  }
+  if (cfg.timezone) {
+    await safeSend(client, "Emulation.setTimezoneOverride", {
+      timezoneId: cfg.timezone
+    });
+  }
+  if (cfg.userAgent) {
+    await safeSend(client, "Network.setUserAgentOverride", { userAgent: cfg.userAgent });
+  }
+  if (cfg.extraHeaders && Object.keys(cfg.extraHeaders).length > 0) {
+    await safeSend(client, "Network.enable", {});
+    await safeSend(client, "Network.setExtraHTTPHeaders", { headers: cfg.extraHeaders });
+  }
+  if (cfg.bypassCSP) {
+    await safeSend(client, "Page.setBypassCSP", { enabled: true });
+  }
+  if (cfg.permissions && cfg.permissions.length > 0) {
+    const params = {
+      permissions: cfg.permissions
+    };
+    if (options.origin) params.origin = options.origin;
+    await safeSend(client, "Browser.grantPermissions", params);
+  }
+  if (cfg.geolocation) {
+    await safeSend(client, "Emulation.setGeolocationOverride", {
+      latitude: cfg.geolocation.latitude,
+      longitude: cfg.geolocation.longitude,
+      accuracy: cfg.geolocation.accuracy ?? 10
+    });
+  }
+}
+var BINDING_NAME = "__trqEmit";
+var isRecordableUrl = (url) => !!url && url !== "about:blank" && !url.startsWith("chrome://") && !url.startsWith("chrome-extension://") && !url.startsWith("devtools://") && !url.startsWith("data:");
+async function broadcastStepCount(ctx) {
+  const n = ctx.session.manifest.stepCount;
+  const expr = `window.__trqSetStep && window.__trqSetStep(${n})`;
+  await Promise.all(
+    Array.from(ctx.clients).map(
+      (c) => c.send("Runtime.evaluate", { expression: expr }).catch(() => {
+      })
+    )
+  );
+}
+async function recordNav(ctx, url, source) {
+  if (!isRecordableUrl(url)) return;
+  if (source === "load" && isAnchorClickPrev(ctx.lastEmittedEvent)) return;
+  const stamped = await ctx.session.appendEvent({
+    type: "navigate",
+    timestamp: Date.now(),
+    url,
+    frame: "main",
+    source
+  });
+  ctx.lastEmittedEvent = stamped;
+  ctx.onEvent?.(stamped);
+  await broadcastStepCount(ctx);
+}
+function isAnchorClickPrev(prev) {
+  if (!prev || prev.type !== "click") return false;
+  const t = prev.target;
+  return t.tagName === "A" || t.attributes?.target === "_blank" || !!t.attributes?.href;
+}
+async function setupRecordingOnClient(client, ctx) {
+  ctx.clients.add(client);
+  client.on("disconnected", () => ctx.clients.delete(client));
+  await client.send("Runtime.enable");
+  await client.send("Page.enable");
+  if (ctx.config) {
+    await applyConfig(client, ctx.config);
+  }
+  await client.send("Runtime.addBinding", { name: BINDING_NAME }).catch(() => {
+  });
+  await client.send("Page.addScriptToEvaluateOnNewDocument", { source: ctx.bootstrap });
+  let mainFrameId = null;
+  try {
+    const tree = await client.send("Page.getFrameTree");
+    mainFrameId = tree.frameTree.frame.id;
+  } catch {
+  }
+  let lastNavUrl = null;
+  client.on("Runtime.bindingCalled", async (raw) => {
+    const event = raw;
+    if (event.name !== BINDING_NAME) return;
+    try {
+      const incoming = JSON.parse(event.payload);
+      if (incoming.__trq === "ready") {
+        await broadcastStepCount(ctx);
+        return;
+      }
+      const stamped = await ctx.session.appendEvent(
+        incoming
+      );
+      ctx.lastEmittedEvent = stamped;
+      ctx.onEvent?.(stamped);
+      await broadcastStepCount(ctx);
+    } catch (err) {
+      console.error("\nFailed to handle event:", err.message);
+    }
+  });
+  client.on("Page.frameNavigated", async (raw) => {
+    const e = raw;
+    if (e.frame.parentId) return;
+    const url = e.frame.url;
+    if (!isRecordableUrl(url)) return;
+    if (url === lastNavUrl) return;
+    lastNavUrl = url;
+    await recordNav(ctx, url, "load");
+  });
+  client.on("Page.navigatedWithinDocument", async (raw) => {
+    const e = raw;
+    if (mainFrameId && e.frameId !== mainFrameId) return;
+    if (!isRecordableUrl(e.url)) return;
+    if (e.url === lastNavUrl) return;
+    lastNavUrl = e.url;
+    await recordNav(ctx, e.url, "in-document");
+  });
+  await client.send("Runtime.evaluate", { expression: ctx.bootstrap }).catch(() => {
+  });
+  await broadcastStepCount(ctx);
+}
+var __dirname2 = import_node_path3.default.dirname((0, import_node_url2.fileURLToPath)(__trq_meta_url__));
+var BOOTSTRAP_PATH = import_node_path3.default.join(__dirname2, "bootstrap.js");
+init_page_context();
+var __dirname22 = import_node_path4.default.dirname((0, import_node_url3.fileURLToPath)(__trq_meta_url__));
+var HELPERS_PATH = import_node_path4.default.join(__dirname22, "replay-helpers.js");
+var ANIMATION_KILL_CSS = `
+  *, *::before, *::after {
+    animation-duration: 0s !important;
+    animation-delay: 0s !important;
+    transition-duration: 0s !important;
+    transition-delay: 0s !important;
+    scroll-behavior: auto !important;
+  }
+`;
+var INJECT_ANIMATION_KILL = `
+  (function () {
+    try {
+      const s = document.createElement('style');
+      s.setAttribute('data-trq', 'animkill');
+      s.textContent = ${JSON.stringify(ANIMATION_KILL_CSS)};
+      (document.head || document.documentElement).appendChild(s);
+    } catch (e) {}
+  })();
+`;
+function modBits(mods) {
+  let b = 0;
+  for (const m of mods) {
+    if (m === "Alt") b |= 1;
+    if (m === "Control") b |= 2;
+    if (m === "Meta") b |= 4;
+    if (m === "Shift") b |= 8;
+  }
+  return b;
+}
+var MOUSE_BUTTON = {
+  left: "left",
+  right: "right",
+  middle: "middle"
+};
+async function waitFor(predicate, timeout = 5e3, pollMs = 100) {
+  const start = Date.now();
+  while (Date.now() - start < timeout) {
+    if (await predicate()) return true;
+    await new Promise((r) => setTimeout(r, pollMs));
+  }
+  return false;
+}
+async function waitForResolvable(ctx, selectors, timeout = 5e3) {
+  const ok = await waitFor(
+    async () => await ctx.evaluate((sels) => {
+      const w = window;
+      return !!w.__trqResolve?.(sels)?.found;
+    }, selectors).catch(() => false),
+    timeout
+  );
+  if (!ok) {
+    throw new Error(`selector did not resolve within ${timeout}ms: ${selectors[0]?.[0] ?? "?"}`);
+  }
+}
+async function replayClick(e, ctx) {
+  await waitForResolvable(ctx, e.selectors);
+  const result = await ctx.evaluate(
+    (sels) => window.__trqClick(sels),
+    e.selectors
+  );
+  if (result.error || !result.rect) throw new Error(result.error || "no rect from click resolve");
+  const { rect } = result;
+  const x = rect.x + Math.min(e.click.offsetX, rect.w);
+  const y = rect.y + Math.min(e.click.offsetY, rect.h);
+  const button = MOUSE_BUTTON[e.click.button] ?? "left";
+  const modifiers = modBits(e.click.modifiers);
+  await ctx.client.send("Input.dispatchMouseEvent", { type: "mouseMoved", x, y });
+  await ctx.client.send("Input.dispatchMouseEvent", {
+    type: "mousePressed",
+    x,
+    y,
+    button,
+    modifiers,
+    clickCount: e.click.clickCount
+  });
+  await ctx.client.send("Input.dispatchMouseEvent", {
+    type: "mouseReleased",
+    x,
+    y,
+    button,
+    modifiers,
+    clickCount: e.click.clickCount
+  });
+}
+async function replayInput(e, ctx) {
+  await waitForResolvable(ctx, e.selectors);
+  const result = await ctx.evaluate(
+    (sels, val) => window.__trqSetInput(sels, val),
+    e.selectors,
+    e.value
+  );
+  if (result.error) throw new Error(result.error);
+}
+async function replayKey(e, ctx) {
+  await ctx.evaluate(
+    (sels) => window.__trqFocus?.(sels),
+    e.selectors
+  ).catch(() => {
+  });
+  const mods = modBits(e.modifiers);
+  await ctx.client.send("Input.dispatchKeyEvent", {
+    type: "keyDown",
+    key: e.key,
+    code: e.key,
+    modifiers: mods
+  });
+  await ctx.client.send("Input.dispatchKeyEvent", {
+    type: "keyUp",
+    key: e.key,
+    code: e.key,
+    modifiers: mods
+  });
+}
+async function replayAssert(e, ctx) {
+  await waitForResolvable(ctx, e.selectors);
+  const result = await ctx.evaluate(
+    (sels, spec) => window.__trqAssert(sels, spec),
+    e.selectors,
+    e.assertion
+  );
+  if (!result.ok) throw new Error(result.reason ?? "assertion failed");
+}
+async function replayNavigate(e, ctx, prev) {
+  const wasUserAction = prev && (prev.type === "click" || prev.type === "key");
+  const prevClickTarget = prev?.type === "click" ? prev.target : null;
+  const prevIsAnchorClick = !!prevClickTarget && (prevClickTarget.tagName === "A" || prevClickTarget.attributes?.target === "_blank" || !!prevClickTarget.attributes?.href);
+  if (e.source === "in-document") {
+    const ok = await waitFor(async () => ctx.url() === e.url, 5e3);
+    if (!ok) {
+      throw new Error(`in-document nav to ${e.url} did not occur (still at ${ctx.url()})`);
+    }
+    return;
+  }
+  if (prevIsAnchorClick) {
+    const before = ctx.url();
+    const ok = await waitFor(async () => ctx.url() !== before, 1e4);
+    if (!ok) {
+      throw new Error(`anchor click did not trigger a navigation (still at ${before})`);
+    }
+    await waitFor(
+      async () => await ctx.evaluate(() => document.readyState) === "complete",
+      5e3
+    ).catch(() => false);
+    return;
+  }
+  if (wasUserAction) {
+    const ok = await waitFor(async () => ctx.url() === e.url, 5e3);
+    if (ok) return;
+  }
+  await ctx.goto(e.url, { timeout: 3e4 });
+}
+function isAnchorClick(e) {
+  if (e.type !== "click") return false;
+  const t = e.target;
+  return t.tagName === "A" || t.attributes?.target === "_blank" || !!t.attributes?.href;
+}
+function urlAreaOf(url) {
+  if (!url) return null;
+  try {
+    const u = new URL(url);
+    const segs = u.pathname.split("/").filter((s) => s.length > 0);
+    return { origin: u.origin, head: segs[0] ?? "" };
+  } catch {
+    return null;
+  }
+}
+function urlInArea(url, area) {
+  try {
+    const u = new URL(url);
+    const head = u.pathname.split("/").filter((s) => s.length > 0)[0] ?? "";
+    return u.origin === area.origin && head === area.head;
+  } catch {
+    return false;
+  }
+}
+async function waitForAnchorClickConsequence(getActiveClient, fallbackClient, ctxFor, clientBefore, expectedNextUrl, nextEventSelectors, switchTimeoutMs = 3e3, totalTimeoutMs = 2e4, stableWindowMs = 1200) {
+  const start = Date.now();
+  while (Date.now() - start < switchTimeoutMs) {
+    const cNow = getActiveClient?.() ?? fallbackClient;
+    if (cNow !== clientBefore) break;
+    await new Promise((r) => setTimeout(r, 50));
+  }
+  const cFinal = getActiveClient?.() ?? fallbackClient;
+  const ctxFinal = ctxFor(cFinal);
+  const expectedArea = urlAreaOf(expectedNextUrl);
+  let lastUrl = null;
+  let stableSince = Date.now();
+  while (Date.now() - start < totalTimeoutMs) {
+    let ready = false;
+    try {
+      const v = await ctxFinal.evaluate(() => document.readyState);
+      ready = v === "complete";
+    } catch {
+    }
+    const u = ctxFinal.url();
+    if (u !== lastUrl) {
+      lastUrl = u;
+      stableSince = Date.now();
+    }
+    const inArea = expectedArea ? urlInArea(u, expectedArea) : true;
+    if (ready && inArea && Date.now() - stableSince >= stableWindowMs) break;
+    await new Promise((r) => setTimeout(r, 150));
+  }
+  if (nextEventSelectors && nextEventSelectors.length > 0) {
+    const remaining = Math.max(0, totalTimeoutMs - (Date.now() - start));
+    await waitFor(
+      async () => {
+        try {
+          const found = await ctxFinal.evaluate((sels) => {
+            const w = window;
+            return !!w.__trqResolve?.(sels)?.found;
+          }, nextEventSelectors);
+          return found;
+        } catch {
+          return false;
+        }
+      },
+      remaining
+    ).catch(() => false);
+  }
+}
+async function setupReplayClient(client, opts = {}) {
+  const helpers = await import_node_fs4.promises.readFile(HELPERS_PATH, "utf8");
+  await client.send("Page.enable");
+  await client.send("Runtime.enable");
+  if (opts.config) {
+    await applyConfig(client, opts.config);
+  }
+  if (process.env.TRQ_DEBUG_REPLAY) {
+    const setFlag = "window.__trqDebugResolve = true;";
+    await client.send("Page.addScriptToEvaluateOnNewDocument", { source: setFlag });
+    await client.send("Runtime.evaluate", { expression: setFlag }).catch(() => {
+    });
+  }
+  await client.send("Page.addScriptToEvaluateOnNewDocument", { source: helpers });
+  if (opts.killAnimations !== false) {
+    await client.send("Page.addScriptToEvaluateOnNewDocument", {
+      source: INJECT_ANIMATION_KILL
+    });
+  }
+  await client.send("Runtime.evaluate", { expression: helpers }).catch(() => {
+  });
+  if (opts.killAnimations !== false) {
+    await client.send("Runtime.evaluate", { expression: INJECT_ANIMATION_KILL }).catch(() => {
+    });
+  }
+}
+async function runReplayOnClient(opts) {
+  let events = await opts.session.readEvents();
+  let total = events.length;
+  let target = opts.toStep != null ? Math.min(opts.toStep, total) : total;
+  const config = await opts.session.readConfig();
+  await setupReplayClient(opts.client, {
+    config,
+    killAnimations: opts.killAnimations
+  });
+  const { cdpPageContext: cdpPageContext2 } = await Promise.resolve().then(() => (init_page_context(), page_context_exports));
+  const ctxCache = /* @__PURE__ */ new Map();
+  const ctxFor = (c) => {
+    let cached = ctxCache.get(c);
+    if (!cached) {
+      cached = cdpPageContext2(c);
+      ctxCache.set(c, cached);
+    }
+    return cached;
+  };
+  const activeCtx = () => ctxFor(opts.getActiveClient?.() ?? opts.client);
+  if (opts.startUrl && opts.startUrl !== "about:blank") {
+    await activeCtx().goto(opts.startUrl).catch(() => {
+    });
+  }
+  let completed = 0;
+  let prev = null;
+  for (let i = 0; i < target; i++) {
+    if (opts.shouldCancel?.()) {
+      return { completed, total };
+    }
+    const e = events[i];
+    await opts.shouldWait?.(i, target, e);
+    if (opts.shouldCancel?.()) {
+      return { completed, total };
+    }
+    opts.onProgress?.(i + 1, target, e, "start");
+    const ctx = activeCtx();
+    if (process.env.TRQ_DEBUG_REPLAY) {
+      console.log(`[replay] step ${i + 1}/${target} ${e.type} @ ${ctx.url()}`);
+    }
+    try {
+      const clientBefore = opts.getActiveClient?.() ?? opts.client;
+      switch (e.type) {
+        case "navigate":
+          await replayNavigate(e, ctx, prev);
+          break;
+        case "click":
+          await replayClick(e, ctx);
+          break;
+        case "input":
+          await replayInput(e, ctx);
+          break;
+        case "key":
+          await replayKey(e, ctx);
+          break;
+        case "assert":
+          await replayAssert(e, ctx);
+          break;
+      }
+      if (e.type === "click" && isAnchorClick(e)) {
+        const next = events[i + 1];
+        const expectedNextUrl = next && "url" in next ? next.url : void 0;
+        const nextSelectors = next && "selectors" in next ? next.selectors : void 0;
+        await waitForAnchorClickConsequence(
+          opts.getActiveClient,
+          opts.client,
+          ctxFor,
+          clientBefore,
+          expectedNextUrl,
+          nextSelectors
+        );
+      }
+      const settle = opts.slow ? 400 : e.type === "click" || e.type === "key" ? 60 : 20;
+      if (settle) await new Promise((r) => setTimeout(r, settle));
+      completed++;
+      prev = e;
+      opts.onProgress?.(i + 1, target, e, "ok");
+    } catch (err) {
+      const msg = err.message;
+      opts.onProgress?.(i + 1, target, e, "fail", msg);
+      if (opts.shouldPauseOnFail) {
+        const action = await opts.shouldPauseOnFail(i, target, e, msg);
+        if (action === "retry" || action === "skip") {
+          events = await opts.session.readEvents();
+          total = events.length;
+          target = opts.toStep != null ? Math.min(opts.toStep, total) : total;
+          if (action === "retry") {
+            const newIdx2 = events.findIndex((ev) => ev.id === e.id);
+            i = (newIdx2 === -1 ? i : newIdx2) - 1;
+            continue;
+          }
+          const newIdx = events.findIndex((ev) => ev.id === e.id);
+          if (newIdx !== -1) i = newIdx;
+          prev = events[i] ?? e;
+          continue;
+        }
+      }
+      return {
+        completed,
+        total,
+        failed: { step: i + 1, reason: msg, event: e }
+      };
+    }
+  }
+  return { completed, total };
+}
+init_page_context();
+var __dirname3 = import_node_path5.default.dirname((0, import_node_url4.fileURLToPath)(__trq_meta_url__));
+var BOOTSTRAP_PATH2 = import_node_path5.default.join(__dirname3, "bootstrap.js");
+var BINDING_NAME2 = "__trqEmit";
+async function runResumeOnClient(opts) {
+  let events = await opts.session.readEvents();
+  let total = events.length;
+  const helpers = await import_node_fs5.promises.readFile(HELPERS_PATH, "utf8");
+  const bootstrap = await import_node_fs5.promises.readFile(BOOTSTRAP_PATH2, "utf8");
+  const config = await opts.session.readConfig();
+  const client = opts.client;
+  let mode = "replaying";
+  const broadcastStepCount2 = async () => {
+    const n = opts.session.manifest.stepCount;
+    await client.send("Runtime.evaluate", {
+      expression: `window.__trqSetStep && window.__trqSetStep(${n})`
+    }).catch(() => {
+    });
+  };
+  const broadcastMode = async (m) => {
+    await client.send("Runtime.evaluate", {
+      expression: `window.__trqMode = ${JSON.stringify(m)};`
+    }).catch(() => {
+    });
+  };
+  await client.send("Runtime.enable");
+  await client.send("Page.enable");
+  await applyConfig(client, config);
+  await client.send("Runtime.addBinding", { name: BINDING_NAME2 }).catch(() => {
+  });
+  await client.send("Page.addScriptToEvaluateOnNewDocument", {
+    source: `window.__trqMode = window.__trqMode || ${JSON.stringify(mode)};`
+  });
+  await client.send("Page.addScriptToEvaluateOnNewDocument", { source: helpers });
+  await client.send("Page.addScriptToEvaluateOnNewDocument", { source: bootstrap });
+  if (opts.killAnimations !== false) {
+    await client.send("Page.addScriptToEvaluateOnNewDocument", { source: INJECT_ANIMATION_KILL });
+  }
+  client.on("Runtime.bindingCalled", async (raw) => {
+    const event = raw;
+    if (event.name !== BINDING_NAME2) return;
+    try {
+      const incoming = JSON.parse(event.payload);
+      if (incoming.__trq === "ready") {
+        await broadcastStepCount2();
+        return;
+      }
+      if (mode !== "recording") return;
+      const stamped = await opts.session.appendEvent(incoming);
+      opts.onRecordEvent?.(stamped);
+      await broadcastStepCount2();
+    } catch (err) {
+      console.error("\nFailed to handle event:", err.message);
+    }
+  });
+  await client.send("Runtime.evaluate", {
+    expression: `window.__trqMode = window.__trqMode || ${JSON.stringify(mode)};`
+  }).catch(() => {
+  });
+  await client.send("Runtime.evaluate", { expression: helpers }).catch(() => {
+  });
+  await client.send("Runtime.evaluate", { expression: bootstrap }).catch(() => {
+  });
+  if (opts.killAnimations !== false) {
+    await client.send("Runtime.evaluate", { expression: INJECT_ANIMATION_KILL }).catch(() => {
+    });
+  }
+  const ctxCache = /* @__PURE__ */ new Map();
+  const ctxFor = (c) => {
+    let cached = ctxCache.get(c);
+    if (!cached) {
+      cached = cdpPageContext(c);
+      ctxCache.set(c, cached);
+    }
+    return cached;
+  };
+  const activeCtx = () => ctxFor(opts.getActiveClient?.() ?? client);
+  if (opts.startUrl && opts.startUrl !== "about:blank") {
+    await activeCtx().goto(opts.startUrl).catch(() => {
+    });
+  }
+  let prev = null;
+  for (let i = 0; i < total; i++) {
+    if (opts.shouldCancel?.()) return { replayed: i };
+    const e = events[i];
+    opts.onReplayProgress?.(i + 1, total, e, "start");
+    const ctx = activeCtx();
+    try {
+      const clientBefore = opts.getActiveClient?.() ?? client;
+      switch (e.type) {
+        case "navigate":
+          await replayNavigate(e, ctx, prev);
+          break;
+        case "click":
+          await replayClick(e, ctx);
+          break;
+        case "input":
+          await replayInput(e, ctx);
+          break;
+        case "key":
+          await replayKey(e, ctx);
+          break;
+        case "assert":
+          await replayAssert(e, ctx);
+          break;
+      }
+      if (e.type === "click" && isAnchorClick(e)) {
+        const next = events[i + 1];
+        const expectedNextUrl = next && "url" in next ? next.url : void 0;
+        const nextSelectors = next && "selectors" in next ? next.selectors : void 0;
+        await waitForAnchorClickConsequence(
+          opts.getActiveClient,
+          client,
+          ctxFor,
+          clientBefore,
+          expectedNextUrl,
+          nextSelectors
+        );
+      }
+      const settle = e.type === "click" || e.type === "key" ? 60 : 20;
+      await new Promise((r) => setTimeout(r, settle));
+      prev = e;
+      opts.onReplayProgress?.(i + 1, total, e, "ok");
+    } catch (err) {
+      const msg = err.message;
+      opts.onReplayProgress?.(i + 1, total, e, "fail", msg);
+      if (opts.shouldPauseOnFail) {
+        const action = await opts.shouldPauseOnFail(i, total, e, msg);
+        if (action === "retry" || action === "skip") {
+          events = await opts.session.readEvents();
+          total = events.length;
+          if (action === "retry") {
+            const newIdx2 = events.findIndex((ev) => ev.id === e.id);
+            i = (newIdx2 === -1 ? i : newIdx2) - 1;
+            continue;
+          }
+          const newIdx = events.findIndex((ev) => ev.id === e.id);
+          if (newIdx !== -1) i = newIdx;
+          prev = events[i] ?? e;
+          continue;
+        }
+      }
+      return { replayed: i, failed: { step: i + 1, reason: msg } };
+    }
+  }
+  mode = "recording";
+  await broadcastMode("recording");
+  await broadcastStepCount2();
+  opts.onRecordingStart?.();
+  return { replayed: total };
+}
+init_page_context();
+var __dirname4 = import_node_path.default.dirname((0, import_node_url.fileURLToPath)(__trq_meta_url__));
+var BOOTSTRAP_PATH3 = import_node_path.default.join(__dirname4, "bootstrap.js");
+async function loadBootstrap() {
+  return import_node_fs.promises.readFile(BOOTSTRAP_PATH3, "utf8");
+}
+async function loadReplayHelpers() {
+  return import_node_fs.promises.readFile(import_node_path.default.join(__dirname4, "replay-helpers.js"), "utf8");
+}
+
+// src/main/cdp-adapter.ts
+function createCDPClient(webContents) {
+  const dbg = webContents.debugger;
+  if (!dbg.isAttached()) {
+    dbg.attach("1.3");
+  }
+  const listeners = /* @__PURE__ */ new Map();
+  const onMessage = (_event, method, params) => {
+    if (process.env.TRQ_DEBUG_CDP) {
+      console.log(`[cdp-adapter] \u2190 ${method}`);
+    }
+    const set = listeners.get(method);
+    if (!set) return;
+    for (const fn of set) {
+      try {
+        fn(params);
+      } catch (err) {
+        console.error(`[cdp-adapter] listener for ${method} threw:`, err);
+      }
+    }
+  };
+  const onDetach = (_event, reason) => {
+    const set = listeners.get("disconnected");
+    if (!set) return;
+    for (const fn of set) {
+      try {
+        fn({ reason });
+      } catch (err) {
+        console.error("[cdp-adapter] disconnected listener threw:", err);
+      }
+    }
+  };
+  dbg.on("message", onMessage);
+  dbg.on("detach", onDetach);
+  return {
+    send: (method, params) => dbg.sendCommand(method, params ?? {}),
+    on: (event, listener) => {
+      let set = listeners.get(event);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        listeners.set(event, set);
+      }
+      set.add(listener);
+    },
+    off: (event, listener) => {
+      listeners.get(event)?.delete(listener);
+    },
+    detach: () => {
+      dbg.removeListener("message", onMessage);
+      dbg.removeListener("detach", onDetach);
+      listeners.clear();
+      if (dbg.isAttached()) dbg.detach();
+    },
+    get attached() {
+      return dbg.isAttached();
+    }
+  };
+}
+
+// src/main/ipc.ts
+function emit(win, channel, payload) {
+  if (win.isDestroyed()) return;
+  win.webContents.send(channel, payload);
+}
+function broadcastStatus(state) {
+  emit(state.win, "session:status", {
+    mode: state.mode,
+    session: state.session?.manifest.name ?? null,
+    stepCount: state.session?.manifest.stepCount ?? 0
+  });
+}
+async function readEvents(dir) {
+  const raw = await import_node_fs6.promises.readFile(import_node_path6.default.join(dir, "events.jsonl"), "utf8").catch(() => "");
+  if (!raw.trim()) return [];
+  return raw.trim().split("\n").map((line) => JSON.parse(line));
+}
+async function loadBlankSafe(view) {
+  try {
+    await view.webContents.loadURL("about:blank");
+  } catch (err) {
+    if (err.errno !== -3) throw err;
+  }
+}
+var nextTabId = 1;
+function tabSummaries(state) {
+  return state.tabs.map((t) => ({
+    id: t.id,
+    url: t.url,
+    title: t.title,
+    active: t.id === state.activeTabId
+  }));
+}
+function broadcastTabs(state) {
+  emit(state.win, "tabs:state", { tabs: tabSummaries(state) });
+}
+function wireUpTab(state, tab) {
+  const wc = tab.view.webContents;
+  wc.on("did-navigate", (_e, url) => {
+    tab.url = url;
+    broadcastTabs(state);
+    if (tab.id === state.activeTabId) state.invalidateLayout();
+  });
+  wc.on("did-navigate-in-page", (_e, url) => {
+    tab.url = url;
+    broadcastTabs(state);
+  });
+  wc.on("page-title-updated", (_e, title) => {
+    tab.title = title;
+    broadcastTabs(state);
+  });
+  wc.on("did-finish-load", () => {
+    if (tab.id === state.activeTabId) state.invalidateLayout();
+    if (state.mode === "recording" && tab.client && state.recordingContext) {
+      const bootstrap = state.recordingContext.bootstrap;
+      const client = tab.client;
+      void (async () => {
+        try {
+          await client.send("Runtime.evaluate", {
+            expression: `(() => {
+              if (document.getElementById('__trq_overlay')) return;
+              window.__trqInstalled = false;
+            })()`
+          });
+          await client.send("Runtime.evaluate", { expression: bootstrap });
+        } catch {
+        }
+      })();
+    }
+  });
+  wc.on("did-stop-loading", () => {
+    if (tab.id === state.activeTabId) state.invalidateLayout();
+  });
+  wc.on("console-message", (_e, level, message) => {
+    if (tab.id !== state.activeTabId) return;
+    const tag = ["log", "warn", "error"][level] ?? "log";
+    console.log(`[page:${tag}] ${message}`);
+  });
+  wc.setWindowOpenHandler(({ url }) => {
+    void createTab(state, url);
+    return { action: "deny" };
+  });
+}
+async function createTab(state, url) {
+  const view = new import_electron.BrowserView({
+    webPreferences: { contextIsolation: true, nodeIntegration: false }
+  });
+  const tab = {
+    id: `tab_${nextTabId++}`,
+    view,
+    url,
+    title: "",
+    client: null
+  };
+  state.tabs.push(tab);
+  wireUpTab(state, tab);
+  if (state.mode === "recording" && state.recordingContext) {
+    try {
+      await loadBlankSafe(view);
+      const client = createCDPClient(view.webContents);
+      tab.client = client;
+      await setupRecordingOnClient(client, state.recordingContext);
+    } catch (err) {
+      console.warn("[createTab] failed to attach recording:", err.message);
+    }
+  }
+  if (state.inspectActive && state.inspectAssets) {
+    try {
+      await loadBlankSafe(view);
+      const client = createCDPClient(view.webContents);
+      tab.client = client;
+      const { bootstrap, helpers, config } = state.inspectAssets;
+      await setupInspectOnClient(state, client, bootstrap, helpers, config);
+    } catch (err) {
+      console.warn("[createTab] failed to attach inspect:", err.message);
+    }
+  }
+  if (state.mode === "replaying" && state.session) {
+    try {
+      await loadBlankSafe(view);
+      const client = createCDPClient(view.webContents);
+      tab.client = client;
+      const config = await state.session.readConfig();
+      await setupReplayClient(client, { config });
+    } catch (err) {
+      console.warn("[createTab] failed to attach replay client:", err.message);
+    }
+  }
+  await switchToTab(state, tab.id);
+  view.webContents.loadURL(url).catch(() => {
+  });
+  return tab;
+}
+async function switchToTab(state, id) {
+  const next = state.tabs.find((t) => t.id === id);
+  if (!next) return;
+  for (const t of state.tabs) {
+    try {
+      state.win.removeBrowserView(t.view);
+    } catch {
+    }
+  }
+  state.win.addBrowserView(next.view);
+  state.activeTabId = id;
+  state.view = next.view;
+  state.recordingClient = next.client;
+  state.invalidateLayout();
+  broadcastTabs(state);
+}
+async function closeAuxiliaryTabs(state) {
+  const primary = state.tabs[0];
+  if (!primary) return;
+  if (state.activeTabId !== primary.id) {
+    await switchToTab(state, primary.id);
+  }
+  for (const t of state.tabs.slice(1)) {
+    try {
+      t.client?.detach();
+    } catch {
+    }
+    try {
+      state.win.removeBrowserView(t.view);
+    } catch {
+    }
+    try {
+      t.view.webContents.destroy?.();
+    } catch {
+    }
+  }
+  state.tabs = [primary];
+  broadcastTabs(state);
+}
+async function closeTab(state, id) {
+  const idx = state.tabs.findIndex((t) => t.id === id);
+  if (idx === -1) return;
+  const tab = state.tabs[idx];
+  if (state.tabs.length === 1) {
+    try {
+      tab.client?.detach();
+    } catch {
+    }
+    tab.client = null;
+    tab.url = "about:blank";
+    tab.title = "";
+    await loadBlankSafe(tab.view);
+    broadcastTabs(state);
+    return;
+  }
+  try {
+    tab.client?.detach();
+  } catch {
+  }
+  try {
+    state.win.removeBrowserView(tab.view);
+  } catch {
+  }
+  try {
+    tab.view.webContents.destroy?.();
+  } catch {
+  }
+  state.tabs.splice(idx, 1);
+  if (state.activeTabId === id) {
+    const neighbor = state.tabs[Math.max(0, idx - 1)] ?? state.tabs[state.tabs.length - 1];
+    await switchToTab(state, neighbor.id);
+  } else {
+    broadcastTabs(state);
+  }
+}
+function detachDebugger(state) {
+  try {
+    state.recordingClient?.detach();
+  } catch {
+  }
+  state.recordingClient = null;
+  try {
+    const dbg = state.view.webContents.debugger;
+    if (dbg.isAttached()) dbg.detach();
+  } catch {
+  }
+}
+async function clearBrowserState(state) {
+  try {
+    await state.view.webContents.session.clearStorageData({
+      storages: [
+        "cookies",
+        "localstorage",
+        "sessionstorage",
+        "indexdb",
+        "cachestorage",
+        "serviceworkers",
+        "shadercache",
+        "websql"
+      ]
+    });
+    await state.view.webContents.session.clearCache();
+  } catch (err) {
+    console.warn("[clearBrowserState] failed:", err.message);
+  }
+}
+async function startRecording(state, name) {
+  if (state.inspectActive) {
+    await stopInspect(state);
+  }
+  if (state.mode !== "idle") {
+    throw new Error(`Cannot start recording while ${state.mode}`);
+  }
+  await closeAuxiliaryTabs(state);
+  await clearBrowserState(state);
+  const session = await Session.load(state.sessionsDir, name);
+  const config = await session.readConfig();
+  state.lockedViewport = config.viewport ? { width: config.viewport.width, height: config.viewport.height } : null;
+  const bootstrap = await loadBootstrap();
+  detachDebugger(state);
+  await loadBlankSafe(state.view);
+  const client = createCDPClient(state.view.webContents);
+  const ctx = {
+    session,
+    bootstrap,
+    clients: /* @__PURE__ */ new Set(),
+    onEvent: (e) => {
+      try {
+        emit(state.win, "session:event", e);
+        broadcastStatus(state);
+      } catch {
+      }
+    },
+    config
+  };
+  await setupRecordingOnClient(client, ctx);
+  state.session = session;
+  state.recordingClient = client;
+  state.recordingContext = ctx;
+  const activeTab = state.tabs.find((t) => t.id === state.activeTabId);
+  if (activeTab) activeTab.client = client;
+  state.mode = "recording";
+  broadcastStatus(state);
+  emit(state.win, "sessions:changed", void 0);
+  const startUrl = session.manifest.initialUrl;
+  if (startUrl && startUrl !== "about:blank") {
+    state.view.webContents.loadURL(startUrl).catch(() => {
+    });
+  }
+}
+async function setupInspectOnClient(state, client, bootstrap, helpers, config) {
+  await client.send("Runtime.enable");
+  await client.send("Page.enable");
+  if (config) {
+    await applyConfig(client, config);
+  }
+  await client.send("Runtime.addBinding", { name: "__trqEmit" }).catch(() => {
+  });
+  await client.send("Page.addScriptToEvaluateOnNewDocument", {
+    source: 'window.__trqMode = "idle"; window.__trqInspect = true;'
+  });
+  await client.send("Page.addScriptToEvaluateOnNewDocument", { source: helpers });
+  await client.send("Page.addScriptToEvaluateOnNewDocument", { source: bootstrap });
+  client.on("Runtime.bindingCalled", (raw) => {
+    const e = raw;
+    if (e.name !== "__trqEmit") return;
+    try {
+      const payload = JSON.parse(e.payload);
+      if (payload.__trq === "hover" && payload.selectors && payload.target) {
+        emit(state.win, "inspect:hover", {
+          selectors: payload.selectors,
+          target: payload.target
+        });
+      }
+    } catch {
+    }
+  });
+  await client.send("Runtime.evaluate", {
+    expression: 'window.__trqMode = "idle"; window.__trqInspect = true;'
+  }).catch(() => {
+  });
+  await client.send("Runtime.evaluate", { expression: helpers }).catch(() => {
+  });
+  await client.send("Runtime.evaluate", { expression: bootstrap }).catch(() => {
+  });
+}
+async function startInspect(state, sessionName) {
+  if (state.inspectActive) return;
+  if (state.mode !== "idle") {
+    throw new Error(`Cannot inspect while ${state.mode}`);
+  }
+  if (!sessionName) {
+    throw new Error("Inspect requires a selected session");
+  }
+  let session;
+  try {
+    session = await Session.load(state.sessionsDir, sessionName);
+  } catch {
+    throw new Error(`Session not found: ${sessionName}`);
+  }
+  const config = await session.readConfig();
+  state.lockedViewport = config.viewport ? { width: config.viewport.width, height: config.viewport.height } : null;
+  await closeAuxiliaryTabs(state);
+  detachDebugger(state);
+  await clearBrowserState(state);
+  await loadBlankSafe(state.view);
+  const bootstrap = await loadBootstrap();
+  const helpers = await loadReplayHelpers();
+  state.inspectAssets = { bootstrap, helpers, config };
+  const client = createCDPClient(state.view.webContents);
+  state.recordingClient = client;
+  const activeTab = state.tabs.find((t) => t.id === state.activeTabId);
+  if (activeTab) activeTab.client = client;
+  await setupInspectOnClient(state, client, bootstrap, helpers, config);
+  state.inspectActive = true;
+  state.cancelReplay = false;
+  state.runToEnd = false;
+  state.replayCursor = null;
+  state.stepResolver = null;
+  state.mode = "paused";
+  emit(state.win, "inspect:state", { active: true });
+  broadcastStatus(state);
+  state.inspectorOpen = true;
+  state.invalidateLayout();
+  state.inspectLoopPromise = (async () => {
+    try {
+      await runReplayOnClient({
+        client,
+        session,
+        startUrl: session.manifest.initialUrl ?? void 0,
+        shouldCancel: () => state.cancelReplay,
+        // Follow into tabs spawned during the inspect step-through. createTab's
+        // inspect branch above attaches a CDP client + injects helpers, then
+        // switchToTab updates state.recordingClient — this getter picks it up.
+        getActiveClient: () => state.recordingClient ?? client,
+        shouldWait: async (idx, _total, e) => {
+          state.replayCursor = {
+            idx,
+            total: _total,
+            eventId: e.id,
+            eventType: e.type
+          };
+          emit(state.win, "replay:cursor", {
+            idx,
+            total: _total,
+            eventId: e.id,
+            eventType: e.type
+          });
+          if (state.runToEnd) return;
+          await new Promise((resolve) => {
+            state.stepResolver = resolve;
+          });
+          state.stepResolver = null;
+        },
+        onProgress: (idx, total, e, status, detail) => {
+          emit(state.win, "replay:progress", {
+            current: idx,
+            total,
+            eventType: e.type,
+            status,
+            detail
+          });
+        }
+      });
+    } catch (err) {
+      console.error("[inspect-debug] loop error:", err.message);
+    } finally {
+      const stillOurs = state.recordingClient === client;
+      state.replayCursor = null;
+      state.stepResolver = null;
+      state.runToEnd = false;
+      emit(state.win, "replay:cursor", { idx: 0, total: 0, eventId: null, eventType: null });
+      if (stillOurs) {
+        try {
+          await client.send("Runtime.evaluate", {
+            expression: `(() => {
+              window.__trqInspect = false;
+              window.__trqMode = 'idle';
+              for (const id of ['__trq_overlay', '__trq_highlight', '__trq_assert_menu']) {
+                document.getElementById(id)?.remove();
+              }
+              window.__trqInstalled = false;
+            })()`
+          });
+        } catch {
+        }
+        detachDebugger(state);
+        exitInspectLayout(state);
+        state.inspectActive = false;
+        state.cancelReplay = false;
+        state.lockedViewport = null;
+        state.mode = "idle";
+        emit(state.win, "inspect:state", { active: false });
+        broadcastStatus(state);
+      }
+    }
+  })();
+}
+async function stopInspect(state) {
+  if (!state.inspectActive) return;
+  state.cancelReplay = true;
+  state.stepResolver?.();
+  state.stepResolver = null;
+  if (state.inspectLoopPromise) {
+    await state.inspectLoopPromise;
+    state.inspectLoopPromise = null;
+  }
+}
+function stepInspect(state) {
+  if (state.mode !== "paused") return;
+  const r = state.stepResolver;
+  if (!r) return;
+  state.stepResolver = null;
+  r();
+}
+function continueInspect(state) {
+  if (state.mode !== "paused") return;
+  state.runToEnd = true;
+  const r = state.stepResolver;
+  if (r) {
+    state.stepResolver = null;
+    r();
+  }
+}
+function exitInspectLayout(state) {
+  state.inspectorOpen = false;
+  state.inspectorCollapsed = false;
+  state.invalidateLayout();
+}
+async function highlightSelector(state, selectors) {
+  if (!state.inspectActive || !state.recordingClient) return false;
+  try {
+    const r = await state.recordingClient.send("Runtime.evaluate", {
+      expression: `window.__trqHighlight && window.__trqHighlight(${JSON.stringify(selectors)})`,
+      returnByValue: true
+    });
+    return r.result?.value ?? false;
+  } catch {
+    return false;
+  }
+}
+async function stopRecording(state) {
+  if (state.mode !== "recording") return;
+  for (const t of state.tabs) {
+    try {
+      t.client?.detach();
+    } catch {
+    }
+    t.client = null;
+  }
+  detachDebugger(state);
+  state.recordingContext = null;
+  state.lockedViewport = null;
+  state.mode = "idle";
+  broadcastStatus(state);
+  emit(state.win, "sessions:changed", void 0);
+}
+function pauseAtFailure(state, idx, total, eventId, reason) {
+  state.pauseFailure = { step: idx + 1, total, eventId, reason };
+  state.invalidateLayout();
+  emit(state.win, "pause:failure", state.pauseFailure);
+  console.log(`[pause] step ${idx + 1}/${total}: ${reason}`);
+  return new Promise((resolve) => {
+    state.pauseResolver = (action) => {
+      state.pauseFailure = null;
+      state.pauseResolver = null;
+      state.invalidateLayout();
+      emit(state.win, "pause:failure", null);
+      resolve(action);
+    };
+  });
+}
+async function play(state, name) {
+  if (state.inspectActive) {
+    await stopInspect(state);
+  }
+  if (state.mode !== "idle") throw new Error(`Cannot play while ${state.mode}`);
+  await closeAuxiliaryTabs(state);
+  const session = await Session.load(state.sessionsDir, name);
+  const config = await session.readConfig();
+  state.lockedViewport = config.viewport ? { width: config.viewport.width, height: config.viewport.height } : null;
+  state.session = session;
+  state.mode = "replaying";
+  state.cancelReplay = false;
+  broadcastStatus(state);
+  detachDebugger(state);
+  await clearBrowserState(state);
+  await loadBlankSafe(state.view);
+  const client = createCDPClient(state.view.webContents);
+  state.recordingClient = client;
+  const activeTab = state.tabs.find((t) => t.id === state.activeTabId);
+  if (activeTab) activeTab.client = client;
+  try {
+    const result = await runReplayOnClient({
+      client,
+      session,
+      startUrl: session.manifest.initialUrl ?? void 0,
+      shouldCancel: () => state.cancelReplay,
+      // Follow into new tabs as the recording did. createTab during replay
+      // mode attaches a CDP client + injects helpers, and switchToTab
+      // updates state.recordingClient — so this getter naturally picks up
+      // the active tab's client between events.
+      getActiveClient: () => state.recordingClient ?? client,
+      shouldPauseOnFail: (idx, total, e, reason) => pauseAtFailure(state, idx, total, e.id, reason),
+      onProgress: (idx, total, e, status, detail) => {
+        emit(state.win, "replay:progress", {
+          current: idx,
+          total,
+          eventType: e.type,
+          status,
+          detail
+        });
+        if (status === "start") {
+          emit(state.win, "log:line", { level: "info", text: `\u25B8 ${idx}/${total} ${e.type}` });
+        } else if (status === "fail") {
+          emit(state.win, "log:line", { level: "error", text: `\u2717 step ${idx}: ${detail ?? "failed"}` });
+        }
+      }
+    });
+    const summary = result.failed ? `[replay] \u2717 step ${result.failed.step}/${result.total}: ${result.failed.reason}` : `[replay] \u2713 ${result.completed}/${result.total}`;
+    console.log(summary);
+    emit(state.win, "log:line", {
+      level: result.failed ? "error" : "info",
+      text: summary
+    });
+  } finally {
+    state.mode = "idle";
+    broadcastStatus(state);
+  }
+}
+async function resume(state, name) {
+  if (state.inspectActive) {
+    await stopInspect(state);
+  }
+  if (state.mode !== "idle") throw new Error(`Cannot resume while ${state.mode}`);
+  await closeAuxiliaryTabs(state);
+  const session = await Session.load(state.sessionsDir, name);
+  const config = await session.readConfig();
+  const bootstrap = await loadBootstrap();
+  state.lockedViewport = config.viewport ? { width: config.viewport.width, height: config.viewport.height } : null;
+  state.session = session;
+  state.mode = "replaying";
+  state.cancelReplay = false;
+  broadcastStatus(state);
+  detachDebugger(state);
+  await clearBrowserState(state);
+  await loadBlankSafe(state.view);
+  const client = createCDPClient(state.view.webContents);
+  state.recordingClient = client;
+  const activeTab = state.tabs.find((t) => t.id === state.activeTabId);
+  if (activeTab) activeTab.client = client;
+  try {
+    const result = await runResumeOnClient({
+      client,
+      session,
+      startUrl: session.manifest.initialUrl ?? void 0,
+      shouldCancel: () => state.cancelReplay,
+      getActiveClient: () => state.recordingClient ?? client,
+      shouldPauseOnFail: (idx, total, e, reason) => pauseAtFailure(state, idx, total, e.id, reason),
+      onReplayProgress: (idx, total, e, status, detail) => {
+        emit(state.win, "replay:progress", {
+          current: idx,
+          total,
+          eventType: e.type,
+          status,
+          detail
+        });
+        if (status === "start") {
+          emit(state.win, "log:line", { level: "info", text: `\u25B8 ${idx}/${total} ${e.type}` });
+        } else if (status === "fail") {
+          emit(state.win, "log:line", { level: "error", text: `\u2717 step ${idx}: ${detail ?? "failed"}` });
+        }
+      },
+      onRecordingStart: () => {
+        emit(state.win, "log:line", {
+          level: "info",
+          text: "\u25B6 replay complete \u2014 now recording. close the window or click Stop to finish."
+        });
+        state.mode = "recording";
+        broadcastStatus(state);
+        const ctx = {
+          session: state.session,
+          bootstrap,
+          clients: /* @__PURE__ */ new Set([client]),
+          onEvent: (e) => {
+            emit(state.win, "session:event", e);
+            broadcastStatus(state);
+          },
+          config
+        };
+        state.recordingContext = ctx;
+        void Promise.all(
+          state.tabs.slice(1).filter((t) => !!t.client).map((t) => setupRecordingOnClient(t.client, ctx))
+        ).catch((err) => {
+          console.warn("[resume] aux-tab recording setup failed:", err.message);
+        });
+      },
+      onRecordEvent: (e) => {
+        emit(state.win, "session:event", e);
+        broadcastStatus(state);
+      }
+    });
+    if (result.failed) {
+      const summary = `[resume] \u2717 step ${result.failed.step}/${result.total}: ${result.failed.reason}`;
+      console.log(summary);
+      emit(state.win, "log:line", { level: "error", text: summary });
+      state.mode = "idle";
+      broadcastStatus(state);
+    } else {
+      console.log(`[resume] \u2713 replay phase complete (${result.completed}/${result.total}) \u2014 recording`);
+    }
+  } catch (err) {
+    state.mode = "idle";
+    broadcastStatus(state);
+    throw err;
+  }
+}
+function handlers(state) {
+  return {
+    "sessions:list": async () => Session.list(state.sessionsDir),
+    "sessions:create": async (s, { name, startUrl }) => {
+      const session = await Session.create(s.sessionsDir, name, startUrl);
+      await clearBrowserState(s);
+      emit(s.win, "sessions:changed", void 0);
+      return session.manifest;
+    },
+    "sessions:delete": async (s, { name }) => {
+      if (s.session?.manifest.name === name && s.mode === "recording") {
+        await stopRecording(s);
+      }
+      await import_node_fs6.promises.rm(import_node_path6.default.join(s.sessionsDir, name), { recursive: true, force: true });
+      emit(s.win, "sessions:changed", void 0);
+    },
+    "sessions:events": async (s, { name }) => readEvents(import_node_path6.default.join(s.sessionsDir, name)),
+    "recording:start": async (s, { name }) => startRecording(s, name),
+    "recording:stop": async (s) => stopRecording(s),
+    "replay:play": async (s, { name }) => play(s, name),
+    "replay:resume": async (s, { name }) => resume(s, name),
+    "replay:stop": async (s) => {
+      s.cancelReplay = true;
+    },
+    // Pause-at-failure resolvers. Each unblocks the loop's awaited promise
+    // with the chosen action. No-op if the loop isn't currently paused.
+    "pause:retry": async (s) => {
+      s.pauseResolver?.("retry");
+    },
+    "pause:skip": async (s) => {
+      s.pauseResolver?.("skip");
+    },
+    "pause:stop": async (s) => {
+      s.pauseResolver?.("stop");
+    },
+    "pause:editFailed": async (s) => {
+      if (!s.pauseFailure || !s.session) return null;
+      return { sessionName: s.session.manifest.name, eventId: s.pauseFailure.eventId };
+    },
+    // Run the page-side scorer against the failed event's recorded target.
+    // Only valid while paused — the live page is in the state it was at the
+    // moment of failure, so DOM candidates are meaningful.
+    "events:suggestSelectors": async (s, { eventId }) => {
+      if (!s.pauseFailure || !s.session || !s.recordingClient) return [];
+      if (eventId !== s.pauseFailure.eventId) return [];
+      const events = await readEvents(import_node_path6.default.join(s.sessionsDir, s.session.manifest.name));
+      const ev = events.find((e) => e.id === eventId);
+      const target = ev?.target;
+      if (!target) return [];
+      try {
+        const r = await s.recordingClient.send("Runtime.evaluate", {
+          expression: `JSON.stringify(window.__trqSuggest && window.__trqSuggest(${JSON.stringify(target)}, 3) || [])`,
+          returnByValue: true
+        });
+        const raw = r.result?.value ?? "[]";
+        return JSON.parse(raw);
+      } catch {
+        return [];
+      }
+    },
+    // Activate the page-side click-to-capture mode. The picked envelope
+    // comes back through the __trqEmit binding; we forward it to the
+    // renderer as 'pick:result'. Caller controls UI (drawer minimize, etc).
+    "events:pickFromPage": async (s) => {
+      if (!s.pauseFailure || !s.recordingClient) return;
+      const client = s.recordingClient;
+      await client.send("Runtime.addBinding", { name: "__trqEmit" }).catch(() => {
+      });
+      const handler = (raw) => {
+        const e = raw;
+        if (e.name !== "__trqEmit") return;
+        try {
+          const p = JSON.parse(e.payload);
+          if (p.__trq === "pick") {
+            emit(s.win, "pick:result", p);
+            client.off?.("Runtime.bindingCalled", handler);
+          } else if (p.__trq === "pick-cancel") {
+            emit(s.win, "pick:result", null);
+            client.off?.("Runtime.bindingCalled", handler);
+          }
+        } catch {
+        }
+      };
+      client.on("Runtime.bindingCalled", handler);
+      s.win.setBrowserView(s.view);
+      s.win.emit("resize");
+      await client.send("Runtime.evaluate", {
+        expression: "window.__trqStartPick && window.__trqStartPick()"
+      }).catch(() => {
+      });
+    },
+    "events:cancelPick": async (s) => {
+      if (!s.recordingClient) return;
+      await s.recordingClient.send("Runtime.evaluate", {
+        expression: "window.__trqStopPick && window.__trqStopPick()"
+      }).catch(() => {
+      });
+    },
+    "view:navigate": async (s, { url }) => {
+      await s.view.webContents.loadURL(url);
+    },
+    "view:setVisible": async (s, { visible }) => {
+      if (visible) {
+        s.win.setBrowserView(s.view);
+        s.win.emit("resize");
+      } else {
+        s.win.setBrowserView(null);
+      }
+    },
+    "view:layout": async (s, { sidebarW, eventsH }) => {
+      s.layout.sidebarW = sidebarW;
+      s.layout.eventsH = eventsH;
+      s.invalidateLayout();
+    },
+    "config:get": async (s, { name }) => {
+      const session = await Session.load(s.sessionsDir, name);
+      return session.readConfig();
+    },
+    "config:set": async (s, { name, config }) => {
+      const session = await Session.load(s.sessionsDir, name);
+      await session.writeConfig(config);
+    },
+    "inspect:start": async (s, args) => startInspect(s, args?.name),
+    "inspect:stop": async (s) => stopInspect(s),
+    "inspect:highlight": async (s, { selectors }) => highlightSelector(s, selectors),
+    "inspect:step": async (s) => stepInspect(s),
+    "inspect:continue": async (s) => continueInspect(s),
+    "inspect:toggleCollapsed": async (s) => {
+      s.inspectorCollapsed = !s.inspectorCollapsed;
+      s.invalidateLayout();
+      emit(s.win, "inspect:state", { active: s.inspectActive, collapsed: s.inspectorCollapsed });
+      return { collapsed: s.inspectorCollapsed };
+    },
+    "tabs:list": async (s) => tabSummaries(s),
+    "tabs:switch": async (s, { id }) => switchToTab(s, id),
+    "tabs:close": async (s, { id }) => closeTab(s, id),
+    "events:replace": async (s, { name, id, patch }) => {
+      if (s.mode === "recording" && s.session?.manifest.name === name) {
+        throw new Error("Cannot edit events while recording");
+      }
+      const session = await Session.load(s.sessionsDir, name);
+      const stamped = await session.replaceEvent(id, patch);
+      emit(s.win, "sessions:changed", void 0);
+      return stamped;
+    },
+    "events:delete": async (s, { name, id }) => {
+      if (s.mode === "recording" && s.session?.manifest.name === name) {
+        throw new Error("Cannot delete events while recording");
+      }
+      const session = await Session.load(s.sessionsDir, name);
+      await session.removeEvent(id);
+      emit(s.win, "sessions:changed", void 0);
+    },
+    "events:insertAt": async (s, { name, idx, event }) => {
+      if (s.mode === "recording" && s.session?.manifest.name === name) {
+        throw new Error("Cannot insert events while recording");
+      }
+      const session = await Session.load(s.sessionsDir, name);
+      const stamped = await session.insertEventAt(idx, event);
+      emit(s.win, "sessions:changed", void 0);
+      return stamped;
+    },
+    "sessions:branch": async (s, { name, newName, throughStep }) => {
+      const session = await Session.load(s.sessionsDir, name);
+      const branched = await session.branch(s.sessionsDir, newName, throughStep);
+      emit(s.win, "sessions:changed", void 0);
+      return branched.manifest;
+    },
+    "ui:eventContextMenu": async (s, { sessionName, eventId, eventIdx, total }) => {
+      const send = (action) => {
+        emit(s.win, "ui:contextMenuChoice", { sessionName, eventId, eventIdx, action });
+      };
+      const menu = import_electron.Menu.buildFromTemplate([
+        { label: "Edit\u2026", click: () => send("edit") },
+        { label: "Delete", click: () => send("delete") },
+        { type: "separator" },
+        { label: "Insert event above\u2026", click: () => send("insertAbove") },
+        { label: "Insert event below\u2026", click: () => send("insertBelow") },
+        { type: "separator" },
+        {
+          label: `Branch from here (steps 1\u2026${eventIdx + 1} of ${total})\u2026`,
+          click: () => send("branch")
+        }
+      ]);
+      menu.popup({ window: s.win });
+    }
+  };
+}
+function registerIpc(state) {
+  const h = handlers(state);
+  for (const channel of Object.keys(h)) {
+    import_electron.ipcMain.handle(channel, (_evt, args) => h[channel](state, args));
+  }
+  broadcastStatus(state);
+}
+
+// src/main/main.ts
+process.env.ELECTRON_DISABLE_SECURITY_WARNINGS = "true";
+var SESSIONS_DIR = process.env.TRQ_SESSIONS_DIR ? import_node_path7.default.resolve(process.env.TRQ_SESSIONS_DIR) : import_node_path7.default.join(process.cwd(), "sessions");
+var PRELOAD = import_node_path7.default.join(__dirname, "../preload/preload.cjs");
+var HEADER_H = 32 + 32;
+var PAUSE_BANNER_H = 36;
+var STATUS_BAR_H = 22;
+var PAGE_PADDING = 8;
+var SIDEBAR_W_DEFAULT = 48 + 240;
+var EVENTS_H_DEFAULT = 180;
+var INSPECTOR_W = 280;
+var INSPECTOR_W_COLLAPSED = 28;
+async function createWindow() {
+  const win = new import_electron2.BrowserWindow({
+    width: 1280,
+    height: 820,
+    backgroundColor: "#0a0a0a",
+    webPreferences: {
+      preload: PRELOAD,
+      contextIsolation: true,
+      nodeIntegration: false
+    }
+  });
+  const view = new import_electron2.BrowserView({
+    webPreferences: { contextIsolation: true, nodeIntegration: false }
+  });
+  win.setBrowserView(view);
+  const primaryTab = {
+    id: "tab_0",
+    view,
+    url: "about:blank",
+    title: "",
+    client: null
+  };
+  const state = {
+    sessionsDir: SESSIONS_DIR,
+    win,
+    layout: { sidebarW: SIDEBAR_W_DEFAULT, eventsH: EVENTS_H_DEFAULT },
+    view,
+    tabs: [primaryTab],
+    activeTabId: primaryTab.id,
+    mode: "idle",
+    session: null,
+    recordingClient: null,
+    recordingContext: null,
+    cancelReplay: false,
+    inspectActive: false,
+    pauseFailure: null,
+    pauseResolver: null,
+    inspectorOpen: false,
+    inspectorCollapsed: false,
+    inspectAssets: null,
+    stepResolver: null,
+    runToEnd: false,
+    replayCursor: null,
+    inspectLoopPromise: null,
+    lockedViewport: null,
+    // Replaced below after sizeView is defined.
+    invalidateLayout: () => {
+    }
+  };
+  let inSizeView = false;
+  const sizeView = () => {
+    if (inSizeView) return;
+    inSizeView = true;
+    try {
+      const active = state.view;
+      const [w, h] = win.getContentSize();
+      const rightReserve = state.inspectorOpen ? state.inspectorCollapsed ? INSPECTOR_W_COLLAPSED : INSPECTOR_W : 0;
+      const left = state.layout.sidebarW;
+      const eventsH = state.layout.eventsH;
+      const bannerH = state.pauseFailure ? PAUSE_BANNER_H : 0;
+      const bounds = {
+        x: left + PAGE_PADDING,
+        y: HEADER_H + bannerH + PAGE_PADDING,
+        width: Math.max(0, w - left - rightReserve - 2 * PAGE_PADDING),
+        height: Math.max(0, h - HEADER_H - bannerH - eventsH - STATUS_BAR_H - 2 * PAGE_PADDING)
+      };
+      active.setBounds(bounds);
+      if (process.env.TRQ_DEBUG_LAYOUT) {
+        console.log(`[layout] window=${w}x${h} inspectorOpen=${state.inspectorOpen} view=${JSON.stringify(bounds)}`);
+      }
+      if (process.platform === "darwin") {
+        win.setContentSize(w, h + 1);
+        win.setContentSize(w, h);
+      }
+      if (state.recordingClient && bounds.width > 0 && bounds.height > 0) {
+        const lock = state.lockedViewport;
+        const params = lock ? {
+          width: lock.width,
+          height: lock.height,
+          // Use min(ratio_w, ratio_h) so neither dimension overflows.
+          // Capped at 1 so a small viewport doesn't get upscaled.
+          scale: Math.min(1, bounds.width / lock.width, bounds.height / lock.height),
+          deviceScaleFactor: 1,
+          mobile: false,
+          dontSetVisibleSize: true
+        } : {
+          width: bounds.width,
+          height: bounds.height,
+          deviceScaleFactor: 1,
+          mobile: false,
+          dontSetVisibleSize: true
+        };
+        if (process.env.TRQ_DEBUG_LAYOUT) {
+          console.log(`[layout] setDeviceMetricsOverride ${JSON.stringify(params)}`);
+        }
+        state.recordingClient.send("Emulation.setDeviceMetricsOverride", params).catch((err) => {
+          if (process.env.TRQ_DEBUG_LAYOUT) {
+            console.log(`[layout]   FAILED: ${err.message}`);
+          }
+        });
+      } else if (process.env.TRQ_DEBUG_LAYOUT) {
+        console.log(`[layout]   skipped: client=${!!state.recordingClient}`);
+      }
+    } finally {
+      inSizeView = false;
+    }
+  };
+  state.invalidateLayout = sizeView;
+  sizeView();
+  win.setMaxListeners(20);
+  win.on("resize", sizeView);
+  wireUpTab(state, primaryTab);
+  registerIpc(state);
+  win.webContents.on("console-message", (_e, level, message, line, source) => {
+    const tag = ["log", "warn", "error"][level] ?? "log";
+    console.log(`[renderer:${tag}] ${message} (${source}:${line})`);
+  });
+  win.webContents.on("preload-error", (_e, file, err) => {
+    console.error(`[preload-error] ${file}:`, err);
+  });
+  await win.loadFile(import_node_path7.default.join(__dirname, "../renderer/index.html"));
+  await view.webContents.loadURL("about:blank");
+  if (process.env.TRQ_DEVTOOLS) {
+    win.webContents.openDevTools({ mode: "detach" });
+  }
+  const autoTest = process.env.TRQ_AUTO_TEST;
+  if (autoTest === "1") {
+    runAutoTest(win, view).catch((err) => {
+      console.error("[auto-test] failed:", err);
+      import_electron2.app.exit(1);
+    });
+  } else if (autoTest === "config") {
+    runConfigAutoTest(win, view).catch((err) => {
+      console.error("[config-test] failed:", err);
+      import_electron2.app.exit(1);
+    });
+  } else if (autoTest === "play") {
+    runPlayAutoTest(win, view).catch((err) => {
+      console.error("[play-test] failed:", err);
+      import_electron2.app.exit(1);
+    });
+  } else if (autoTest === "inspect") {
+    runInspectAutoTest(win, view).catch((err) => {
+      console.error("[inspect-test] failed:", err);
+      import_electron2.app.exit(1);
+    });
+  } else if (autoTest === "debug") {
+    runDebugAutoTest(win, view).catch((err) => {
+      console.error("[debug-test] failed:", err);
+      import_electron2.app.exit(1);
+    });
+  } else if (autoTest === "responsive") {
+    runResponsiveAutoTest(win, view).catch((err) => {
+      console.error("[responsive-test] failed:", err);
+      import_electron2.app.exit(1);
+    });
+  } else if (autoTest === "tabs") {
+    runTabsAutoTest(win, state).catch((err) => {
+      console.error("[tabs-test] failed:", err);
+      import_electron2.app.exit(1);
+    });
+  } else if (autoTest === "scaledViewport") {
+    runScaledViewportAutoTest(win, state).catch((err) => {
+      console.error("[scaledviewport-test] failed:", err);
+      import_electron2.app.exit(1);
+    });
+  }
+  const cleanup = () => {
+    try {
+      const dbg = view.webContents.debugger;
+      if (dbg.isAttached()) dbg.detach();
+    } catch {
+    }
+  };
+  win.on("closed", cleanup);
+  import_electron2.app.on("before-quit", cleanup);
+}
+async function runAutoTest(win, view) {
+  const name = process.env.TRQ_AUTO_TEST_SESSION ?? `gui-smoketest-${Date.now()}`;
+  const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+  console.log(`[auto-test] creating session ${name}`);
+  await win.webContents.executeJavaScript(
+    `window.trq.invoke('sessions:create', { name: ${JSON.stringify(name)}, startUrl: 'https://example.com' })`
+  );
+  console.log("[auto-test] starting recording");
+  await win.webContents.executeJavaScript(
+    `window.trq.invoke('recording:start', { name: ${JSON.stringify(name)} })`
+  );
+  await wait(500);
+  console.log("[auto-test] navigating BrowserView to example.com");
+  await win.webContents.executeJavaScript(
+    `window.trq.invoke('view:navigate', { url: 'https://example.com' })`
+  );
+  await wait(3e3);
+  console.log("[auto-test] locating link to click");
+  const linkBox = await view.webContents.executeJavaScript(`
+    (() => {
+      const links = Array.from(document.querySelectorAll('a'));
+      console.log('[page] found', links.length, 'links:', links.map((a) => a.textContent));
+      const a = links[0];
+      if (!a) return null;
+      const r = a.getBoundingClientRect();
+      return { x: Math.round(r.x + r.width / 2), y: Math.round(r.y + r.height / 2), text: a.textContent };
+    })()
+  `);
+  console.log("[auto-test] linkBox:", linkBox);
+  if (!linkBox) {
+    console.log("[auto-test] WARN: link not found, skipping click");
+  } else {
+    await view.webContents.sendInputEvent({ type: "mouseMove", x: linkBox.x, y: linkBox.y });
+    await view.webContents.sendInputEvent({ type: "mouseDown", x: linkBox.x, y: linkBox.y, button: "left", clickCount: 1 });
+    await view.webContents.sendInputEvent({ type: "mouseUp", x: linkBox.x, y: linkBox.y, button: "left", clickCount: 1 });
+  }
+  await wait(2500);
+  console.log("[auto-test] stopping recording");
+  await win.webContents.executeJavaScript(
+    `window.trq.invoke('recording:stop', undefined)`
+  );
+  await wait(500);
+  const events = await win.webContents.executeJavaScript(
+    `window.trq.invoke('sessions:events', { name: ${JSON.stringify(name)} })`
+  );
+  console.log(`[auto-test] captured ${events.length} events:`);
+  for (const e of events) console.log(`  ${e.id} ${e.type}`);
+  console.log("[auto-test] PASS \u2014 quitting");
+  import_electron2.app.quit();
+}
+async function runConfigAutoTest(win, view) {
+  const name = process.env.TRQ_AUTO_TEST_SESSION ?? `cfg-smoketest-${Date.now()}`;
+  const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+  const CONFIG = {
+    viewport: { width: 800, height: 600, deviceScaleFactor: 1, mobile: false },
+    permissions: ["geolocation"],
+    geolocation: { latitude: 52.52, longitude: 13.405, accuracy: 5 },
+    locale: "de-DE",
+    timezone: "Europe/Berlin"
+  };
+  console.log(`[config-test] creating session ${name}`);
+  await win.webContents.executeJavaScript(
+    `window.trq.invoke('sessions:create', { name: ${JSON.stringify(name)}, startUrl: 'about:blank' })`
+  );
+  console.log("[config-test] writing config:", CONFIG);
+  await win.webContents.executeJavaScript(
+    `window.trq.invoke('config:set', { name: ${JSON.stringify(name)}, config: ${JSON.stringify(CONFIG)} })`
+  );
+  console.log("[config-test] starting recording");
+  await win.webContents.executeJavaScript(
+    `window.trq.invoke('recording:start', { name: ${JSON.stringify(name)} })`
+  );
+  await wait(600);
+  console.log("[config-test] navigating to https://example.com");
+  await win.webContents.executeJavaScript(
+    `window.trq.invoke('view:navigate', { url: 'https://example.com' })`
+  );
+  await wait(2500);
+  const probe = await view.webContents.executeJavaScript(`
+    (async () => {
+      const out = {
+        innerWidth: window.innerWidth,
+        innerHeight: window.innerHeight,
+        locale: (new Intl.DateTimeFormat()).resolvedOptions().locale,
+        timezone: (new Intl.DateTimeFormat()).resolvedOptions().timeZone,
+        geo: null,
+        geoErr: null,
+      };
+      try {
+        out.geo = await new Promise((resolve, reject) => {
+          navigator.geolocation.getCurrentPosition(
+            (pos) => resolve({ lat: pos.coords.latitude, lng: pos.coords.longitude, acc: pos.coords.accuracy }),
+            (err) => reject(err.message || String(err)),
+            { timeout: 4000 },
+          );
+        });
+      } catch (e) { out.geoErr = String(e); }
+      return out;
+    })()
+  `);
+  console.log("[config-test] probe result:", JSON.stringify(probe, null, 2));
+  const checks = [
+    ["viewport.width", probe.innerWidth, CONFIG.viewport.width],
+    ["viewport.height", probe.innerHeight, CONFIG.viewport.height],
+    ["locale", probe.locale, CONFIG.locale],
+    ["timezone", probe.timezone, CONFIG.timezone],
+    ["geo.lat", probe.geo?.lat, CONFIG.geolocation.latitude],
+    ["geo.lng", probe.geo?.lng, CONFIG.geolocation.longitude]
+  ];
+  let pass = true;
+  for (const [field, actual, expected] of checks) {
+    const ok = actual === expected;
+    console.log(`  [${ok ? "\u2713" : "\u2717"}] ${field}: ${JSON.stringify(actual)} (expected ${JSON.stringify(expected)})`);
+    if (!ok) pass = false;
+  }
+  console.log("[config-test] stopping recording");
+  await win.webContents.executeJavaScript(
+    `window.trq.invoke('recording:stop', undefined)`
+  );
+  await wait(400);
+  console.log(`[config-test] ${pass ? "PASS" : "FAIL"}`);
+  import_electron2.app.exit(pass ? 0 : 1);
+}
+async function runPlayAutoTest(win, view) {
+  const name = process.env.TRQ_AUTO_TEST_SESSION ?? "gui-smoketest";
+  const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+  const timeoutMs = +(process.env.TRQ_AUTO_TEST_TIMEOUT ?? "120000");
+  await win.webContents.executeJavaScript(`
+    (() => {
+      window.trq.on('session:status', (s) => {
+        console.log('[status] mode=' + s.mode);
+      });
+      window.trq.on('replay:progress', (p) => {
+        console.log('[progress] ' + p.current + '/' + p.total + ' ' + p.eventType + ' (' + p.status + (p.detail ? ' \u2014 ' + p.detail : '') + ')');
+      });
+      return null;
+    })()
+  `);
+  const runOne = async (label) => {
+    console.log(`[${label}] invoke replay:play`);
+    const invokePromise = win.webContents.executeJavaScript(
+      `window.trq.invoke('replay:play', { name: ${JSON.stringify(name)} }).then(() => '__OK__').catch((e) => '__ERR__: ' + e.message)`
+    );
+    const result = await Promise.race([
+      invokePromise,
+      new Promise((resolve) => setTimeout(() => resolve("__TIMEOUT__"), timeoutMs))
+    ]);
+    console.log(`[${label}] result: ${result} / final URL: ${view.webContents.getURL()}`);
+    return result;
+  };
+  const a = await runOne("play-1");
+  if (a !== "__OK__") {
+    import_electron2.app.exit(1);
+    return;
+  }
+  console.log("[play-test] waiting 2s before play-2\u2026");
+  await wait(2e3);
+  const b = await runOne("play-2");
+  import_electron2.app.exit(a === "__OK__" && b === "__OK__" ? 0 : 1);
+}
+async function runInspectAutoTest(win, view) {
+  const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+  console.log("[inspect-test] starting inspect mode");
+  await win.webContents.executeJavaScript(
+    `window.trq.invoke('inspect:start', undefined)`
+  );
+  await wait(500);
+  console.log("[inspect-test] navigating BrowserView to example.com");
+  await win.webContents.executeJavaScript(
+    `window.trq.invoke('view:navigate', { url: 'https://example.com' })`
+  );
+  await wait(3e3);
+  let hoverCount = 0;
+  await win.webContents.executeJavaScript(`
+    (() => {
+      window.__inspectHovers = [];
+      window.trq.on('inspect:hover', (h) => {
+        window.__inspectHovers.push(h);
+        console.log('[hover] ' + JSON.stringify({
+          tag: h.target.tagName,
+          firstSelector: h.selectors && h.selectors[0] && h.selectors[0][0],
+        }));
+      });
+      return null;
+    })()
+  `);
+  const linkBox = await view.webContents.executeJavaScript(`
+    (() => {
+      const a = document.querySelector('a');
+      if (!a) return null;
+      const r = a.getBoundingClientRect();
+      return { x: Math.round(r.x + r.width / 2), y: Math.round(r.y + r.height / 2), text: a.textContent };
+    })()
+  `);
+  console.log("[inspect-test] target link:", linkBox);
+  if (!linkBox) {
+    import_electron2.app.exit(1);
+    return;
+  }
+  await view.webContents.sendInputEvent({ type: "mouseMove", x: 20, y: 20 });
+  await wait(80);
+  await view.webContents.sendInputEvent({ type: "mouseMove", x: linkBox.x, y: linkBox.y });
+  await wait(800);
+  const hovers = await win.webContents.executeJavaScript("window.__inspectHovers");
+  console.log(`[inspect-test] received ${hovers.length} hover events`);
+  if (hovers.length > 0) {
+    const last = hovers[hovers.length - 1];
+    console.log("[inspect-test] last hover selectors:");
+    for (const s of last.selectors) console.log("  - " + s[0]);
+  }
+  hoverCount = hovers.length;
+  if (hovers.length > 0) {
+    const sels = hovers[hovers.length - 1].selectors;
+    const ok = await win.webContents.executeJavaScript(
+      `window.trq.invoke('inspect:highlight', { selectors: ${JSON.stringify(sels)} })`
+    );
+    console.log("[inspect-test] highlight returned:", ok);
+    await wait(1e3);
+  }
+  await win.webContents.executeJavaScript(`window.trq.invoke('inspect:stop', undefined)`);
+  console.log(`[inspect-test] ${hoverCount > 0 ? "PASS" : "FAIL"}`);
+  import_electron2.app.exit(hoverCount > 0 ? 0 : 1);
+}
+async function runDebugAutoTest(win, view) {
+  const name = process.env.TRQ_AUTO_TEST_SESSION ?? "assert-test";
+  const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+  await win.webContents.executeJavaScript(`
+    (() => {
+      window.__cursors = [];
+      window.__statuses = [];
+      window.trq.on('replay:cursor', (c) => {
+        window.__cursors.push(c);
+        console.log('[cursor] ' + c.idx + '/' + c.total + ' ' + (c.eventId ?? '-') + ' ' + (c.eventType ?? '-'));
+      });
+      window.trq.on('session:status', (s) => {
+        window.__statuses.push(s);
+        console.log('[status] mode=' + s.mode);
+      });
+      return null;
+    })()
+  `);
+  console.log(`[debug-test] starting inspect on session: ${name}`);
+  await win.webContents.executeJavaScript(
+    `window.trq.invoke('inspect:start', { name: ${JSON.stringify(name)} })`
+  );
+  let cursors = [];
+  for (let i = 0; i < 30; i++) {
+    cursors = await win.webContents.executeJavaScript("window.__cursors");
+    if (cursors.length > 0) break;
+    await wait(200);
+  }
+  if (cursors.length === 0) {
+    console.log("[debug-test] FAIL \u2014 no cursor received after inspect:start");
+    import_electron2.app.exit(1);
+    return;
+  }
+  const first = cursors[0];
+  console.log(`[debug-test] first cursor: idx=${first.idx} total=${first.total} eventType=${first.eventType}`);
+  console.log("[debug-test] step-over");
+  await win.webContents.executeJavaScript(`window.trq.invoke('inspect:step', undefined)`);
+  await wait(2500);
+  cursors = await win.webContents.executeJavaScript("window.__cursors");
+  console.log(`[debug-test] cursors so far: ${cursors.length}`);
+  if (cursors.length < 2) {
+    console.log("[debug-test] FAIL \u2014 no second cursor after step");
+    import_electron2.app.exit(1);
+    return;
+  }
+  console.log(`[debug-test] second cursor: idx=${cursors[1].idx} eventType=${cursors[1].eventType}`);
+  console.log("[debug-test] run-to-end");
+  await win.webContents.executeJavaScript(`window.trq.invoke('inspect:continue', undefined)`);
+  let modeIdle = false;
+  for (let i = 0; i < 60; i++) {
+    const statuses = await win.webContents.executeJavaScript("window.__statuses");
+    if (statuses.find((s) => s.mode === "idle" && statuses.indexOf(s) > 0)) {
+      modeIdle = true;
+      break;
+    }
+    await wait(500);
+  }
+  console.log(`[debug-test] mode returned to idle: ${modeIdle}`);
+  console.log(`[debug-test] ${modeIdle ? "PASS" : "FAIL"}`);
+  import_electron2.app.exit(modeIdle ? 0 : 1);
+}
+async function runResponsiveAutoTest(win, view) {
+  const name = process.env.TRQ_AUTO_TEST_SESSION ?? "assert-test";
+  const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+  console.log(`[responsive-test] starting inspect on session: ${name}`);
+  await win.webContents.executeJavaScript(
+    `window.trq.invoke('inspect:start', { name: ${JSON.stringify(name)} })`
+  );
+  await win.webContents.executeJavaScript(`window.trq.invoke('inspect:step', undefined)`);
+  await wait(2500);
+  const expanded = await view.webContents.executeJavaScript(`
+    ({ innerWidth: window.innerWidth, innerHeight: window.innerHeight })
+  `);
+  console.log(`[responsive-test] expanded inspector \u2192 page reports ${expanded.innerWidth}x${expanded.innerHeight}`);
+  await win.webContents.executeJavaScript(`window.trq.invoke('inspect:toggleCollapsed', undefined)`);
+  await wait(500);
+  const collapsed = await view.webContents.executeJavaScript(`
+    ({ innerWidth: window.innerWidth, innerHeight: window.innerHeight })
+  `);
+  console.log(`[responsive-test] collapsed inspector \u2192 page reports ${collapsed.innerWidth}x${collapsed.innerHeight}`);
+  await win.webContents.executeJavaScript(`window.trq.invoke('inspect:toggleCollapsed', undefined)`);
+  await wait(500);
+  const reExpanded = await view.webContents.executeJavaScript(`
+    ({ innerWidth: window.innerWidth, innerHeight: window.innerHeight })
+  `);
+  console.log(`[responsive-test] re-expanded \u2192 page reports ${reExpanded.innerWidth}x${reExpanded.innerHeight}`);
+  const tolerance = 4;
+  const expectedExpanded = 1280 - SIDEBAR_W - INSPECTOR_W;
+  const expectedCollapsed = 1280 - SIDEBAR_W - INSPECTOR_W_COLLAPSED;
+  const pass = Math.abs(expanded.innerWidth - expectedExpanded) < tolerance && Math.abs(collapsed.innerWidth - expectedCollapsed) < tolerance && Math.abs(reExpanded.innerWidth - expectedExpanded) < tolerance;
+  console.log(`[responsive-test] expected expanded=${expectedExpanded}, collapsed=${expectedCollapsed}`);
+  console.log(`[responsive-test] ${pass ? "PASS" : "FAIL"}`);
+  import_electron2.app.exit(pass ? 0 : 1);
+}
+async function runTabsAutoTest(win, state) {
+  const name = process.env.TRQ_AUTO_TEST_SESSION ?? `tabs-smoketest-${Date.now()}`;
+  const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+  console.log(`[tabs-test] creating session ${name}`);
+  await win.webContents.executeJavaScript(
+    `window.trq.invoke('sessions:create', { name: ${JSON.stringify(name)}, startUrl: 'about:blank' })`
+  );
+  console.log("[tabs-test] starting recording");
+  await win.webContents.executeJavaScript(
+    `window.trq.invoke('recording:start', { name: ${JSON.stringify(name)} })`
+  );
+  await wait(600);
+  const dataUrl = "data:text/html," + encodeURIComponent(
+    '<!doctype html><meta charset=utf8><title>Tab Test</title><body style="font: 16px sans-serif; padding: 20px"><a id="link" href="https://example.com" target="_blank">open in new tab</a></body>'
+  );
+  console.log("[tabs-test] navigating active tab to data: URL");
+  await win.webContents.executeJavaScript(
+    `window.trq.invoke('view:navigate', { url: ${JSON.stringify(dataUrl)} })`
+  );
+  await wait(1500);
+  const linkBox = await state.view.webContents.executeJavaScript(`
+    (() => {
+      const a = document.getElementById('link');
+      if (!a) return null;
+      const r = a.getBoundingClientRect();
+      return { x: Math.round(r.x + r.width / 2), y: Math.round(r.y + r.height / 2) };
+    })()
+  `);
+  if (!linkBox) {
+    console.log("[tabs-test] FAIL \u2014 link not found");
+    import_electron2.app.exit(1);
+    return;
+  }
+  console.log(`[tabs-test] clicking link at ${linkBox.x},${linkBox.y}`);
+  await state.view.webContents.sendInputEvent({ type: "mouseMove", x: linkBox.x, y: linkBox.y });
+  await state.view.webContents.sendInputEvent({ type: "mouseDown", x: linkBox.x, y: linkBox.y, button: "left", clickCount: 1 });
+  await state.view.webContents.sendInputEvent({ type: "mouseUp", x: linkBox.x, y: linkBox.y, button: "left", clickCount: 1 });
+  await wait(3e3);
+  console.log(`[tabs-test] tabs.length = ${state.tabs.length}`);
+  console.log(`[tabs-test] active tab url = ${state.view.webContents.getURL()}`);
+  const sawNewTab = state.tabs.length === 2;
+  const newTabUrl = state.tabs[1]?.view.webContents.getURL() ?? "";
+  const newTabLoadedExample = newTabUrl.includes("example.com");
+  console.log(`[tabs-test] sawNewTab=${sawNewTab} newTabLoadedExample=${newTabLoadedExample}`);
+  console.log("[tabs-test] stopping recording");
+  await win.webContents.executeJavaScript(
+    `window.trq.invoke('recording:stop', undefined)`
+  );
+  await wait(500);
+  const pass = sawNewTab && newTabLoadedExample;
+  console.log(`[tabs-test] ${pass ? "PASS" : "FAIL"}`);
+  import_electron2.app.exit(pass ? 0 : 1);
+}
+async function runScaledViewportAutoTest(win, state) {
+  const name = process.env.TRQ_AUTO_TEST_SESSION ?? `scaledvp-smoketest-${Date.now()}`;
+  const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+  console.log(`[scaledviewport-test] creating session ${name}`);
+  await win.webContents.executeJavaScript(
+    `window.trq.invoke('sessions:create', { name: ${JSON.stringify(name)}, startUrl: 'about:blank' })`
+  );
+  const LOCKED = { width: 1920, height: 1080, deviceScaleFactor: 1, mobile: false };
+  console.log(`[scaledviewport-test] writing config.viewport = ${LOCKED.width}x${LOCKED.height}`);
+  await win.webContents.executeJavaScript(
+    `window.trq.invoke('config:set', { name: ${JSON.stringify(name)}, config: { viewport: ${JSON.stringify(LOCKED)} } })`
+  );
+  console.log("[scaledviewport-test] starting recording");
+  await win.webContents.executeJavaScript(
+    `window.trq.invoke('recording:start', { name: ${JSON.stringify(name)} })`
+  );
+  await wait(800);
+  const dataUrl = "data:text/html," + encodeURIComponent(
+    '<!doctype html><meta charset=utf8><title>Scaled VP Test</title><style>body{margin:0} #m{width:1920px;height:1080px;background:linear-gradient(90deg,#f00,#0f0,#00f)}</style><body><div id="m">marker</div></body>'
+  );
+  await win.webContents.executeJavaScript(
+    `window.trq.invoke('view:navigate', { url: ${JSON.stringify(dataUrl)} })`
+  );
+  await wait(1500);
+  const viewBounds = state.view.getBounds();
+  console.log(`[scaledviewport-test] BrowserView bounds: ${viewBounds.width}x${viewBounds.height}`);
+  const probe = await state.view.webContents.executeJavaScript(`
+    ({
+      innerWidth: window.innerWidth,
+      innerHeight: window.innerHeight,
+      scrollWidth: document.documentElement.scrollWidth,
+      scrollHeight: document.documentElement.scrollHeight,
+    })
+  `);
+  console.log(`[scaledviewport-test] page reports: ${JSON.stringify(probe)}`);
+  await win.webContents.executeJavaScript(`window.trq.invoke('recording:stop', undefined)`);
+  await wait(400);
+  const expectedScale = Math.min(1, viewBounds.width / LOCKED.width, viewBounds.height / LOCKED.height);
+  const checks = [
+    ["innerWidth (page should see locked width)", probe.innerWidth, LOCKED.width],
+    ["innerHeight (page should see locked height)", probe.innerHeight, LOCKED.height],
+    ["view bounds preserved (BrowserView did NOT grow to locked size)", viewBounds.width < LOCKED.width, true]
+  ];
+  let pass = true;
+  for (const [label, actual, expected] of checks) {
+    const ok = actual === expected;
+    console.log(`  [${ok ? "\u2713" : "\u2717"}] ${label}: ${JSON.stringify(actual)} (expected ${JSON.stringify(expected)})`);
+    if (!ok) pass = false;
+  }
+  console.log(`[scaledviewport-test] expected scale \u2248 ${expectedScale.toFixed(3)}`);
+  console.log(`[scaledviewport-test] ${pass ? "PASS" : "FAIL"}`);
+  import_electron2.app.exit(pass ? 0 : 1);
+}
+import_electron2.app.whenReady().then(createWindow);
+import_electron2.app.on("window-all-closed", () => {
+  if (process.platform !== "darwin") import_electron2.app.quit();
+});
+import_electron2.app.on("activate", () => {
+  if (import_electron2.BrowserWindow.getAllWindows().length === 0) createWindow();
+});