pi-chrome 0.15.49 → 0.15.53

package/test-suite/unit/cdp-passthrough.test.mjs

@@ -0,0 +1,183 @@
+// Raw CDP passthrough (cdp.call / cdp.targets / chrome_cdp formatting) and the scripting→CDP fallback
+// that keeps page actions working on about:blank automation tabs.
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import vm from "node:vm";
+import { stripTypeScriptTypes } from "node:module";
+import { test } from "node:test";
+
+const workerSource = fs.readFileSync(new URL("../../extensions/chrome-profile-bridge/browser-extension/service_worker.js", import.meta.url), "utf8");
+const indexSource = fs.readFileSync(new URL("../../extensions/chrome-profile-bridge/index.ts", import.meta.url), "utf8");
+const ABOUT_BLANK_DENIED = 'Cannot access contents of url "about:blank". Extension manifest must request permission to access this host.';
+
+function harness({ targets = [], respond } = {}) {
+  const calls = [], attached = [], hung = [];
+  const listener = { addListener() {}, removeListener() {} };
+  const page = vm.createContext({ location: { href: "about:blank" } });
+  page.window = page;
+  page.globalThis = page;
+  const chrome = {
+    runtime: { id: "test", getManifest: () => ({ version: "0.0.1" }), getURL: (f) => `chrome-extension://test/${f}`, onInstalled: listener, onStartup: listener, lastError: null },
+    alarms: { create() {}, onAlarm: listener }, action: { onClicked: listener }, webNavigation: { onCommitted: listener },
+    debugger: {
+      onDetach: listener,
+      getTargets: (cb) => cb(targets),
+      attach: async () => {},
+      // Real Chrome fails in-flight commands with "Detached while handling command" on detach.
+      detach: async () => {
+        for (const cb of hung.splice(0)) {
+          chrome.runtime.lastError = { message: "Detached while handling command." };
+          cb(undefined);
+          chrome.runtime.lastError = null;
+        }
+      },
+      sendCommand: (debuggee, method, params, cb) => {
+        calls.push({ method, params: JSON.parse(JSON.stringify(params)) });
+        const reply = respond ? respond(method, params) : undefined;
+        if (reply === "never") { hung.push(cb); return; } // simulate a hung CDP command
+        Promise.resolve(reply).then((value) => {
+          if (method === "Runtime.evaluate" && value === undefined) {
+            Promise.resolve().then(() => vm.runInContext(params.expression, page)).then(
+              (v) => { const json = JSON.stringify(v); cb({ result: json === undefined ? { type: typeof v } : { value: JSON.parse(json) } }); },
+              (error) => cb({ exceptionDetails: { text: error.message, exception: { description: error.message } } }),
+            );
+            return;
+          }
+          cb(value);
+        });
+      },
+    },
+    scripting: { executeScript: async () => { throw new Error(ABOUT_BLANK_DENIED); } },
+    tabs: { onUpdated: listener, get: async (id) => ({ id, windowId: 1, url: "about:blank", status: "complete" }) },
+  };
+  const sources = new Map();
+  const worker = {
+    chrome, console, AbortController, URL,
+    navigator: { userAgent: "unit-test" },
+    setTimeout, clearTimeout, setInterval: () => 0, clearInterval() {},
+    fetch: async (url) => {
+      const file = String(url).replace("chrome-extension://test/", "");
+      if (!sources.has(file)) return { ok: false, status: 404, text: async () => "" };
+      return { ok: true, status: 200, text: async () => sources.get(file) };
+    },
+  };
+  worker.self = worker;
+  vm.runInNewContext(workerSource, worker);
+  worker.getTabByParams = async (params, opts = {}) => {
+    if (params.targetId === "missing") throw new Error("No Chrome tab with id 999");
+    if (opts.createOwnedTarget === false && params.targetId === undefined) return null;
+    return { id: Number(params.targetId ?? 5), windowId: 1, url: "https://fixture.test/", title: "Fixture" };
+  };
+  worker.bringToFront = async (tab) => tab;
+  const realAttach = worker.attachDebugger;
+  worker.attachDebugger = async (tabId) => { attached.push(tabId); return realAttach(tabId); };
+  return { worker, chrome, calls, attached, page, sources, cdpMethods: () => calls.map((c) => c.method) };
+}
+
+test("cdp.call validates method/params before touching the debugger", async () => {
+  const h = harness();
+  await assert.rejects(h.worker.dispatch("cdp.call", { method: "  " }), /non-empty string "method"/);
+  await assert.rejects(h.worker.dispatch("cdp.call", { method: "Runtime.evaluate", params: [1] }), /must be a plain object/);
+  await assert.rejects(h.worker.dispatch("cdp.call", { method: "Runtime.evaluate", params: "x" }), /must be a plain object/);
+  assert.equal(h.attached.length, 0);
+  assert.equal(h.calls.length, 0);
+});
+
+test("cdp.call sends the exact method and params to the resolved tab and returns the raw result", async () => {
+  const h = harness({ respond: (method) => method === "Network.getCookies" ? { cookies: [{ name: "sid" }] } : {} });
+  const result = await h.worker.dispatch("cdp.call", { targetId: "7", method: " Network.getCookies ", params: { urls: ["https://fixture.test"] } });
+  assert.deepEqual(JSON.parse(JSON.stringify(result)), { cookies: [{ name: "sid" }] });
+  assert.deepEqual(h.attached, [7]);
+  assert.deepEqual(h.calls.at(-1), { method: "Network.getCookies", params: { urls: ["https://fixture.test"] } });
+});
+
+test("background mode blocks focus-stealing raw CDP methods; foreground allows them", async () => {
+  const h = harness();
+  for (const method of ["Page.bringToFront", "Target.activateTarget"]) {
+    await assert.rejects(h.worker.dispatch("cdp.call", { method, background: true, foreground: false }), /blocked by background mode/);
+  }
+  assert.equal(h.calls.length, 0);
+  await h.worker.dispatch("cdp.call", { method: "Page.bringToFront", background: false, foreground: true });
+  assert.equal(h.cdpMethods().at(-1), "Page.bringToFront");
+});
+
+test("cdp.call honours timeoutMs and detaches a hung session", async () => {
+  const h = harness({ respond: (method) => method === "Debugger.pause" ? "never" : undefined });
+  const started = Date.now();
+  await assert.rejects(h.worker.dispatch("cdp.call", { method: "Debugger.pause", timeoutMs: 60 }), /CDP Debugger\.pause timed out after 60ms/);
+  assert.ok(Date.now() - started < 2_000, "custom deadline used instead of a longer default");
+  assert.equal(h.cdpMethods().filter((m) => m === "Debugger.pause").length, 1, "a timed-out command is not re-sent after the cleanup detach");
+  assert.equal(h.worker.cdpCallTimeoutMs({}), 5_000);
+  assert.equal(h.worker.cdpCallTimeoutMs({ timeoutMs: 999_999 }), 120_000);
+});
+
+test("cdp.targets lists only the resolved tab's targets, never creates a target, and surfaces explicit misses", async () => {
+  const h = harness({ targets: [
+    { id: "a", tabId: 5, type: "page", url: "https://fixture.test/", attached: true },
+    { id: "b", tabId: 5, type: "other", url: "chrome-extension://pw/overlay.html", attached: false, extensionId: "pw" },
+    { id: "c", tabId: 9, type: "page", url: "https://private.example/secret", attached: false },
+  ] });
+  const listed = await h.worker.dispatch("cdp.targets", { targetId: "5" });
+  assert.deepEqual(listed.targets.map((t) => t.id), ["a", "b"]);
+  assert.equal(listed.otherTabTargetCount, 1);
+  assert.ok(!JSON.stringify(listed).includes("private.example"), "other tabs' URLs are not echoed");
+  const none = await h.worker.dispatch("cdp.targets", {});
+  assert.equal(none.tab, null);
+  assert.equal(none.targets.length, 0);
+  await assert.rejects(h.worker.dispatch("cdp.targets", { targetId: "missing" }), /No Chrome tab with id/);
+  assert.equal(h.attached.length, 0, "diagnostics never attach the debugger");
+});
+
+test("scripting denied on about:blank falls back to CDP for func and packaged-file injection", async () => {
+  const h = harness();
+  h.sources.set("snapshot_injected.js", "globalThis.__piChromeSnapshotPage = async (max, _c, _r, _n, mode) => ({ url: location.href, max, mode });");
+  const snapshot = await h.worker.dispatch("page.snapshot", { targetId: "5", maxElements: 12, mode: "forms" });
+  assert.deepEqual(JSON.parse(JSON.stringify(snapshot)), { url: "about:blank", max: 12, mode: "forms" });
+  assert.ok(h.cdpMethods().filter((m) => m === "Runtime.evaluate").length >= 2, "file and func both ran through Runtime.evaluate");
+
+  const clicked = await h.worker.resolveTargetInTab(5, { x: 10, y: 20 });
+  assert.equal(clicked.found, true, "input target resolution also survives denied scripting");
+});
+
+test("non-permission scripting failures are not masked by the CDP fallback", async () => {
+  const h = harness();
+  h.chrome.scripting.executeScript = async () => { throw new Error("Frame with ID 0 was removed."); };
+  await assert.rejects(h.worker.executeScriptWithFallback({ target: { tabId: 5 }, func: () => 1 }, "x"), /Frame with ID 0 was removed/);
+  assert.equal(h.calls.length, 0);
+  assert.equal(h.worker.isScriptingAccessDenied(new Error(ABOUT_BLANK_DENIED)), true);
+});
+
+test("CDP fallback reports page exceptions with the call-site label", async () => {
+  const h = harness();
+  await assert.rejects(
+    h.worker.executeScriptWithFallback({ target: { tabId: 5 }, func: () => { throw new Error("boom in page"); }, args: [] }, "probe page"),
+    /probe page: .*boom in page/,
+  );
+});
+
+// ---- Pi-side formatting for chrome_cdp results ----
+function section(start, end) {
+  const from = indexSource.indexOf(start);
+  const to = indexSource.indexOf(end, from);
+  assert.ok(from >= 0 && to > from, `Missing source section: ${start}`);
+  return indexSource.slice(from, to);
+}
+const formatCdpResult = vm.runInNewContext(`${stripTypeScriptTypes(section("const CDP_OVERSIZE_JSON_CHARS", "\nfunction extensionRoot"))}; formatCdpResult`, {
+  safeJson: (v) => JSON.stringify(v, null, 2),
+  truncateText: (s) => (s.length > 30_000 ? `${s.slice(0, 30_000)}[truncated]` : s),
+});
+
+test("chrome_cdp never returns screenshot/binary payloads or oversized details verbatim", () => {
+  const data = "A".repeat(4000) + "==";
+  const shot = formatCdpResult("Page.captureScreenshot", { data });
+  assert.ok(!shot.content[0].text.includes("AAAA"));
+  assert.match(shot.content[0].text, /~2999 bytes/);
+  assert.equal(shot.details.value.omitted, "data-field");
+
+  const huge = formatCdpResult("DOM.getOuterHTML", { outerHTML: "x".repeat(300_000) });
+  assert.equal(huge.details.value.omitted, "oversized-result");
+  assert.ok(huge.content[0].text.length < 31_000);
+
+  const small = formatCdpResult("Runtime.evaluate", { result: { type: "number", value: 2 } });
+  assert.deepEqual(small.details.value, { result: { type: "number", value: 2 } });
+});

package/test-suite/unit/chrome-command.test.mjs

@@ -0,0 +1,163 @@
+// Exercise the shipped /chrome command registration and handlers without opening Chrome or a bridge.
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import vm from "node:vm";
+import { stripTypeScriptTypes } from "node:module";
+import { test } from "node:test";
+
+const source = fs.readFileSync(new URL("../../extensions/chrome-profile-bridge/index.ts", import.meta.url), "utf8");
+const { version } = JSON.parse(fs.readFileSync(new URL("../../package.json", import.meta.url), "utf8"));
+const now = 1_000_000;
+function section(start, end) {
+  const from = source.indexOf(start);
+  const to = source.indexOf(end, from);
+  assert.ok(from >= 0 && to > from, `Missing source section: ${start}`);
+  return source.slice(from, to);
+}
+const commandSource = stripTypeScriptTypes([
+  section("const authSummary =", "\n\tconst chromeControlAuthorized ="),
+  section("// Shared handlers,", "\n\tfunction registerChromeTools("),
+].join("\n"));
+
+function healthyResponse(action) {
+  switch (action) {
+    case "tab.version": return { extensionVersion: version };
+    case "page.evaluate": return 2;
+    case "page.probe": return { arithmetic: 2, location: "https://fixture.test/", webdriver: false };
+    default: throw new Error(`Unexpected bridge action: ${action}`);
+  }
+}
+
+function harness({ until, background = true, mode = "server", choices = [], send = healthyResponse } = {}) {
+  const calls = [], notices = [], menus = [];
+  let command;
+  const ctx = {
+    ui: {
+      notify: (...args) => notices.push(args),
+      async select(title, items) {
+        menus.push({ title, items: Array.from(items) });
+        return choices[menus.length - 1];
+      },
+    },
+  };
+  const sandbox = {
+    Date: { now: () => now }, PI_CHROME_VERSION: version,
+    chromeAuthorizedUntil: until, backgroundEnabled: background,
+    hostnameOf: (url) => new URL(url).hostname,
+    bridge: {
+      status: () => ({ mode }),
+      async send(action, params, timeout) {
+        calls.push({ action, params: JSON.parse(JSON.stringify(params)), timeout });
+        return send(action, params, timeout);
+      },
+    },
+    pi: { registerCommand(name, definition) { assert.equal(name, "chrome"); command = definition; } },
+  };
+  vm.runInNewContext(commandSource, sandbox);
+  return { command, calls, notices, menus, sandbox, run: (args = "") => command.handler(args, ctx) };
+}
+
+test("command help and root completion omit status; nested background status remains available", () => {
+  const h = harness();
+  assert.doesNotMatch(h.command.description, /\/chrome status\b/);
+  assert.match(h.command.description, /\/chrome doctor/);
+  assert.deepEqual(Array.from(h.command.getArgumentCompletions(""), (item) => item.value), [
+    "authorize", "revoke", "doctor", "onboard", "background",
+  ]);
+  assert.equal(h.command.getArgumentCompletions("sta"), null);
+  assert.equal(h.command.getArgumentCompletions("doctor")[0].value, "doctor");
+  assert.equal(h.command.getArgumentCompletions("background st")[0].value, "background status");
+  assert.equal(h.command.getArgumentCompletions("authorize 15")[0].value, "authorize 15m");
+});
+
+test("removed status command returns a warning without probing Chrome", async () => {
+  const h = harness();
+  await h.run("status");
+  assert.equal(h.calls.length, 0);
+  assert.equal(h.notices.length, 1);
+  assert.match(h.notices[0][0], /Unknown subcommand 'status'/);
+  assert.doesNotMatch(h.notices[0][0], /\| status \|/);
+  assert.equal(h.notices[0][1], "warning");
+});
+
+test("bare chrome shows loading immediately, then a lightweight dashboard without page probes", async () => {
+  let finish;
+  const h = harness({ send: () => new Promise((resolve) => { finish = resolve; }) });
+  const done = h.run();
+  assert.deepEqual(h.notices, [["Checking Chrome connection…", "info"]]);
+  assert.equal(h.menus.length, 0);
+  assert.deepEqual(h.calls, [{ action: "tab.version", params: {}, timeout: 5_000 }]);
+  finish({ extensionVersion: version });
+  await done;
+  assert.match(h.menus[0].title, /Chrome connected.*auth: locked.*background: on \(hard\)/);
+  assert.ok(h.menus[0].items.includes("Doctor / troubleshoot"));
+  assert.ok(!h.menus[0].items.some((item) => /status/i.test(item)));
+  assert.equal(h.calls.length, 1);
+});
+
+test("dashboard retains authorization/background state when Chrome is offline or outdated", async () => {
+  for (const [send, expected] of [
+    [() => { throw new Error("offline"); }, /Chrome not responding/],
+    [() => ({ extensionVersion: "0.0.0" }), /Chrome extension v0\.0\.0.*reload extension/],
+  ]) {
+    const h = harness({ until: "indefinite", send });
+    await h.run("background off");
+    await h.run("background status");
+    assert.match(h.notices.at(-1)[0], /background is off/);
+    await h.run();
+    assert.match(h.menus[0].title, expected);
+    assert.match(h.menus[0].title, /auth: authorized indefinitely.*background: off/);
+    assert.deepEqual(h.calls, [{ action: "tab.version", params: {}, timeout: 5_000 }]);
+  }
+});
+
+test("Doctor includes locked, timed, indefinite, and expired authorization plus background state", async () => {
+  for (const [until, expected] of [
+    [undefined, "locked"], [now + 15 * 60_000, "authorized for ~15m"],
+    ["indefinite", "authorized indefinitely"], [now, "locked"],
+  ]) {
+    for (const background of [true, false]) {
+      const h = harness({ until, background });
+      await h.run("doctor");
+      assert.equal(h.notices[0][0], "Checking pi-chrome…");
+      const report = h.notices.at(-1)[0];
+      assert.ok(report.includes(`pi-chrome v${version}`));
+      assert.ok(report.includes(`Authorization: ${expected}`));
+      assert.ok(report.includes(`Background: ${background ? "on (hard)" : "off"}`));
+      assert.match(report, /Chrome is connected/);
+      assert.match(report, /can run code/);
+      assert.match(report, /fixture\.test/);
+      assert.deepEqual(h.calls.map(({ action, timeout }) => [action, timeout]), [
+        ["tab.version", 35_000], ["page.evaluate", 10_000], ["page.probe", 10_000],
+      ]);
+      assert.ok(h.calls.filter((call) => call.action.startsWith("page.")).every((call) => call.params.foreground === false));
+      assert.equal(h.sandbox.chromeAuthorizedUntil, until, "diagnostics do not grant or change authorization");
+      assert.equal(h.sandbox.backgroundEnabled, background);
+    }
+  }
+});
+
+test("Doctor retains local state and repair hints when connection/version checks fail", async () => {
+  for (const [send, expected] of [
+    [() => { throw new Error("offline"); }, /Chrome isn't responding: offline/],
+    [() => ({ extensionVersion: "0.0.0" }), /old version \(0\.0\.0\)/],
+  ]) {
+    const h = harness({ until: "indefinite", background: false, mode: "client", send });
+    await h.run("doctor");
+    const report = h.notices.at(-1)[0];
+    assert.match(report, /Authorization: authorized indefinitely/);
+    assert.match(report, /Background: off/);
+    assert.match(report, /sharing another pi session's connection/);
+    assert.match(report, expected);
+    assert.match(report, /Fix:/);
+    assert.deepEqual(h.calls.map((call) => call.action), ["tab.version"]);
+  }
+});
+
+test("choosing Doctor explicitly from the dashboard runs full diagnostics", async () => {
+  const h = harness({ choices: ["Doctor / troubleshoot"] });
+  await h.run();
+  assert.deepEqual(h.calls.map((call) => call.action), ["tab.version", "tab.version", "page.evaluate", "page.probe"]);
+  assert.match(h.notices.at(-1)[0], /Authorization: locked/);
+  assert.match(h.notices.at(-1)[0], /Background: on \(hard\)/);
+});

package/test-suite/unit/type-evidence.test.mjs

@@ -0,0 +1,208 @@
+// chrome_type before/after evidence, replace=true, navigation-aware includeSnapshot, and tab.new load
+// settling. Chrome and the page are mocked; live caret behavior is covered by challenge 44.
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import vm from "node:vm";
+import { stripTypeScriptTypes } from "node:module";
+import { test } from "node:test";
+
+const workerSource = fs.readFileSync(new URL("../../extensions/chrome-profile-bridge/browser-extension/service_worker.js", import.meta.url), "utf8");
+const indexSource = fs.readFileSync(new URL("../../extensions/chrome-profile-bridge/index.ts", import.meta.url), "utf8");
+const clone = (value) => JSON.parse(JSON.stringify(value));
+
+function makeInput({ value = "", caret = value.length, type = "text", name = "q" } = {}) {
+  return {
+    tagName: "INPUT", type, name, id: name, isConnected: true, isContentEditable: false,
+    value, selectionStart: caret, selectionEnd: caret,
+    getAttribute(attr) { return attr === "type" ? this.type : attr === "name" ? this.name : null; },
+    scrollIntoView() {}, getBoundingClientRect: () => ({ left: 10, top: 10, width: 300, height: 30 }),
+    focus() {},
+  };
+}
+
+function harness(element, { platform = "MacIntel", tabs = {} } = {}) {
+  const calls = [];
+  const listeners = new Set();
+  const page = vm.createContext({
+    document: { activeElement: element, querySelector: (s) => (s === "#q" ? element : null), createRange: () => ({}) },
+    getSelection: () => null,
+    location: { href: "https://fixture.test/" },
+    __PI_CHROME_STATE__: { elements: { "el-1": element } },
+  });
+  page.window = page;
+  const listener = { addListener() {}, removeListener() {} };
+  const chrome = {
+    runtime: { id: "test", getManifest: () => ({ version: "0.0.1" }), onInstalled: listener, onStartup: listener },
+    alarms: { create() {}, onAlarm: listener }, action: { onClicked: listener }, webNavigation: { onCommitted: listener },
+    debugger: { onDetach: listener },
+    scripting: { executeScript: async ({ func, args = [] }) => [{ result: await vm.runInContext(`(${func.toString()})`, page)(...args) }] },
+    tabs: {
+      onUpdated: { addListener: (fn) => listeners.add(fn), removeListener: (fn) => listeners.delete(fn) },
+      get: async (id) => clone(tabs[id] ?? { id, windowId: 1, url: "https://fixture.test/", status: "complete" }),
+    },
+  };
+  const worker = { chrome, console, AbortController, setTimeout, clearTimeout, setInterval: () => 0, navigator: { userAgent: "unit-test", platform }, fetch: async () => { throw new Error("offline"); } };
+  worker.self = worker;
+  vm.runInNewContext(workerSource, worker);
+  worker.sleep = async () => {};
+  worker.getTabByParams = async (params) => clone(tabs[Number(params.targetId ?? 2)] ?? { id: Number(params.targetId ?? 2), windowId: 1, url: "https://fixture.test/", status: "complete" });
+  worker.bringToFront = async (tab) => tab;
+  worker.attachDebugger = async () => {};
+  worker.cdpMoveTo = async () => {};
+  const splice = (text) => {
+    if (typeof element.value !== "string") return;
+    const { value, selectionStart: s, selectionEnd: e } = element;
+    element.value = value.slice(0, s) + text + value.slice(e);
+    element.selectionStart = element.selectionEnd = s + text.length;
+  };
+  worker.cdp = async (_tabId, method, params = {}) => {
+    calls.push({ method, params: clone(params) });
+    if (method === "Input.dispatchKeyEvent") {
+      if ((params.commands || []).includes("selectAll")) { element.selectionStart = 0; element.selectionEnd = element.value.length; }
+      else if (params.type === "keyDown" && params.key === "Delete") {
+        if (element.selectionEnd > element.selectionStart) splice("");
+      } else if (params.type === "keyDown" && params.text && params.key !== "Enter") splice(params.text);
+    }
+    return {};
+  };
+  return { worker, calls, element, listeners, fire: (tabId, info) => { for (const fn of [...listeners]) fn(tabId, info); } };
+}
+
+test("typing into the middle of a prefilled field reports the splice instead of a bare count", async () => {
+  const h = harness(makeInput({ value: "why do flamingos stand", caret: 7 }));
+  const result = await h.worker.dispatch("page.type", { targetId: "2", selector: "#q", text: "cats " });
+  assert.equal(h.element.value, "why do cats flamingos stand");
+  assert.equal(result.valueBefore, "why do flamingos stand");
+  assert.equal(result.valueAfter, "why do cats flamingos stand");
+  assert.equal(result.existingTextLengthBefore, 22);
+  assert.equal(result.insertedAt, "caret-middle");
+  assert.equal(result.replaced, undefined);
+});
+
+test("empty and caret-end targets are classified without warnings", async () => {
+  const empty = harness(makeInput());
+  assert.equal((await empty.worker.dispatch("page.type", { targetId: "2", uid: "el-1", text: "hi" })).insertedAt, "empty");
+  const end = harness(makeInput({ value: "hello" }));
+  const result = await end.worker.dispatch("page.type", { targetId: "2", uid: "el-1", text: "!" });
+  assert.equal(result.insertedAt, "caret-end");
+  assert.equal(result.valueAfter, "hello!");
+});
+
+for (const [platform, modifiers] of [["MacIntel", 4], ["Win32", 2]]) {
+  test(`replace=true selects all with the platform shortcut + selectAll command, then deletes (${platform})`, async () => {
+    const h = harness(makeInput({ value: "old query text", caret: 3 }), { platform });
+    const result = await h.worker.dispatch("page.type", { targetId: "2", selector: "#q", text: "new", replace: true });
+    assert.equal(h.element.value, "new");
+    assert.equal(result.replaced, true);
+    assert.equal(result.insertedAt, "replaced-all");
+    assert.equal(result.valueBefore, "old query text", "before is read prior to select-all/delete");
+    const selectAll = h.calls.find((c) => (c.params.commands || []).includes("selectAll"));
+    assert.equal(selectAll.params.modifiers, modifiers);
+  });
+}
+
+test("sensitive fields never expose contents in type evidence", async () => {
+  const h = harness(makeInput({ value: "hunter2", type: "password", name: "password" }));
+  const result = await h.worker.dispatch("page.type", { targetId: "2", selector: "#q", text: "x" });
+  assert.equal(result.valueRedacted, true);
+  assert.equal(result.valueBefore, undefined);
+  assert.equal(result.valueAfter, undefined);
+  assert.ok(!JSON.stringify(result).includes("hunter2"));
+  assert.equal(result.existingTextLengthBefore, 7);
+});
+
+test("a non-text focus target reports no value evidence rather than a false empty field", async () => {
+  const h = harness({ tagName: "DIV", isConnected: true, isContentEditable: false, scrollIntoView() {}, getBoundingClientRect: () => ({ left: 0, top: 0, width: 10, height: 10 }) });
+  const result = await h.worker.dispatch("page.type", { targetId: "2", selector: "#q", text: "x" });
+  assert.equal(result.valueBefore, undefined);
+  assert.equal(result.insertedAt, undefined);
+});
+
+test("includeSnapshot waits for a navigation the action started and snapshots the new page", async () => {
+  const tabs = { 2: { id: 2, windowId: 1, url: "https://fixture.test/", status: "complete" } };
+  const h = harness(makeInput(), { tabs });
+  h.worker.chromeInputKey = async () => {
+    tabs[2] = { ...tabs[2], url: "https://fixture.test/search?q=x", status: "loading" };
+    setTimeout(() => { tabs[2].status = "complete"; h.fire(2, { status: "complete" }); }, 20);
+    return { input: "chrome", key: "Enter" };
+  };
+  h.worker.snapshotInTab = async (params) => ({ url: tabs[Number(params.targetId)].url, status: tabs[Number(params.targetId)].status });
+  const out = await h.worker.dispatch("page.key", { targetId: "2", key: "Enter", includeSnapshot: true });
+  assert.equal(out.navigation.from, "https://fixture.test/");
+  assert.equal(out.navigation.to, "https://fixture.test/search?q=x");
+  assert.equal(out.navigation.settled, true);
+  assert.deepEqual(clone(out.snapshot), { url: "https://fixture.test/search?q=x", status: "complete" });
+  assert.equal(h.listeners.size, 0, "listener removed");
+});
+
+test("a non-navigating action snapshots immediately; an already-loading page is not waited on", async () => {
+  const tabs = { 2: { id: 2, windowId: 1, url: "https://fixture.test/", status: "complete" } };
+  const h = harness(makeInput(), { tabs });
+  h.worker.chromeInputClick = async () => ({ input: "chrome" });
+  h.worker.snapshotInTab = async () => ({ ok: true });
+  const plain = await h.worker.dispatch("page.click", { targetId: "2", selector: "#q", includeSnapshot: true });
+  assert.equal(plain.navigation, undefined);
+
+  tabs[2].status = "loading"; // e.g. a hanging subresource, same URL
+  const started = Date.now();
+  const busy = await h.worker.dispatch("page.click", { targetId: "2", selector: "#q", includeSnapshot: true });
+  assert.ok(Date.now() - started < 1_000, "no bounded wait for a load the action did not start");
+  assert.equal(busy.navigation.settled, false);
+  assert.equal(busy.navigation.waitedMs < 1_000, true);
+});
+
+test("tab.new reports the settled tab and loadStatus instead of the t=0 loading stub", async () => {
+  const tabs = {};
+  const h = harness(makeInput(), { tabs });
+  h.worker.findGroupRecordByTitle = async () => null;
+  h.worker.trackSessionTab = async () => {};
+  h.worker.groupTab = async (tab) => ({ tab: { id: tab.id, url: tab.url, status: tab.status }, group: { title: "Pi Session: t" } });
+  h.worker.formatTab = async (tab) => ({ id: tab.id, url: tab.url, status: tab.status, title: tab.title });
+  h.worker.chrome.tabs.create = async ({ url }) => {
+    tabs[9] = { id: 9, windowId: 1, url: "", title: "", status: "loading" };
+    setTimeout(() => { tabs[9] = { ...tabs[9], url, title: "Loaded", status: "complete" }; h.fire(9, { status: "complete" }); }, 20);
+    return clone(tabs[9]);
+  };
+  const out = await h.worker.dispatch("tab.new", { url: "https://fixture.test/page", background: true });
+  assert.equal(out.loadStatus, "complete");
+  assert.deepEqual(clone(out.tab), { id: 9, url: "https://fixture.test/page", status: "complete", title: "Loaded" });
+  assert.equal(out.group.title, "Pi Session: t");
+});
+
+// ---- Pi-side text ----
+function section(start, end) {
+  const from = indexSource.indexOf(start);
+  const to = indexSource.indexOf(end, from);
+  assert.ok(from >= 0 && to > from, `Missing source section: ${start}`);
+  return indexSource.slice(from, to);
+}
+const pi = vm.runInNewContext(`${stripTypeScriptTypes(section("function formatIncludedSnapshotText(", "\n// Keep raw CDP"))}; ({ formatIncludedSnapshotText, describeTypeEvidence })`, {
+  formatChromeSnapshot: (s) => `SNAPSHOT ${s.url}`,
+});
+
+test("chrome_type text warns on splices, mentions spliced submits, and redacts secrets", () => {
+  const spliced = pi.describeTypeEvidence({ valueBefore: "abc", valueAfter: "aXbc", insertedAt: "caret-middle" }, 1, true).join("\n");
+  assert.match(spliced, /Field went from "abc" to "aXbc"/);
+  assert.match(spliced, /spliced into the middle/);
+  assert.match(spliced, /submitted the spliced value/);
+  const appended = pi.describeTypeEvidence({ valueBefore: "abc", valueAfter: "abcX", insertedAt: "caret-end" }, 1, false).join("\n");
+  assert.match(appended, /appended to existing content/);
+  assert.doesNotMatch(appended, /⚠/);
+  const secret = pi.describeTypeEvidence({ valueRedacted: true, existingTextLengthBefore: 7, valueLengthAfter: 8, insertedAt: "caret-end" }, 1, false).join("\n");
+  assert.match(secret, /\[redacted\] \(7 → 8 chars/);
+  assert.equal(pi.describeTypeEvidence({ input: "chrome" }, 1, false).length, 0);
+  const lost = pi.describeTypeEvidence({ valueBefore: "abc", valueAfter: "abc", existingTextLengthBefore: 3, valueLengthAfter: 3, insertedAt: "caret-middle" }, 5, true).join("\n");
+  assert.match(lost, /did not change/);
+  assert.doesNotMatch(lost, /spliced/, "an unchanged field is not reported as a splice");
+  const lostSecret = pi.describeTypeEvidence({ valueRedacted: true, existingTextLengthBefore: 3, valueLengthAfter: 3, insertedAt: "caret-end" }, 2, false).join("\n");
+  assert.match(lostSecret, /did not change/);
+});
+
+test("included snapshots state whether a navigation settled", () => {
+  const settled = pi.formatIncludedSnapshotText({ snapshot: { url: "https://b.test/" }, navigation: { from: "https://a.test/", to: "https://b.test/", settled: true, waitedMs: 120 } }, "Pressed Enter.");
+  assert.match(settled, /Navigated https:\/\/a\.test\/ → https:\/\/b\.test\/ \(waited 120ms/);
+  assert.match(settled, /SNAPSHOT https:\/\/b\.test\//);
+  const stale = pi.formatIncludedSnapshotText({ snapshot: { url: "https://a.test/" }, navigation: { from: "https://a.test/", to: "https://b.test/", settled: false, waitedMs: 5000 } }, "Pressed Enter.");
+  assert.match(stale, /⚠ The action started a navigation that had not finished after 5000ms/);
+  assert.equal(pi.formatIncludedSnapshotText({ result: {} }, "Clicked."), "Clicked.");
+});