@ranganathmk/trq 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,1721 @@
+import { createRequire } from "module"; const require = createRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../core/src/cdp.ts
+function adaptCDPSession(session) {
+  return {
+    send: (method, params) => session.send(method, params),
+    on: (event, listener) => {
+      session.on(event, listener);
+    },
+    off: (event, listener) => {
+      session.off(event, listener);
+    }
+  };
+}
+var init_cdp = __esm({
+  "../core/src/cdp.ts"() {
+    "use strict";
+  }
+});
+
+// ../core/src/config.ts
+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 init_config = __esm({
+  "../core/src/config.ts"() {
+    "use strict";
+  }
+});
+
+// ../core/src/page-context.ts
+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({
+  "../core/src/page-context.ts"() {
+    "use strict";
+  }
+});
+
+// ../core/src/replay.ts
+var replay_exports = {};
+__export(replay_exports, {
+  HELPERS_PATH: () => HELPERS_PATH,
+  INJECT_ANIMATION_KILL: () => INJECT_ANIMATION_KILL,
+  isAnchorClick: () => isAnchorClick,
+  replayAssert: () => replayAssert,
+  replayClick: () => replayClick,
+  replayInput: () => replayInput,
+  replayKey: () => replayKey,
+  replayNavigate: () => replayNavigate,
+  runReplay: () => runReplay,
+  runReplayOnClient: () => runReplayOnClient,
+  setupReplayClient: () => setupReplayClient,
+  urlAreaOf: () => urlAreaOf,
+  urlInArea: () => urlInArea,
+  waitForAnchorClickConsequence: () => waitForAnchorClickConsequence
+});
+import puppeteer2 from "puppeteer";
+import { promises as fs3 } from "node:fs";
+import path3 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+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;
+}
+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 });
+}
+async function runReplay(opts) {
+  const events = await opts.session.readEvents();
+  const total = events.length;
+  const target = opts.toStep != null ? Math.min(opts.toStep, total) : total;
+  const helpers = await fs3.readFile(HELPERS_PATH, "utf8");
+  const config = await opts.session.readConfig();
+  const browser = await puppeteer2.launch({
+    headless: false,
+    defaultViewport: null,
+    args: ["--no-first-run", "--no-default-browser-check", "--start-maximized"]
+  });
+  browser.on("targetdestroyed", async (t) => {
+    if (t.type() !== "page") return;
+    try {
+      const remaining = (await browser.pages()).length;
+      if (remaining === 0) await browser.close();
+    } catch {
+    }
+  });
+  const onSigint = async () => {
+    try {
+      await browser.close();
+    } catch {
+    }
+  };
+  process.once("SIGINT", onSigint);
+  const setupPage = async (page2) => {
+    const client2 = await page2.createCDPSession();
+    await client2.send("Page.enable");
+    await client2.send("Runtime.enable");
+    await applyConfig(adaptCDPSession(client2), config);
+    await client2.send("Page.addScriptToEvaluateOnNewDocument", { source: helpers });
+    if (opts.killAnimations !== false) {
+      await client2.send("Page.addScriptToEvaluateOnNewDocument", {
+        source: INJECT_ANIMATION_KILL
+      });
+    }
+    await client2.send("Runtime.evaluate", { expression: helpers }).catch(() => {
+    });
+    if (opts.killAnimations !== false) {
+      await client2.send("Runtime.evaluate", { expression: INJECT_ANIMATION_KILL }).catch(() => {
+      });
+    }
+    return client2;
+  };
+  const pages = await browser.pages();
+  const page = pages[0] ?? await browser.newPage();
+  const client = await setupPage(page);
+  const ctx = puppeteerPageContext(page, adaptCDPSession(client));
+  let completed = 0;
+  let prev = null;
+  for (let i = 0; i < target; i++) {
+    const e = events[i];
+    opts.onProgress?.(i + 1, target, e, "start");
+    try {
+      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 expectedArea = urlAreaOf(expectedNextUrl);
+        const start = Date.now();
+        let lastUrl = null;
+        let stableSince = start;
+        while (Date.now() - start < 2e4) {
+          let ready = false;
+          try {
+            const v = await ctx.evaluate(() => document.readyState);
+            ready = v === "complete";
+          } catch {
+          }
+          const u = ctx.url();
+          if (u !== lastUrl) {
+            lastUrl = u;
+            stableSince = Date.now();
+          }
+          const inArea = expectedArea ? urlInArea(u, expectedArea) : true;
+          if (ready && inArea && Date.now() - stableSince >= 1200) break;
+          await new Promise((r) => setTimeout(r, 150));
+        }
+      }
+      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);
+      process.removeListener("SIGINT", onSigint);
+      return {
+        completed,
+        total,
+        failed: { step: i + 1, reason: msg, event: e },
+        browser
+      };
+    }
+  }
+  process.removeListener("SIGINT", onSigint);
+  return { completed, total, browser };
+}
+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 fs3.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 };
+}
+var __dirname2, HELPERS_PATH, ANIMATION_KILL_CSS, INJECT_ANIMATION_KILL, MOUSE_BUTTON;
+var init_replay = __esm({
+  "../core/src/replay.ts"() {
+    "use strict";
+    init_cdp();
+    init_config();
+    init_page_context();
+    __dirname2 = path3.dirname(fileURLToPath2(import.meta.url));
+    HELPERS_PATH = path3.join(__dirname2, "replay-helpers.js");
+    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;
+  }
+`;
+    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) {}
+  })();
+`;
+    MOUSE_BUTTON = {
+      left: "left",
+      right: "right",
+      middle: "middle"
+    };
+  }
+});
+
+// ../core/src/resume.ts
+var resume_exports = {};
+__export(resume_exports, {
+  runResume: () => runResume,
+  runResumeOnClient: () => runResumeOnClient
+});
+import puppeteer3 from "puppeteer";
+import { promises as fs4 } from "node:fs";
+import path4 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+async function runResume(opts) {
+  const events = await opts.session.readEvents();
+  const total = events.length;
+  const priorStepCount = opts.session.manifest.stepCount;
+  const helpers = await fs4.readFile(HELPERS_PATH, "utf8");
+  const bootstrap = await fs4.readFile(BOOTSTRAP_PATH2, "utf8");
+  const config = await opts.session.readConfig();
+  const browser = await puppeteer3.launch({
+    headless: false,
+    defaultViewport: null,
+    args: ["--no-first-run", "--no-default-browser-check", "--start-maximized"]
+  });
+  const closed = new Promise(
+    (resolve) => browser.once("disconnected", () => resolve())
+  );
+  const clients = /* @__PURE__ */ new Set();
+  let mode = "replaying";
+  let newRecorded = 0;
+  const broadcastStepCount2 = async () => {
+    const n = opts.session.manifest.stepCount;
+    const expr = `window.__trqSetStep && window.__trqSetStep(${n})`;
+    await Promise.all(
+      Array.from(clients).map(
+        (c) => c.send("Runtime.evaluate", { expression: expr }).catch(() => {
+        })
+      )
+    );
+  };
+  const broadcastMode = async (m) => {
+    const expr = `window.__trqMode = ${JSON.stringify(m)};`;
+    await Promise.all(
+      Array.from(clients).map(
+        (c) => c.send("Runtime.evaluate", { expression: expr }).catch(() => {
+        })
+      )
+    );
+  };
+  const setupPage = async (page2) => {
+    const client2 = await page2.createCDPSession();
+    clients.add(client2);
+    client2.on("disconnected", () => clients.delete(client2));
+    await client2.send("Runtime.enable");
+    await client2.send("Page.enable");
+    await applyConfig(adaptCDPSession(client2), config);
+    await client2.send("Runtime.addBinding", { name: BINDING_NAME2 }).catch(() => {
+    });
+    await client2.send("Page.addScriptToEvaluateOnNewDocument", {
+      source: `window.__trqMode = window.__trqMode || ${JSON.stringify(mode)};`
+    });
+    await client2.send("Page.addScriptToEvaluateOnNewDocument", { source: helpers });
+    await client2.send("Page.addScriptToEvaluateOnNewDocument", { source: bootstrap });
+    await client2.send("Page.addScriptToEvaluateOnNewDocument", {
+      source: INJECT_ANIMATION_KILL
+    });
+    client2.on("Runtime.bindingCalled", async (event) => {
+      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
+        );
+        newRecorded++;
+        opts.onRecordEvent?.(stamped);
+        await broadcastStepCount2();
+      } catch (err) {
+        console.error("\nFailed to handle event:", err.message);
+      }
+    });
+    await client2.send("Runtime.evaluate", {
+      expression: `window.__trqMode = window.__trqMode || ${JSON.stringify(mode)};`
+    }).catch(() => {
+    });
+    await client2.send("Runtime.evaluate", { expression: helpers }).catch(() => {
+    });
+    await client2.send("Runtime.evaluate", { expression: bootstrap }).catch(() => {
+    });
+    await client2.send("Runtime.evaluate", { expression: INJECT_ANIMATION_KILL }).catch(() => {
+    });
+    return client2;
+  };
+  browser.on("targetdestroyed", async (t) => {
+    if (t.type() !== "page") return;
+    try {
+      const remaining = (await browser.pages()).length;
+      if (remaining === 0) await browser.close();
+    } catch {
+    }
+  });
+  const onSigint = async () => {
+    try {
+      await browser.close();
+    } catch {
+    }
+  };
+  process.once("SIGINT", onSigint);
+  const pages = await browser.pages();
+  const page = pages[0] ?? await browser.newPage();
+  const client = await setupPage(page);
+  const ctx = puppeteerPageContext(page, adaptCDPSession(client));
+  let prev = null;
+  for (let i = 0; i < total; i++) {
+    const e = events[i];
+    opts.onReplayProgress?.(i + 1, total, e, "start");
+    try {
+      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 expectedArea = urlAreaOf(expectedNextUrl);
+        const start = Date.now();
+        let lastUrl = null;
+        let stableSince = start;
+        while (Date.now() - start < 2e4) {
+          let ready = false;
+          try {
+            const v = await ctx.evaluate(() => document.readyState);
+            ready = v === "complete";
+          } catch {
+          }
+          const u = ctx.url();
+          if (u !== lastUrl) {
+            lastUrl = u;
+            stableSince = Date.now();
+          }
+          const inArea = expectedArea ? urlInArea(u, expectedArea) : true;
+          if (ready && inArea && Date.now() - stableSince >= 1200) break;
+          await new Promise((r) => setTimeout(r, 150));
+        }
+      }
+      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);
+      process.removeListener("SIGINT", onSigint);
+      await closed;
+      return {
+        replayed: i,
+        newRecorded,
+        failed: { step: i + 1, reason: msg }
+      };
+    }
+  }
+  mode = "recording";
+  await broadcastMode("recording");
+  await broadcastStepCount2();
+  opts.onRecordingStart?.();
+  await closed;
+  process.removeListener("SIGINT", onSigint);
+  return { replayed: total, newRecorded };
+}
+async function runResumeOnClient(opts) {
+  let events = await opts.session.readEvents();
+  let total = events.length;
+  const helpers = await fs4.readFile(HELPERS_PATH, "utf8");
+  const bootstrap = await fs4.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 };
+}
+var __dirname3, BOOTSTRAP_PATH2, BINDING_NAME2;
+var init_resume = __esm({
+  "../core/src/resume.ts"() {
+    "use strict";
+    init_cdp();
+    init_config();
+    init_page_context();
+    init_replay();
+    __dirname3 = path4.dirname(fileURLToPath3(import.meta.url));
+    BOOTSTRAP_PATH2 = path4.join(__dirname3, "bootstrap.js");
+    BINDING_NAME2 = "__trqEmit";
+  }
+});
+
+// ../core/src/cli.ts
+import path5 from "node:path";
+
+// ../core/src/agent.ts
+init_cdp();
+import puppeteer from "puppeteer";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+// ../core/src/recording.ts
+init_config();
+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);
+}
+
+// ../core/src/agent.ts
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var BOOTSTRAP_PATH = path.join(__dirname, "bootstrap.js");
+async function runAgent(opts) {
+  const bootstrap = await fs.readFile(BOOTSTRAP_PATH, "utf8");
+  const config = await opts.session.readConfig();
+  const browser = await puppeteer.launch({
+    headless: false,
+    defaultViewport: null,
+    args: ["--no-first-run", "--no-default-browser-check", "--start-maximized"]
+  });
+  const closed = new Promise((resolve) => browser.once("disconnected", () => resolve()));
+  const ctx = {
+    session: opts.session,
+    bootstrap,
+    clients: /* @__PURE__ */ new Set(),
+    onEvent: opts.onEvent,
+    config
+  };
+  const setupPage = async (page) => {
+    try {
+      const session = await page.createCDPSession();
+      const client = adaptCDPSession(session);
+      await setupRecordingOnClient(client, ctx);
+    } catch {
+    }
+  };
+  const pages = await browser.pages();
+  for (const p of pages) await setupPage(p);
+  browser.on("targetcreated", async (target) => {
+    if (target.type() !== "page") return;
+    const page = await target.page();
+    if (page) await setupPage(page);
+  });
+  browser.on("targetdestroyed", async (target) => {
+    if (target.type() !== "page") return;
+    try {
+      const remaining = (await browser.pages()).length;
+      if (remaining === 0) await browser.close();
+    } catch {
+    }
+  });
+  const onSigint = async () => {
+    try {
+      await browser.close();
+    } catch {
+    }
+  };
+  process.once("SIGINT", onSigint);
+  if (opts.startUrl && opts.startUrl !== "about:blank" && pages[0]) {
+    await pages[0].goto(opts.startUrl).catch(() => {
+    });
+  }
+  await closed;
+  process.removeListener("SIGINT", onSigint);
+}
+
+// ../core/src/storage.ts
+import { promises as fs2 } from "node:fs";
+import { existsSync } from "node:fs";
+import path2 from "node:path";
+var Session = class _Session {
+  constructor(dir, manifest) {
+    this.dir = dir;
+    this.manifest = manifest;
+  }
+  writeChain = Promise.resolve();
+  static async create(rootDir, name, initialUrl) {
+    const dir = path2.join(rootDir, name);
+    if (existsSync(dir)) {
+      throw new Error(`Session already exists: ${name}`);
+    }
+    await fs2.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 fs2.writeFile(path2.join(dir, "manifest.json"), JSON.stringify(manifest, null, 2));
+    await fs2.writeFile(path2.join(dir, "events.jsonl"), "");
+    return new _Session(dir, manifest);
+  }
+  static async load(rootDir, name) {
+    const dir = path2.join(rootDir, name);
+    const raw = await fs2.readFile(path2.join(dir, "manifest.json"), "utf8");
+    return new _Session(dir, JSON.parse(raw));
+  }
+  static async list(rootDir) {
+    if (!existsSync(rootDir)) return [];
+    const names = await fs2.readdir(rootDir);
+    const out = [];
+    for (const name of names) {
+      const mp = path2.join(rootDir, name, "manifest.json");
+      if (!existsSync(mp)) continue;
+      try {
+        out.push(JSON.parse(await fs2.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 fs2.appendFile(path2.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 fs2.writeFile(path2.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 fs2.writeFile(path2.join(this.dir, "events.jsonl"), body);
+  }
+  async flushManifest() {
+    await fs2.writeFile(
+      path2.join(this.dir, "manifest.json"),
+      JSON.stringify(this.manifest, null, 2)
+    );
+  }
+  async readEvents() {
+    const raw = await fs2.readFile(path2.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 = path2.join(this.dir, "config.json");
+    if (!existsSync(p)) return {};
+    try {
+      return JSON.parse(await fs2.readFile(p, "utf8"));
+    } catch {
+      return {};
+    }
+  }
+  async writeConfig(cfg) {
+    await fs2.writeFile(
+      path2.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);
+}
+
+// ../core/src/cli.ts
+var SESSIONS_DIR = process.env.TRQ_SESSIONS_DIR ? path5.resolve(process.env.TRQ_SESSIONS_DIR) : path5.join(process.cwd(), "sessions");
+var argv = process.argv.slice(2);
+var cmd = argv[0];
+async function main() {
+  switch (cmd) {
+    case "new":
+      return cmdNew(argv.slice(1));
+    case "list":
+    case "ls":
+      return cmdList();
+    case "show":
+      return cmdShow(argv.slice(1));
+    case "play":
+      return cmdPlay(argv.slice(1));
+    case "resume":
+      return cmdResume(argv.slice(1));
+    case "config":
+      return cmdConfig(argv.slice(1));
+    case "studio":
+      return cmdStudio(argv.slice(1));
+    case "help":
+    case "-h":
+    case "--help":
+    case void 0:
+      return printUsage(0);
+    default:
+      console.error(`Unknown command: ${cmd}
+`);
+      printUsage(1);
+  }
+}
+function printUsage(code) {
+  console.log(`trq \u2014 record and replay web sessions
+
+Usage:
+  trq new <name> [--url <url>]    Create and start recording a new session
+  trq list                         List all sessions
+  trq show <name>                  Show recorded events for a session
+  trq play <name> [--to N] [--slow]
+                                      Replay a session end-to-end (or up to step N)
+  trq resume <name>                Replay all prior steps, then continue recording
+  trq config show <name>           Print the session's config.json
+  trq config set <name> <key> <value>
+                                      Set a single config field (dot.notation, JSON value)
+  trq config unset <name> <key>    Remove a config field
+  trq studio                       Launch the trq Studio desktop GUI
+
+Sessions are stored in: ${SESSIONS_DIR}
+`);
+  process.exit(code);
+}
+async function cmdNew(args) {
+  const name = args[0];
+  if (!name || name.startsWith("--")) {
+    console.error("Usage: trq new <name> [--url <url>]");
+    process.exit(1);
+  }
+  const urlIdx = args.indexOf("--url");
+  const startUrl = urlIdx >= 0 ? args[urlIdx + 1] : "about:blank";
+  const session = await Session.create(SESSIONS_DIR, name);
+  console.log(`\u25B8 Session created: ${name}  (${session.manifest.id})`);
+  console.log(`\u25B8 Recording. Close the Chrome window to save & exit.
+`);
+  let count = 0;
+  await runAgent({
+    session,
+    startUrl,
+    onEvent: (e) => {
+      count++;
+      const label = describeEvent(e, 40);
+      process.stdout.write(
+        `\r  ${count} step${count === 1 ? "" : "s"} \xB7 last: ${label.padEnd(60)}`
+      );
+    }
+  });
+  console.log(`
+
+\u25B8 Saved ${session.manifest.stepCount} steps to ${session.dir}`);
+  if (session.manifest.lastUrl) {
+    console.log(`\u25B8 Last URL: ${session.manifest.lastUrl}`);
+  }
+}
+async function cmdList() {
+  const sessions = await Session.list(SESSIONS_DIR);
+  if (sessions.length === 0) {
+    console.log("No sessions yet. Create one with: trq new <name>");
+    return;
+  }
+  const nameW = Math.max(4, ...sessions.map((s) => s.name.length));
+  console.log(`${"NAME".padEnd(nameW + 2)}STEPS  UPDATED                   LAST URL`);
+  for (const s of sessions) {
+    console.log(
+      `${s.name.padEnd(nameW + 2)}${String(s.stepCount).padEnd(7)}${s.updatedAt}  ${s.lastUrl ?? ""}`
+    );
+  }
+}
+async function cmdShow(args) {
+  const name = args[0];
+  if (!name) {
+    console.error("Usage: trq show <name>");
+    process.exit(1);
+  }
+  const session = await Session.load(SESSIONS_DIR, name);
+  const events = await session.readEvents();
+  console.log(`${session.manifest.id}  ${session.manifest.name}  ${events.length} steps
+`);
+  events.forEach((e, i) => {
+    const idx = String(i + 1).padStart(3);
+    console.log(`  ${idx}  ${describeEvent(e, 60).padEnd(64)}`);
+  });
+  if (events.length > 0) {
+    console.log(`
+Last URL: ${session.manifest.lastUrl ?? "(none)"}`);
+  }
+}
+async function cmdPlay(args) {
+  const name = args[0];
+  if (!name || name.startsWith("--")) {
+    console.error("Usage: trq play <name> [--to N] [--slow]");
+    process.exit(1);
+  }
+  const toIdx = args.indexOf("--to");
+  const toStep = toIdx >= 0 ? parseInt(args[toIdx + 1] ?? "", 10) : void 0;
+  const slow = args.includes("--slow");
+  const session = await Session.load(SESSIONS_DIR, name);
+  const events = await session.readEvents();
+  const total = toStep != null ? Math.min(toStep, events.length) : events.length;
+  console.log(`\u25B8 Replaying ${session.manifest.name} \u2014 ${total}/${events.length} steps`);
+  const { runReplay: runReplay2 } = await Promise.resolve().then(() => (init_replay(), replay_exports));
+  const result = await runReplay2({
+    session,
+    toStep,
+    slow,
+    onProgress: (idx, tot, e, status, detail) => {
+      const label = describeEvent(e, 50);
+      const head = `  ${String(idx).padStart(3)}/${tot}`;
+      if (status === "start") {
+        process.stdout.write(`\r${head}  \u2026  ${label.padEnd(60)}`);
+      } else if (status === "ok") {
+        process.stdout.write(`\r${head}  \u2713  ${label.padEnd(60)}
+`);
+      } else if (status === "fail") {
+        process.stdout.write(`\r${head}  \u2717  ${label.padEnd(60)}
+`);
+        if (detail) console.error(`         ${detail}`);
+      }
+    }
+  });
+  if (result.failed) {
+    console.error(`
+\u2717 Replay failed at step ${result.failed.step}: ${result.failed.reason}`);
+    console.error("  Browser left open for inspection. Close it to exit.");
+    await new Promise((r) => result.browser.once("disconnected", () => r()));
+    process.exit(1);
+  } else {
+    console.log(`
+\u2713 Replay complete (${result.completed}/${result.total} steps).`);
+    console.log("  Browser left open. Close it to exit.");
+    await new Promise((r) => result.browser.once("disconnected", () => r()));
+  }
+}
+async function cmdResume(args) {
+  const name = args[0];
+  if (!name) {
+    console.error("Usage: trq resume <name>");
+    process.exit(1);
+  }
+  const session = await Session.load(SESSIONS_DIR, name);
+  const events = await session.readEvents();
+  console.log(`\u25B8 Resuming ${session.manifest.name} \u2014 ${events.length} prior step${events.length === 1 ? "" : "s"}`);
+  const { runResume: runResume2 } = await Promise.resolve().then(() => (init_resume(), resume_exports));
+  const result = await runResume2({
+    session,
+    onReplayProgress: (idx, tot, e, status, detail) => {
+      const label = describeEvent(e, 50);
+      const head = `  ${String(idx).padStart(3)}/${tot}`;
+      if (status === "start") {
+        process.stdout.write(`\r${head}  \u2026  ${label.padEnd(60)}`);
+      } else if (status === "ok") {
+        process.stdout.write(`\r${head}  \u2713  ${label.padEnd(60)}
+`);
+      } else if (status === "fail") {
+        process.stdout.write(`\r${head}  \u2717  ${label.padEnd(60)}
+`);
+        if (detail) console.error(`         ${detail}`);
+      }
+    },
+    onRecordingStart: () => {
+      console.log(`
+\u25B8 Replay complete. Now recording from step ${events.length + 1}.`);
+      console.log(`  Close the Chrome window when done.
+`);
+    },
+    onRecordEvent: (e) => {
+      const label = describeEvent(e, 40);
+      process.stdout.write(
+        `\r  ${session.manifest.stepCount} steps total \xB7 last: ${label.padEnd(50)}`
+      );
+    }
+  });
+  console.log("");
+  if (result.failed) {
+    console.error(`
+\u2717 Replay failed at step ${result.failed.step}: ${result.failed.reason}`);
+    console.error(`  ${result.replayed}/${events.length} steps replayed before failure.`);
+    process.exit(1);
+  }
+  console.log(`
+\u25B8 Saved ${session.manifest.stepCount} total steps (${result.newRecorded} new).`);
+}
+function describeEvent(e, max) {
+  switch (e.type) {
+    case "click": {
+      const text = e.target.textContent || e.selectors[0]?.[0] || "?";
+      return `click       "${text.slice(0, max)}"`;
+    }
+    case "input": {
+      const label = e.target.attributes["name"] || e.target.attributes["placeholder"] || e.selectors[0]?.[0] || "?";
+      const valDisplay = e.isPassword ? `<password length=${e.value.length}>` : `"${e.value.slice(0, max)}"`;
+      return `input       ${label.slice(0, 24)} = ${valDisplay}`;
+    }
+    case "key": {
+      const where = e.target.tagName.toLowerCase();
+      return `key         ${e.key}${e.modifiers.length ? " (" + e.modifiers.join("+") + ")" : ""}  on <${where}>`;
+    }
+    case "navigate": {
+      const arrow = e.source === "in-document" ? "\u2192" : "\u21D2";
+      return `navigate    ${arrow} ${e.url.slice(0, max)}`;
+    }
+    case "assert": {
+      const tag = e.target.tagName.toLowerCase();
+      switch (e.assertion.kind) {
+        case "visible":
+          return `assert      visible: <${tag}>`;
+        case "text-equals":
+          return `assert      <${tag}> text == "${e.assertion.text.slice(0, max)}"`;
+        case "value-equals":
+          return `assert      <${tag}> value == "${e.assertion.value.slice(0, max)}"`;
+      }
+    }
+  }
+}
+async function cmdConfig(args) {
+  const sub = args[0];
+  const name = args[1];
+  if (!sub || !name) {
+    console.error("Usage:\n  trq config show <name>\n  trq config set <name> <key> <value>\n  trq config unset <name> <key>");
+    process.exit(1);
+  }
+  const session = await Session.load(SESSIONS_DIR, name);
+  if (sub === "show") {
+    console.log(JSON.stringify(await session.readConfig(), null, 2));
+    return;
+  }
+  const key = args[2];
+  if (!key) {
+    console.error(`Usage: trq config ${sub} ${name} <key>${sub === "set" ? " <value>" : ""}`);
+    process.exit(1);
+  }
+  const cfg = await session.readConfig();
+  if (sub === "unset") {
+    unsetPath(cfg, key);
+    await session.writeConfig(cfg);
+    console.log(`\u2713 unset ${key} in ${name}/config.json`);
+    return;
+  }
+  if (sub === "set") {
+    const rawValue = args.slice(3).join(" ");
+    if (rawValue === "") {
+      console.error("Usage: trq config set <name> <key> <value>");
+      process.exit(1);
+    }
+    let value;
+    try {
+      value = JSON.parse(rawValue);
+    } catch {
+      value = rawValue;
+    }
+    setPath(cfg, key, value);
+    await session.writeConfig(cfg);
+    console.log(`\u2713 set ${key} = ${JSON.stringify(value)} in ${name}/config.json`);
+    return;
+  }
+  console.error(`Unknown config subcommand: ${sub}`);
+  process.exit(1);
+}
+async function cmdStudio(args) {
+  const appDir = process.env.TRQ_STUDIO_PATH;
+  if (!appDir) {
+    console.error(
+      "Error: TRQ_STUDIO_PATH is not set.\n  This usually means the studio bundle is missing from the install.\n  If running from a global install, try `npm install -g trq` again."
+    );
+    process.exit(1);
+  }
+  const { spawn } = await import("node:child_process");
+  const { createRequire } = await import("node:module");
+  const cliBin = process.env.npm_execpath ?? process.argv[1];
+  const requireFromCli = createRequire(cliBin);
+  let electronBin;
+  try {
+    electronBin = requireFromCli("electron");
+  } catch (err) {
+    console.error(
+      `Error: failed to resolve \`electron\`.
+  ${err.message}
+  Try \`npm install -g trq\` (the install should pull electron's binary).`
+    );
+    process.exit(1);
+  }
+  const proc = spawn(electronBin, [appDir, ...args], {
+    stdio: "inherit",
+    env: process.env
+  });
+  proc.on("exit", (code) => process.exit(code ?? 0));
+}
+function setPath(obj, dotted, value) {
+  const parts = dotted.split(".");
+  let cur = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const k = parts[i];
+    if (typeof cur[k] !== "object" || cur[k] === null) cur[k] = {};
+    cur = cur[k];
+  }
+  cur[parts[parts.length - 1]] = value;
+}
+function unsetPath(obj, dotted) {
+  const parts = dotted.split(".");
+  let cur = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const k = parts[i];
+    if (typeof cur[k] !== "object" || cur[k] === null) return;
+    cur = cur[k];
+  }
+  delete cur[parts[parts.length - 1]];
+}
+main().catch((err) => {
+  console.error("\nError:", err.message);
+  process.exit(1);
+});