local-operator-ui 0.39.0 → 0.39.2

package/out/main/index.js

@@ -15004,10 +15004,24 @@ function resolveLauncherWatchPlan(input) {
     };
   }
   if (input.mode !== "headless") {
+    if (input.mode !== "inactive" || input.boundedVisibleProbe !== true) {
+      return {
+        watch: false,
+        launcherPid: null,
+        reason: `window mode ${input.mode} is not launcher-bound: a person can close it`
+      };
+    }
+    if (!Number.isInteger(input.launcherPid) || input.launcherPid <= 1) {
+      return {
+        watch: false,
+        launcherPid: null,
+        reason: "visible probe already detached (no launcher to outlive)"
+      };
+    }
     return {
-      watch: false,
-      launcherPid: null,
-      reason: `window mode ${input.mode} is not launcher-bound: a person can close it`
+      watch: true,
+      launcherPid: input.launcherPid,
+      reason: `visible probe launched by pid ${input.launcherPid}; it is capped and quits when that process goes`
     };
   }
   if (!Number.isInteger(input.launcherPid) || input.launcherPid <= 1) {
@@ -26052,11 +26066,11 @@ class ConsoleHost {
             { rendered: null }
           );
         }
-        const rect = cropToWindow(
+        const rect2 = cropToWindow(
           report.contentRect,
           window.getContentBounds()
         );
-        const png = await this.captureWithRetry(window, rect);
+        const png = await this.captureWithRetry(window, rect2);
         const grid = runtime.emulator.grid;
         return {
           image_base64: png.toString("base64"),
@@ -26092,10 +26106,10 @@ class ConsoleHost {
    * renderer paints antialiased text and a cursor — and the empty-terminal case is the
    * offscreen path's problem too, so this is not a new ceiling.
    */
-  async captureWithRetry(window, rect) {
+  async captureWithRetry(window, rect2) {
     let bytes = 0;
     for (let attempt = 1; attempt <= 2; attempt++) {
-      const image2 = await window.webContents.capturePage(rect);
+      const image2 = await window.webContents.capturePage(rect2);
       const png = framePng(image2);
       bytes = png.length;
       if (hasTerminalContent(image2.toBitmap())) {
@@ -27060,14 +27074,14 @@ function wrapBracketedPaste(bytes) {
   out.set(end, start.length + bytes.length);
   return out;
 }
-function cropToWindow(rect, bounds) {
-  const x = Math.max(Math.floor(rect.x), 0);
-  const y = Math.max(Math.floor(rect.y), 0);
+function cropToWindow(rect2, bounds) {
+  const x = Math.max(Math.floor(rect2.x), 0);
+  const y = Math.max(Math.floor(rect2.y), 0);
   return {
     x,
     y,
-    width: Math.max(Math.min(Math.floor(rect.width), bounds.width - x), 1),
-    height: Math.max(Math.min(Math.floor(rect.height), bounds.height - y), 1)
+    width: Math.max(Math.min(Math.floor(rect2.width), bounds.width - x), 1),
+    height: Math.max(Math.min(Math.floor(rect2.height), bounds.height - y), 1)
   };
 }
 function framePng(image2) {
@@ -27836,12 +27850,12 @@ function contentReportOrThrow(value) {
     throw new Error("A console content report is required.");
   }
   const report = value;
-  const rect = report.contentRect;
-  if (!rect || typeof rect !== "object") {
+  const rect2 = report.contentRect;
+  if (!rect2 || typeof rect2 !== "object") {
     throw new Error("A console content report needs a contentRect.");
   }
   const numbers = ["x", "y", "width", "height"].map((key) => {
-    const raw = rect[key];
+    const raw = rect2[key];
     if (typeof raw !== "number" || !Number.isFinite(raw)) {
       throw new Error(`contentRect.${key} must be a number.`);
     }
@@ -28341,6 +28355,60 @@ async function startConsoleHost(options) {
     };
   }
 }
+const DEV_DRIVER_ENV = "LOCAL_OPERATOR_UI_DEV_DRIVER";
+const DEV_DRIVER_OUT_ENV = "LOCAL_OPERATOR_UI_DEV_DRIVER_OUT";
+const DEV_DRIVER_ARG = "--lo-dev-driver";
+const DEV_DRIVER_CAPTURE = "dev-driver-capture";
+const DEV_DRIVER_FACTS = "dev-driver-facts";
+const DEV_DRIVER_ADDRESS_OVERLAY = "dev-driver-address-overlay";
+const DEV_DRIVER_ADDRESS_OVERLAY_PROJECT = "dev-driver-address-overlay-project";
+const DEV_DRIVER_ADDRESS_OVERLAY_EVENT = "dev-driver-address-overlay-event";
+const TRUTHY = /* @__PURE__ */ new Set(["1", "true"]);
+function readOptIn(env) {
+  const raw = env[DEV_DRIVER_ENV];
+  if (raw === void 0 || raw.trim() === "")
+    return { asked: false, value: null };
+  return { asked: true, value: raw.trim() };
+}
+function resolveDevDriverArming(input) {
+  const off = (problems = []) => ({
+    armed: false,
+    outDir: null,
+    problems
+  });
+  const optIn = readOptIn(input.env);
+  if (!optIn.asked) return off();
+  if (!TRUTHY.has(optIn.value.toLowerCase())) {
+    return off([
+      `${DEV_DRIVER_ENV}=${optIn.value} is not an opt-in (accepted: 1, true); the renderer dev driver stayed off`
+    ]);
+  }
+  if (input.windowMode !== "headless" && input.windowMode !== "inactive") {
+    return off([
+      `the renderer dev driver refused to arm in a "${input.windowMode}" window; it never raises one, so use --window-mode=headless (or inactive)`
+    ]);
+  }
+  const outDir = input.env[DEV_DRIVER_OUT_ENV]?.trim() ?? "";
+  if (outDir === "" || !outDir.startsWith("/")) {
+    return off([
+      `${DEV_DRIVER_ENV} was set but ${DEV_DRIVER_OUT_ENV} is ${outDir === "" ? "missing" : `"${outDir}"`}; an absolute frames directory is required, so the driver did not arm`
+    ]);
+  }
+  return { armed: true, outDir, problems: [] };
+}
+function headlessExerciserAllowed(input) {
+  return input.arming.armed && input.windowMode === "headless";
+}
+function devDriverArgument(outDir) {
+  return `${DEV_DRIVER_ARG}=${outDir}`;
+}
+function describeDevDriverArming(arming) {
+  if (arming.armed) {
+    return `[dev-driver] ARMED; frames are written to ${arming.outDir}`;
+  }
+  if (arming.problems.length === 0) return null;
+  return `[dev-driver] not armed: ${arming.problems.join("; ")}`;
+}
 const WEBAUTHN_GROUP_SUFFIX = ".webauthn";
 const WEBAUTHN_PROMPT_REASON = "use a passkey for $1";
 const WEBAUTHN_CHOOSER_TIMEOUT_MS = 6e4;
@@ -28763,7 +28831,368 @@ function labelOf(account) {
   if (!account) return "an unnamed passkey";
   return account.displayName || account.name || "an unnamed passkey";
 }
+const ADDRESS_LIST_ENV = "LOCAL_OPERATOR_UI_BROWSER_ADDRESS_OVERLAY_S2";
+const ADDRESS_LIST_DOCUMENT = "browser-address-overlay-list.html";
+const ADDRESS_LIST_HEADER_HEIGHT = 28;
+const ADDRESS_LIST_ROW_HEIGHT = 35.5;
+const ADDRESS_LIST_ROWS_MAX = 5;
+const ADDRESS_LIST_MAX_HEIGHT_DIP = 212;
+const ADDRESS_LIST_NOTICE_HEIGHT_DIP = 104;
+const ADDRESS_LIST_ANCHOR_GAP_MAX = 24;
+const ADDRESS_LIST_MAX_PAYLOAD_BYTES = 16 * 1024;
+const ADDRESS_LIST_MAX_TEXT = 512;
+const ADDRESS_LIST_MAX_TITLE = 256;
+const ADDRESS_LIST_MAX_LABEL = 256;
+const ADDRESS_LIST_THEME_FALLBACK = "#1b1f24";
+const DIP_INT32_MAX$1 = 2 ** 31 - 1;
+const NOTICE_KINDS = [
+  "error",
+  "hint",
+  "empty",
+  "no_match"
+];
+const HOSTILE_STRING = /[\p{Cc}\u2028\u2029\u202A-\u202E\u2066-\u2069]/gu;
+const COLOR = /^(#[0-9a-f]{6}|rgb\(\d{1,3}, ?\d{1,3}, ?\d{1,3}\))$/i;
+const PROJECTION_KEYS = /* @__PURE__ */ new Set([
+  "v",
+  "seq",
+  "tabId",
+  "visible",
+  "pageRect",
+  "field",
+  "listTop",
+  "active",
+  "view",
+  "label",
+  "dir",
+  "theme"
+]);
+const RECT_KEYS = ["x", "y", "width", "height"];
+const THEME_KEYS = [
+  "elevated",
+  "ink",
+  "inkMuted",
+  "accent",
+  "accentWash",
+  "rowHover",
+  "hairline",
+  "control"
+];
+function isRecord$1(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOnlyKeys(value, allowed) {
+  const set2 = allowed instanceof Set ? allowed : new Set(allowed);
+  for (const key of Object.keys(value)) if (!set2.has(key)) return false;
+  return true;
+}
+function finite(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function rect(value) {
+  if (!isRecord$1(value)) return null;
+  if (!hasOnlyKeys(value, RECT_KEYS)) return null;
+  const x = finite(value.x);
+  const y = finite(value.y);
+  const width = finite(value.width);
+  const height = finite(value.height);
+  if (x === null || y === null || width === null || height === null)
+    return null;
+  return { x, y, width, height };
+}
+function sanitizeOverlayText(value, cap) {
+  if (typeof value !== "string") return null;
+  const stripped = value.replace(HOSTILE_STRING, "");
+  const points = [...stripped];
+  return points.length > cap ? points.slice(0, cap).join("") : stripped;
+}
+function sanitizeRows(value) {
+  if (!Array.isArray(value)) return null;
+  if (value.length === 0 || value.length > ADDRESS_LIST_ROWS_MAX) return null;
+  const rows = [];
+  for (const entry of value) {
+    if (!isRecord$1(entry) || !hasOnlyKeys(entry, ["text", "title"])) return null;
+    const text = sanitizeOverlayText(entry.text, ADDRESS_LIST_MAX_TEXT);
+    const title = sanitizeOverlayText(entry.title, ADDRESS_LIST_MAX_TITLE);
+    if (text === null || title === null) return null;
+    if (text.length === 0) return null;
+    rows.push({ text, title });
+  }
+  return rows;
+}
+function sanitizeTheme(value) {
+  if (value === void 0) return { theme: null, fact: "absent" };
+  if (!isRecord$1(value) || !hasOnlyKeys(value, THEME_KEYS)) {
+    return { theme: null, fact: "fallback" };
+  }
+  const theme = {};
+  for (const key of THEME_KEYS) {
+    const raw = value[key];
+    if (typeof raw !== "string" || !COLOR.test(raw)) {
+      return { theme: null, fact: "fallback" };
+    }
+    theme[key] = raw;
+  }
+  return { theme, fact: "resolved" };
+}
+function jsonBytes(value) {
+  try {
+    return new TextEncoder().encode(JSON.stringify(value)).length;
+  } catch {
+    return Number.POSITIVE_INFINITY;
+  }
+}
+function sanitizeProjection(raw) {
+  if (jsonBytes(raw) > ADDRESS_LIST_MAX_PAYLOAD_BYTES) {
+    return { ok: false, reason: "payload_too_large" };
+  }
+  if (!isRecord$1(raw)) return { ok: false, reason: "not_an_object" };
+  if (!hasOnlyKeys(raw, PROJECTION_KEYS)) {
+    return { ok: false, reason: "unknown_key" };
+  }
+  if (raw.v !== 1) return { ok: false, reason: "bad_version" };
+  if (!Number.isInteger(raw.seq) || raw.seq < 1) {
+    return { ok: false, reason: "bad_seq" };
+  }
+  if (!Number.isInteger(raw.tabId)) return { ok: false, reason: "bad_tab" };
+  if (typeof raw.visible !== "boolean") {
+    return { ok: false, reason: "bad_visible" };
+  }
+  if (!raw.visible) {
+    return {
+      ok: true,
+      projection: {
+        v: 1,
+        seq: raw.seq,
+        tabId: raw.tabId,
+        visible: false,
+        pageRect: { x: 0, y: 0, width: 0, height: 0 },
+        field: { x: 0, y: 0, width: 0, height: 0 },
+        listTop: 0,
+        active: -1,
+        view: { kind: "notice", notice: "empty", text: "" },
+        label: "",
+        dir: "ltr",
+        theme: null,
+        themeFact: "absent"
+      }
+    };
+  }
+  const pageRect = rect(raw.pageRect);
+  const field = rect(raw.field);
+  if (pageRect === null || field === null) {
+    return { ok: false, reason: "bad_rect" };
+  }
+  const listTop = finite(raw.listTop);
+  if (listTop === null) return { ok: false, reason: "bad_list_top" };
+  if (field.width <= 0 || field.height <= 0) {
+    return { ok: false, reason: "bad_field" };
+  }
+  if (!Number.isInteger(raw.active)) return { ok: false, reason: "bad_active" };
+  const active = raw.active;
+  const viewRaw = raw.view;
+  if (!isRecord$1(viewRaw)) return { ok: false, reason: "bad_view" };
+  let view;
+  if (viewRaw.kind === "rows") {
+    if (!hasOnlyKeys(viewRaw, ["kind", "rows"])) {
+      return { ok: false, reason: "bad_view" };
+    }
+    const rows = sanitizeRows(viewRaw.rows);
+    if (rows === null) return { ok: false, reason: "bad_rows" };
+    view = { kind: "rows", rows };
+  } else if (viewRaw.kind === "notice") {
+    if (!hasOnlyKeys(viewRaw, ["kind", "notice", "text"])) {
+      return { ok: false, reason: "bad_view" };
+    }
+    if (!NOTICE_KINDS.includes(viewRaw.notice)) {
+      return { ok: false, reason: "bad_notice" };
+    }
+    const text = sanitizeOverlayText(viewRaw.text, ADDRESS_LIST_MAX_LABEL);
+    if (text === null) return { ok: false, reason: "bad_notice_text" };
+    view = {
+      kind: "notice",
+      notice: viewRaw.notice,
+      text
+    };
+  } else {
+    return { ok: false, reason: "bad_view" };
+  }
+  if (view.kind === "rows" ? active < -1 || active >= view.rows.length : active !== -1) {
+    return { ok: false, reason: "bad_active" };
+  }
+  const label = sanitizeOverlayText(raw.label, ADDRESS_LIST_MAX_LABEL);
+  if (label === null) return { ok: false, reason: "bad_label" };
+  if (raw.dir !== "ltr" && raw.dir !== "rtl") {
+    return { ok: false, reason: "bad_dir" };
+  }
+  const { theme, fact } = sanitizeTheme(raw.theme);
+  return {
+    ok: true,
+    projection: {
+      v: 1,
+      seq: raw.seq,
+      tabId: raw.tabId,
+      visible: true,
+      pageRect,
+      field,
+      listTop,
+      active,
+      view,
+      label,
+      dir: raw.dir,
+      theme,
+      themeFact: fact
+    }
+  };
+}
+function int32$1(value) {
+  if (!Number.isFinite(value)) return null;
+  const rounded = Math.round(value);
+  return Math.abs(rounded) > DIP_INT32_MAX$1 ? null : rounded;
+}
+function addressListHeightFor(view) {
+  if (view.kind === "notice") return ADDRESS_LIST_NOTICE_HEIGHT_DIP;
+  return Math.ceil(
+    ADDRESS_LIST_HEADER_HEIGHT + 2 + view.rows.length * ADDRESS_LIST_ROW_HEIGHT + 2 + 1
+  );
+}
+function addressListBoundsFor(field, listTop, view, owner) {
+  const fx = int32$1(field.x);
+  const fy = int32$1(field.y);
+  const fw = int32$1(field.width);
+  const fh = int32$1(field.height);
+  const top = int32$1(listTop);
+  const ownerWidth = int32$1(owner.width);
+  const ownerHeight = int32$1(owner.height);
+  if (fx === null || fy === null || fw === null || fh === null || top === null || ownerWidth === null || ownerHeight === null) {
+    return null;
+  }
+  if (fw <= 0 || fh <= 0 || ownerWidth <= 0 || ownerHeight <= 0) return null;
+  const gap = top - (fy + fh);
+  if (gap < 0 || gap > ADDRESS_LIST_ANCHOR_GAP_MAX) return null;
+  const height = addressListHeightFor(view);
+  if (height > ADDRESS_LIST_MAX_HEIGHT_DIP) return null;
+  const left = Math.max(0, fx);
+  const right = Math.min(ownerWidth, fx + fw);
+  const bottom = Math.min(ownerHeight, top + height);
+  if (right <= left) return null;
+  if (bottom - top !== height) return null;
+  return { x: left, y: top, width: right - left, height };
+}
+function addressListRowIndexAt(view, offsetY) {
+  if (view.kind !== "rows") return null;
+  if (!Number.isFinite(offsetY)) return null;
+  const withinRows = offsetY - ADDRESS_LIST_HEADER_HEIGHT - 2;
+  if (withinRows < 0) return null;
+  const index = Math.floor(withinRows / ADDRESS_LIST_ROW_HEIGHT);
+  return index >= 0 && index < view.rows.length ? index : null;
+}
+function measurementValue(value) {
+  if (!isRecord$1(value)) return null;
+  if (!Number.isInteger(value.appliedSeq)) return null;
+  if (!Number.isInteger(value.rowCount)) return null;
+  const headerHeight = finite(value.headerHeight);
+  const viewportHeight = finite(value.viewportHeight);
+  const scrollHeight = finite(value.scrollHeight);
+  if (headerHeight === null || viewportHeight === null || scrollHeight === null)
+    return null;
+  if (!Array.isArray(value.rowRects)) return null;
+  const rowRects = [];
+  for (const entry of value.rowRects) {
+    if (!isRecord$1(entry)) return null;
+    const top = finite(entry.top);
+    const height = finite(entry.height);
+    if (top === null || height === null) return null;
+    rowRects.push({ top, height });
+  }
+  const innerHeight = finite(value.innerHeight);
+  const visualHeight = finite(value.visualHeight);
+  let activeRowRect = null;
+  if (value.activeRowRect !== null && value.activeRowRect !== void 0) {
+    if (!isRecord$1(value.activeRowRect)) return null;
+    const top = finite(value.activeRowRect.top);
+    const height = finite(value.activeRowRect.height);
+    if (top === null || height === null) return null;
+    activeRowRect = { top, height };
+  }
+  const appliedSeq = value.appliedSeq;
+  const rowCount = value.rowCount;
+  if (typeof appliedSeq !== "number" || typeof rowCount !== "number")
+    return null;
+  return {
+    appliedSeq,
+    rowCount,
+    headerHeight,
+    rowRects,
+    viewportHeight,
+    scrollHeight,
+    ...innerHeight === null ? {} : { innerHeight },
+    ...visualHeight === null ? {} : { visualHeight },
+    activeRowRect
+  };
+}
+function addressListMeasurementProblem(raw, projection, requestedHeight) {
+  const measurement = measurementValue(raw);
+  if (measurement === null) return "measure_invalid";
+  if (measurement.appliedSeq !== projection.seq) return "measure_stale";
+  const reported = measurement.visualHeight ?? measurement.innerHeight;
+  if (reported !== void 0 && Math.abs(reported - requestedHeight) > 1) {
+    return "measure_viewport";
+  }
+  if (projection.view.kind !== "rows") {
+    return measurement.rowCount === 0 ? null : "measure_extra_rows";
+  }
+  const rows = projection.view.rows;
+  if (measurement.rowCount !== rows.length) return "measure_row_count";
+  if (measurement.rowRects.length !== rows.length) return "measure_row_rects";
+  if (Math.abs(measurement.headerHeight - ADDRESS_LIST_HEADER_HEIGHT) > 0.5) {
+    return "measure_header";
+  }
+  for (const row of measurement.rowRects) {
+    if (Math.abs(row.height - ADDRESS_LIST_ROW_HEIGHT) > 0.5) {
+      return "measure_row_height";
+    }
+  }
+  if (measurement.scrollHeight > measurement.viewportHeight + 1) {
+    return "measure_scroll";
+  }
+  if (projection.active >= 0) {
+    if (measurement.activeRowRect === null) return "measure_active_missing";
+    const paintBox = measurement.visualHeight ?? measurement.innerHeight ?? requestedHeight;
+    const { top, height } = measurement.activeRowRect;
+    const documentBottom = measurement.headerHeight + top + height;
+    if (top < -0.5 || documentBottom > paintBox + 0.5) {
+      return "active_not_visible";
+    }
+  }
+  return null;
+}
+function addressListViewModel(projection) {
+  const fallback = {
+    elevated: ADDRESS_LIST_THEME_FALLBACK,
+    ink: "#e6e8ea",
+    inkMuted: "#9aa0a6",
+    accent: "#5b9dd9",
+    accentWash: "#23303d",
+    rowHover: "#24282e",
+    hairline: "#2f343b",
+    control: "#3a4048"
+  };
+  const theme = projection.theme ?? fallback;
+  return {
+    v: 1,
+    seq: projection.seq,
+    dir: projection.dir,
+    label: projection.label,
+    active: projection.active,
+    view: projection.view,
+    height: addressListHeightFor(projection.view),
+    theme
+  };
+}
 const ADDRESS_OVERLAY_S1_ENV = "LOCAL_OPERATOR_UI_BROWSER_ADDRESS_OVERLAY_S1";
+const ADDRESS_OVERLAY_VISIBLE_ENV = "LOCAL_OPERATOR_UI_BROWSER_ADDRESS_OVERLAY_VISIBLE";
+const ADDRESS_OVERLAY_VISIBLE_MAX_MS = 12e4;
 const ADDRESS_OVERLAY_DOCUMENT = "browser-address-overlay.html";
 const ADDRESS_OVERLAY_MAX_HEIGHT_DIP = 160;
 const ADDRESS_OVERLAY_READY_TIMEOUT_MS = 5e3;
@@ -28771,25 +29200,132 @@ const DIP_INT32_MAX = 2 ** 31 - 1;
 const INDEX_DOCUMENT_SUFFIX$2 = /\/?index\.html(\?.*)?$/;
 const TRAILING_SLASH$1 = /\/$/;
 function addressOverlayDocumentUrlFor(rendererUrl) {
-  return INDEX_DOCUMENT_SUFFIX$2.test(rendererUrl) ? rendererUrl.replace(INDEX_DOCUMENT_SUFFIX$2, `/${ADDRESS_OVERLAY_DOCUMENT}`) : `${rendererUrl.replace(TRAILING_SLASH$1, "")}/${ADDRESS_OVERLAY_DOCUMENT}`;
+  return documentUrlFor(rendererUrl, ADDRESS_OVERLAY_DOCUMENT);
+}
+function addressListDocumentUrlFor(rendererUrl) {
+  return documentUrlFor(rendererUrl, ADDRESS_LIST_DOCUMENT);
+}
+function documentUrlFor(rendererUrl, document) {
+  return INDEX_DOCUMENT_SUFFIX$2.test(rendererUrl) ? rendererUrl.replace(INDEX_DOCUMENT_SUFFIX$2, `/${document}`) : `${rendererUrl.replace(TRAILING_SLASH$1, "")}/${document}`;
 }
 function resolveAddressOverlayGate(input) {
   const raw = input.env[ADDRESS_OVERLAY_S1_ENV];
+  const listRaw = input.env[ADDRESS_LIST_ENV];
+  const visibleRaw = input.env[ADDRESS_OVERLAY_VISIBLE_ENV];
+  const listAsked = listRaw !== void 0 && listRaw.trim() !== "";
+  const visibleAsked = visibleRaw !== void 0 && visibleRaw.trim() !== "";
   if (raw === void 0 || raw.trim() === "") {
-    return { asked: false, enabled: false, reason: null };
+    if (visibleAsked) {
+      return {
+        asked: true,
+        enabled: false,
+        list: false,
+        visible: false,
+        reason: `${ADDRESS_OVERLAY_VISIBLE_ENV} needs ${ADDRESS_OVERLAY_S1_ENV}=1 and ${ADDRESS_LIST_ENV}=1: the visible probe is an increment on S1's child and S2's mirror, not a third arm`
+      };
+    }
+    return listAsked ? {
+      asked: true,
+      enabled: false,
+      list: false,
+      visible: false,
+      reason: `${ADDRESS_LIST_ENV} needs ${ADDRESS_OVERLAY_S1_ENV}=1: S2's list is a mirror inside S1's child, not a second child`
+    } : {
+      asked: false,
+      enabled: false,
+      list: false,
+      visible: false,
+      reason: null
+    };
   }
   const asked = true;
   if (raw.trim() !== "1") {
     return {
       asked,
       enabled: false,
+      list: false,
+      visible: false,
       reason: `${ADDRESS_OVERLAY_S1_ENV}=${raw.trim()} is not an opt-in (accepted: 1); the address overlay stayed off`
     };
   }
+  if (listAsked && listRaw.trim() !== "1") {
+    return {
+      asked,
+      enabled: false,
+      list: false,
+      visible: false,
+      reason: `${ADDRESS_LIST_ENV}=${listRaw.trim()} is not an opt-in (accepted: 1); the address overlay stayed off`
+    };
+  }
+  if (visibleAsked) {
+    if (visibleRaw.trim() !== "1") {
+      return {
+        asked,
+        enabled: false,
+        list: false,
+        visible: false,
+        reason: `${ADDRESS_OVERLAY_VISIBLE_ENV}=${visibleRaw.trim()} is not an opt-in (accepted: 1); the address overlay stayed off`
+      };
+    }
+    if (!listAsked) {
+      return {
+        asked,
+        enabled: false,
+        list: false,
+        visible: false,
+        reason: `${ADDRESS_OVERLAY_VISIBLE_ENV} needs ${ADDRESS_LIST_ENV}=1: S3's visible probe shows S2's mirror, never a bare S1 child`
+      };
+    }
+    if (input.windowMode === "headless") {
+      return {
+        asked,
+        enabled: false,
+        list: false,
+        visible: false,
+        reason: `${ADDRESS_OVERLAY_VISIBLE_ENV} refused in a "headless" window: a headless run labelled visible would misattribute its evidence; use --window-mode=inactive`
+      };
+    }
+    if (input.windowMode !== "inactive") {
+      return {
+        asked,
+        enabled: false,
+        list: false,
+        visible: false,
+        reason: `${ADDRESS_OVERLAY_VISIBLE_ENV} refused in a "${input.windowMode}" window: a visible probe never runs in the product's own mode; use --window-mode=inactive`
+      };
+    }
+    if (!input.devDriverArmed) {
+      return {
+        asked,
+        enabled: false,
+        list: false,
+        visible: false,
+        reason: "the visible address overlay needs the armed renderer dev driver; it has no product path"
+      };
+    }
+    if (input.packaged === true) {
+      return {
+        asked,
+        enabled: false,
+        list: false,
+        visible: false,
+        reason: `${ADDRESS_OVERLAY_VISIBLE_ENV} refused in a packaged build: S3 is an unpackaged probe, never product surface`
+      };
+    }
+    return {
+      asked,
+      enabled: true,
+      list: true,
+      visible: true,
+      reason: null
+    };
+  }
   if (!input.devDriverArmed) {
     return {
       asked,
       enabled: false,
+      list: false,
+      visible: false,
       reason: "the address overlay needs the armed renderer dev driver; it has no user-facing trigger in S1"
     };
   }
@@ -28797,10 +29333,18 @@ function resolveAddressOverlayGate(input) {
     return {
       asked,
       enabled: false,
+      list: false,
+      visible: false,
       reason: `the address overlay refused to arm in a "${input.windowMode}" window; S1 has no user-facing path, so use --window-mode=headless`
     };
   }
-  return { asked, enabled: true, reason: null };
+  return {
+    asked,
+    enabled: true,
+    list: listAsked,
+    visible: false,
+    reason: null
+  };
 }
 function int32(value) {
   if (typeof value !== "number" || !Number.isFinite(value)) return null;
@@ -28844,11 +29388,15 @@ function copyLayout(snapshot2) {
   };
 }
 function layoutKeyOf(snapshot2) {
-  const rect = snapshot2.contentRect;
-  return `${snapshot2.activeTabId}:${snapshot2.presented ? 1 : 0}:${rect ? `${rect.x},${rect.y},${rect.width},${rect.height}` : "null"}`;
+  const rect2 = snapshot2.contentRect;
+  return `${snapshot2.activeTabId}:${snapshot2.presented ? 1 : 0}:${rect2 ? `${rect2.x},${rect2.y},${rect2.width},${rect2.height}` : "null"}`;
+}
+function sameRect(a, b) {
+  if (b === null) return false;
+  return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
 }
 const OVERLAY_BACKGROUND = "#1b1f24";
-function createHardenedView() {
+function createHardenedView(options) {
   const partition = `address-overlay-${node_crypto.randomUUID()}`;
   const childSession = electron.session.fromPartition(partition);
   childSession.setPermissionRequestHandler(
@@ -28868,10 +29416,15 @@ function createHardenedView() {
       nodeIntegration: false,
       webSecurity: true,
       allowRunningInsecureContent: false,
-      // No `preload`, and no script in the document: nothing can ask for a
-      // bridge, and the renderer never runs JavaScript even if the document
-      // changes by accident.
-      javascript: false
+      // No `preload`, and no app imports in either document. The flag is the
+      // S1/S2 split: false for the inert document, true for the mirror list.
+      javascript: options.javascript,
+      // The mirror is a tiny document that must stay frame-accurate while the
+      // owner window is hidden, unfocused or occluded (headless probe, a
+      // background app window). Chromium otherwise throttles its frame loop,
+      // and a native resize can sit unapplied for ~1 s — the exact interval
+      // `measure_viewport` is there to catch. S1 keeps the default.
+      ...options.javascript ? { backgroundThrottling: false } : {}
     }
   });
   view.webContents.setWindowOpenHandler(() => ({ action: "deny" }));
@@ -28882,6 +29435,8 @@ class AddressOverlayController {
   window;
   documentUrl;
   createView;
+  javascript;
+  onEvent;
   readinessTimeoutMs;
   log;
   now;
@@ -28909,10 +29464,42 @@ class AddressOverlayController {
   disposed;
   ownerListeners;
   childListeners;
+  // ---- S2 mirror state ----------------------------------------------------
+  lastSeq;
+  shownSeq;
+  lastProjection;
+  /** The rectangle last applied for a projection. `onLayout`'s unchanged-key
+   * re-assert uses THIS, never the S1 top-strip rule: an S2 child sits at the
+   * dock, and re-raising it with the S1 rectangle would move the list. */
+  lastAppliedBounds;
+  lastMeasurement;
+  themeFact;
+  applyCount;
+  commitsEmitted;
+  commitsDropped;
+  hideCounts;
+  keysBlocked;
+  mouseDowns;
+  mouseUps;
+  mouseMoves;
+  mouseDownRow;
+  contextMenuBlocked;
+  // ---- S3 focus facts -----------------------------------------------------
+  /** Counted only for the scripted (S2/S3) child, so S1's listener set stays
+   * exactly what it was; see `wireChild`'s S2 policy comment. */
+  childFocusEvents;
+  childBlurEvents;
+  /** The launch gate's `visible` fact, copied in so `facts()` can report it
+   * without re-deriving the gate (which it must never do: one pure decision). */
+  visibleMode;
+  lastRejected;
+  projectQueue;
   constructor(deps) {
     this.window = deps.window;
     this.documentUrl = deps.documentUrl;
-    this.createView = deps.createView ?? createHardenedView;
+    this.createView = deps.createView ?? (() => createHardenedView({ javascript: deps.javascript === true }));
+    this.javascript = deps.javascript === true;
+    this.onEvent = deps.onEvent ?? null;
     this.readinessTimeoutMs = deps.readinessTimeoutMs ?? ADDRESS_OVERLAY_READY_TIMEOUT_MS;
     this.log = deps.log ?? (() => {
     });
@@ -28946,6 +29533,27 @@ class AddressOverlayController {
     this.disposed = false;
     this.ownerListeners = [];
     this.childListeners = [];
+    this.lastSeq = 0;
+    this.shownSeq = -1;
+    this.lastProjection = null;
+    this.lastAppliedBounds = null;
+    this.lastMeasurement = null;
+    this.themeFact = "absent";
+    this.applyCount = 0;
+    this.commitsEmitted = 0;
+    this.commitsDropped = /* @__PURE__ */ new Map();
+    this.hideCounts = /* @__PURE__ */ new Map();
+    this.keysBlocked = 0;
+    this.mouseDowns = 0;
+    this.mouseUps = 0;
+    this.mouseMoves = 0;
+    this.mouseDownRow = null;
+    this.contextMenuBlocked = 0;
+    this.childFocusEvents = 0;
+    this.childBlurEvents = 0;
+    this.visibleMode = deps.visible === true;
+    this.lastRejected = null;
+    this.projectQueue = Promise.resolve();
     this.attachOwnerListeners();
   }
   // ---- observer hooks ------------------------------------------------------
@@ -28975,7 +29583,7 @@ class AddressOverlayController {
     if (this.state !== "shown") return;
     const view = this.view;
     if (!view || this.viewUsable(view) === false) return;
-    const bounds = overlayBoundsFor(next.contentRect, this.ownerSize());
+    const bounds = this.lastProjection !== null ? this.lastAppliedBounds : overlayBoundsFor(next.contentRect, this.ownerSize());
     if (bounds === null || !next.presented) {
       this.hide("layout_invalid");
       return;
@@ -29022,6 +29630,10 @@ class AddressOverlayController {
     this.generation += 1;
     this.settleReady(false);
     this.hiddenReason = reason;
+    this.hideCounts.set(reason, (this.hideCounts.get(reason) ?? 0) + 1);
+    this.shownSeq = -1;
+    this.mouseDownRow = null;
+    this.lastMeasurement = null;
     const view = this.view;
     if (view && this.viewUsable(view)) {
       try {
@@ -29034,6 +29646,14 @@ class AddressOverlayController {
     }
     this.log(`[browser] address overlay hidden: ${reason}`);
   }
+  /** `WebContents.isFocused()` behind a guard: a disposed view throws. */
+  childIsFocused(view) {
+    try {
+      return view.webContents.isFocused();
+    } catch {
+      return false;
+    }
+  }
   /** Facts only: identifiers, geometry and counters. No page content. */
   facts() {
     const view = this.view;
@@ -29056,7 +29676,10 @@ class AddressOverlayController {
         visible,
         bounds,
         order,
-        childCount
+        childCount,
+        focusEvents: this.childFocusEvents,
+        blurEvents: this.childBlurEvents,
+        isFocused: this.childIsFocused(view)
       };
     }
     let ownerDestroyed = true;
@@ -29067,6 +29690,18 @@ class AddressOverlayController {
     } catch {
       ownerDestroyed = true;
     }
+    let ownerWindowFocused = false;
+    try {
+      ownerWindowFocused = !ownerDestroyed && this.window.isFocused();
+    } catch {
+      ownerWindowFocused = false;
+    }
+    let ownerFocusedContentsId = null;
+    try {
+      ownerFocusedContentsId = electron.webContents.getFocusedWebContents()?.id ?? null;
+    } catch {
+      ownerFocusedContentsId = null;
+    }
     return {
       documentUrl: this.documentUrl,
       state: this.state,
@@ -29094,10 +29729,36 @@ class AddressOverlayController {
       },
       pendingShow: this.showInFlight !== null,
       readinessTimer: this.readinessTimer !== null,
+      visibleMode: this.visibleMode,
+      ownerFocusedContentsId,
+      ownerWindowFocused,
+      s2: {
+        list: this.javascript,
+        javascript: this.javascript,
+        lastSeq: this.lastSeq,
+        shownSeq: this.shownSeq,
+        lastRejected: this.lastRejected,
+        theme: this.themeFact,
+        applyCount: this.applyCount,
+        view: this.lastProjection === null ? { kind: "none", rowCount: 0, active: -1 } : {
+          kind: this.lastProjection.view.kind,
+          rowCount: this.lastProjection.view.kind === "rows" ? this.lastProjection.view.rows.length : 0,
+          active: this.lastProjection.active
+        },
+        measured: this.lastMeasurement,
+        commitsEmitted: this.commitsEmitted,
+        commitsDropped: Object.fromEntries(this.commitsDropped),
+        hideCounts: Object.fromEntries(this.hideCounts),
+        keysBlocked: this.keysBlocked,
+        mouseDowns: this.mouseDowns,
+        mouseUps: this.mouseUps,
+        mouseMoves: this.mouseMoves,
+        contextMenuBlocked: this.contextMenuBlocked
+      },
       metrics: this.appMetrics ? this.appMetrics() : null
     };
   }
-  async probe(action) {
+  async probe(action, argument) {
     if (action === "show") {
       await this.showOverlay();
       return this.facts();
@@ -29106,8 +29767,278 @@ class AddressOverlayController {
       this.hide("probe");
       return this.facts();
     }
+    if (action === "click") {
+      this.probeClick(argument);
+      await new Promise((done) => setTimeout(done, 40));
+      return this.facts();
+    }
+    if (action === "measure") {
+      await this.probeMeasure();
+      return this.facts();
+    }
+    if (action === "key") {
+      this.probeKey(argument);
+      await new Promise((done) => setTimeout(done, 20));
+      return this.facts();
+    }
     return this.facts();
   }
+  /**
+   * Apply one renderer projection (S2). Everything arriving here was or will be
+   * revalidated: JSON size, shape, every string, tab/layout freshness, zoom,
+   * anchor geometry and — after the child paints — the child's own measurements.
+   *
+   * Serialized: a per-frame renderer can outpace `executeJavaScript`, and two
+   * overlapping applies would let an older model win. The queue is per
+   * controller, so a burst between frames costs one apply each in arrival order.
+   */
+  project(raw) {
+    const run = () => this.projectOnce(raw);
+    const next = this.projectQueue.then(run, run);
+    this.projectQueue = next.then(
+      () => void 0,
+      () => void 0
+    );
+    return next;
+  }
+  async projectOnce(raw) {
+    const parsed = sanitizeProjection(raw);
+    if (!parsed.ok) {
+      this.drop(parsed.reason);
+      return {
+        accepted: false,
+        shown: false,
+        reason: parsed.reason,
+        bounds: null
+      };
+    }
+    const projection = parsed.projection;
+    this.themeFact = projection.themeFact;
+    if (!projection.visible) {
+      if (projection.seq > this.lastSeq) this.lastSeq = projection.seq;
+      this.hide("projection_hidden");
+      return { accepted: true, shown: false, reason: null, bounds: null };
+    }
+    if (this.disposed) {
+      return this.refuseProjection("disposed");
+    }
+    if (projection.seq < this.lastSeq) {
+      this.drop("stale_seq");
+      return {
+        accepted: false,
+        shown: this.state === "shown",
+        reason: "stale_seq",
+        bounds: null
+      };
+    }
+    if (projection.seq === this.lastSeq && projection.seq === this.shownSeq) {
+      return {
+        accepted: true,
+        shown: this.state === "shown",
+        reason: null,
+        bounds: this.view && this.viewUsable(this.view) ? this.view.getBounds() : null
+      };
+    }
+    if (this.failedReason) return this.refuseProjection("overlay_failed");
+    if (this.ownerUnavailable()) {
+      this.releaseChild("owner_unavailable");
+      return this.refuseProjection("owner_unavailable");
+    }
+    const zoom = this.ownerZoom();
+    if (zoom === null || Math.abs(zoom - 1) > 1e-3) {
+      return this.refuseProjection("zoomed");
+    }
+    const layout = this.layout;
+    if (projection.tabId !== layout.activeTabId) {
+      return this.refuseProjection("stale_tab");
+    }
+    if (!layout.presented || !sameRect(projection.pageRect, layout.contentRect)) {
+      return this.refuseProjection("stale_layout");
+    }
+    const bounds = addressListBoundsFor(
+      projection.field,
+      projection.listTop,
+      projection.view,
+      this.ownerSize()
+    );
+    if (bounds === null) return this.refuseProjection("anchor_inconsistent");
+    this.generation += 1;
+    const generation = this.generation;
+    this.boundTabId = projection.tabId;
+    if (!this.view) {
+      const created = this.createChild(bounds);
+      if (!created) {
+        return this.refuseProjection(
+          this.failedReason ?? "child_create_failed"
+        );
+      }
+    }
+    if (!(this.domReady && this.finished)) {
+      this.state = "loading";
+      const ready = await this.waitForReady();
+      if (!ready)
+        return this.refuseProjection(this.failedReason ?? "invalidated");
+    }
+    if (this.disposed || generation !== this.generation) {
+      return this.refuseProjection("invalidated");
+    }
+    const view = this.view;
+    if (!view || !this.viewUsable(view)) {
+      return this.refuseProjection("child_unavailable");
+    }
+    view.setBounds(bounds);
+    this.raiseChild(view);
+    view.setVisible(true);
+    const model = addressListViewModel(projection);
+    let measured = null;
+    let problem = null;
+    try {
+      for (let attempt = 0; attempt < 8; attempt += 1) {
+        if (attempt % 2 === 1) view.setBounds(bounds);
+        measured = await view.webContents.executeJavaScript(
+          `window.__loAddressOverlay && window.__loAddressOverlay.apply(${JSON.stringify(model)})`,
+          false
+        );
+        problem = addressListMeasurementProblem(
+          measured,
+          projection,
+          bounds.height
+        );
+        if (problem === null) break;
+        if (problem !== "measure_scroll" && problem !== "measure_viewport")
+          break;
+        await new Promise((done) => setTimeout(done, 150));
+      }
+    } catch {
+      return this.refuseProjection("apply_error");
+    }
+    if (problem !== null) return this.refuseProjection(problem, bounds);
+    this.applyCount += 1;
+    this.lastSeq = projection.seq;
+    this.shownSeq = projection.seq;
+    this.lastProjection = projection;
+    this.lastAppliedBounds = bounds;
+    this.lastMeasurement = measured;
+    this.lastRejected = null;
+    this.state = "shown";
+    this.hiddenReason = null;
+    return { accepted: true, shown: true, reason: null, bounds };
+  }
+  refuseProjection(reason, bounds = null) {
+    this.lastRejected = reason;
+    this.drop(reason);
+    this.hide(reason);
+    return { accepted: false, shown: false, reason, bounds };
+  }
+  drop(reason) {
+    this.commitsDropped.set(reason, (this.commitsDropped.get(reason) ?? 0) + 1);
+  }
+  ownerZoom() {
+    try {
+      const zoom = this.window.webContents.getZoomFactor();
+      return typeof zoom === "number" && Number.isFinite(zoom) ? zoom : null;
+    } catch {
+      return null;
+    }
+  }
+  rowAt(y) {
+    if (this.state !== "shown") return null;
+    if (this.lastProjection === null) return null;
+    if (this.shownSeq !== this.lastSeq || this.shownSeq < 1) return null;
+    const projection = this.lastProjection;
+    if (projection.view.kind !== "rows") return null;
+    const index = addressListRowIndexAt(projection.view, y);
+    if (index === null || index >= projection.view.rows.length) return null;
+    return index;
+  }
+  emitCommit(index) {
+    const projection = this.lastProjection;
+    const sink = this.onEvent;
+    if (projection === null || sink === null) {
+      this.drop("no_sink");
+      return;
+    }
+    if (projection.view.kind !== "rows" || index >= projection.view.rows.length) {
+      this.drop("commit_index");
+      return;
+    }
+    this.commitsEmitted += 1;
+    sink({ type: "commit", seq: projection.seq, index });
+    this.log(
+      `[browser] address overlay commit emitted: seq=${projection.seq} index=${index}`
+    );
+  }
+  /**
+   * Probe-only mouse path: `sendInputEvent` into the child's own input pipeline.
+   * This exercises the child and the before-mouse-event observer; it does NOT
+   * exercise macOS NSView hit-testing between sibling views (matrix V3).
+   */
+  probeClick(argument) {
+    const view = this.view;
+    const measurement = this.lastMeasurement;
+    if (!view || !this.viewUsable(view) || !measurement) {
+      throw new Error("address_overlay_click: no applied list to click");
+    }
+    const arg = argument ?? {};
+    const row = arg.row;
+    const upRow = arg.upRow === void 0 ? row : arg.upRow;
+    const rows = measurement.rowRects;
+    if (typeof row !== "number" || !Number.isInteger(row) || !rows[row]) {
+      throw new Error(
+        "address_overlay_click: row must be a rendered row index"
+      );
+    }
+    if (typeof upRow !== "number" || !Number.isInteger(upRow)) {
+      throw new Error("address_overlay_click: upRow must be an integer");
+    }
+    const point = (index) => {
+      const rect2 = rows[index];
+      const fallbackY = ADDRESS_LIST_HEADER_HEIGHT + 2 + (index + 0.5) * ADDRESS_LIST_ROW_HEIGHT;
+      return rect2 ? {
+        x: 40,
+        y: ADDRESS_LIST_HEADER_HEIGHT + 2 + rect2.top + rect2.height / 2
+      } : { x: 40, y: fallbackY };
+    };
+    const receive = (type2, index) => {
+      const { x, y } = point(index);
+      view.webContents.sendInputEvent({
+        type: type2,
+        x: Math.round(x),
+        y: Math.round(y),
+        button: "left",
+        clickCount: 1
+      });
+    };
+    receive("mouseMove", row);
+    receive("mouseDown", row);
+    receive("mouseUp", upRow);
+  }
+  /**
+   * Probe-only key into the child's own input pipeline. It is how the gated
+   * harness proves `before-input-event` swallows keys; CDP-injected keys go
+   * through a different path and were measured NOT to fire it.
+   */
+  probeKey(argument) {
+    const view = this.view;
+    if (!view || !this.viewUsable(view)) {
+      throw new Error("address_overlay_key: no child");
+    }
+    const arg = argument ?? {};
+    const keyCode = typeof arg.keyCode === "string" && arg.keyCode.length > 0 ? arg.keyCode.slice(0, 32) : "A";
+    view.webContents.sendInputEvent({ type: "keyDown", keyCode });
+    view.webContents.sendInputEvent({ type: "keyUp", keyCode });
+  }
+  async probeMeasure() {
+    const view = this.view;
+    if (!view || !this.viewUsable(view)) {
+      throw new Error("address_overlay_measure: no child");
+    }
+    const measured = await view.webContents.executeJavaScript(
+      "window.__loAddressOverlay && window.__loAddressOverlay.measure()",
+      false
+    );
+    this.lastMeasurement = measured;
+  }
   /**
    * Idempotent teardown for the host's stop/rollback/window-close paths.
    * Closing the webContents before detaching is required: removing a
@@ -29319,6 +30250,54 @@ class AddressOverlayController {
       event?.preventDefault?.();
       this.log(`[browser] address overlay refused redirect to ${url}`);
     });
+    if (!this.javascript) return;
+    on(contents, "before-input-event", (...args) => {
+      const event = args[0];
+      event?.preventDefault?.();
+      this.keysBlocked += 1;
+    });
+    on(contents, "context-menu", (...args) => {
+      const event = args[0];
+      event?.preventDefault?.();
+      this.contextMenuBlocked += 1;
+    });
+    on(contents, "focus", () => {
+      this.childFocusEvents += 1;
+    });
+    on(contents, "blur", () => {
+      this.childBlurEvents += 1;
+    });
+    on(contents, "before-mouse-event", (...args) => {
+      const event = args[0];
+      const mouse = args[1];
+      if (!mouse || typeof mouse.x !== "number" || typeof mouse.y !== "number") {
+        return;
+      }
+      if (mouse.type === "mouseMove") {
+        this.mouseMoves += 1;
+        return;
+      }
+      event?.preventDefault?.();
+      if (mouse.type === "mouseDown") {
+        this.mouseDowns += 1;
+        this.mouseDownRow = this.rowAt(mouse.y);
+        return;
+      }
+      if (mouse.type !== "mouseUp") return;
+      this.mouseUps += 1;
+      const row = this.rowAt(mouse.y);
+      const downRow = this.mouseDownRow;
+      this.mouseDownRow = null;
+      if (downRow === null || row === null) {
+        this.drop("mouse_no_row");
+        return;
+      }
+      if (downRow !== row) {
+        this.drop("mouse_mismatch");
+        return;
+      }
+      this.emitCommit(row);
+    });
   }
   /** Terminal for this host lifetime: a broken document must not be retried. */
   failChild(reason) {
@@ -63799,6 +64778,13 @@ class TabRegistry {
   nextTabId = 1;
   activeTabId = null;
   visible = true;
+  /** WHY the view is hidden when it is: the renderer is painting one of the
+   * browser's OWN state pages (start page, load failure), not an overlay that
+   * covers the chrome band. Only shortcut ownership reads this. Presentation
+   * reads `visible` alone, so a state page never makes a native view
+   * "presented"; and every report overwrites it, so a reason cannot outlive the
+   * hide it described. */
+  ownStatePage = false;
   contentRect = null;
   /** Tabs with a command in flight, keyed by tabId. See `lane`. */
   busy = /* @__PURE__ */ new Set();
@@ -63900,12 +64886,20 @@ class TabRegistry {
     }
     return null;
   }
-  /** Native shortcut eligibility needs the main-owned chrome visibility fact,
-   * not an active page's presentation bit: blank browser chrome still owns
-   * New tab, while a real blocking overlay must refuse it. Read-only and
-   * main-internal; no layout behavior or agent projection changes. */
+  /** Whether the browser's chrome band is the presented UI and therefore owns
+   * the native shortcut keys (Cmd+L/T/R and the rest).
+   *
+   * NOT the same fact as "the native view is visible". The browser's own state
+   * pages - start page, load-failure panel - hide the view ON PURPOSE so their
+   * DOM can paint (design 11.3), and they are still the browser the user is
+   * looking at. Reading `visible` alone dropped every chord on those two states,
+   * and on main's side the press was not even consumed, so the app menu's Reload
+   * reloaded the whole window. Only an overlay hide, or an unmounted surface (no
+   * rect), takes the chords away. The native window floor in
+   * `browserChromeOwnsChord` is untouched: this says whose keys they are, never
+   * that the window is foreground. */
   get chromeVisible() {
-    return this.visible && this.contentRect !== null;
+    return this.contentRect !== null && (this.visible || this.ownStatePage);
   }
   get activeTab() {
     return this.activeTabId === null ? null : this.tabs.get(this.activeTabId) ?? null;
@@ -64082,14 +65076,22 @@ class TabRegistry {
    * hijacked window. Visiting the route again reports a fresh rect and restores
    * it. A null rect is also how the caller hides the view at teardown, so it must
    * never be swallowed on the way here (see `use-browser-chrome`). */
-  setContentRect(rect) {
-    this.contentRect = rect;
+  setContentRect(rect2) {
+    this.contentRect = rect2;
     this.applyLayout();
   }
   /** Full-window overlays hide the view (design 11.3): a native view paints
-   * above all DOM, so an overlay is invisible unless the view goes away. */
-  setViewVisible(visible) {
+   * above all DOM, so an overlay is invisible unless the view goes away.
+   *
+   * `ownPage` separates the two reasons a hide can have, because they mean
+   * opposite things for the KEYBOARD: an overlay (dialog, menu, picker) owns it,
+   * while the browser's own start page / failure panel does not - that surface is
+   * still the browser, and `chromeVisible` keeps its shortcuts. Normalised
+   * against `visible` so the invariant held is "a reason only exists while the
+   * view is hidden", never two facts that disagree. */
+  setViewVisible(visible, ownPage = false) {
     this.visible = visible;
+    this.ownStatePage = !visible && ownPage;
     this.applyLayout();
   }
   activate(tabId) {
@@ -64109,16 +65111,16 @@ class TabRegistry {
       record.view.setVisible(record.presented);
     }
     this.layoutRevision += 1;
-    const rect = this.contentRect;
+    const rect2 = this.contentRect;
     try {
       this.onLayout({
         activeTabId: this.activeTabId,
         presented: active?.presented === true,
-        contentRect: rect ? {
-          x: rect.x,
-          y: rect.y,
-          width: rect.width,
-          height: rect.height
+        contentRect: rect2 ? {
+          x: rect2.x,
+          y: rect2.y,
+          width: rect2.width,
+          height: rect2.height
         } : null,
         revision: this.layoutRevision
       });
@@ -66287,15 +67289,20 @@ class BrowserHost {
   }
   /** Layout authority is the renderer's (design 11.2): it measures the content
    * area and reports it, and main applies it to the active tab only. */
-  setContentRect(rect) {
-    this.registry.setContentRect(rect);
-    if (rect === null) this.clearPageFocus();
+  setContentRect(rect2) {
+    this.registry.setContentRect(rect2);
+    if (rect2 === null) this.clearPageFocus();
     return this.chromeState();
   }
   /** Full-window overlays hide the view: a native view paints above all DOM, so
-   * an overlay is invisible unless the view goes away (design 11.3). */
-  setViewVisible(visible) {
-    this.registry.setViewVisible(visible);
+   * an overlay is invisible unless the view goes away (design 11.3).
+   *
+   * `ownPage` is the RENDERER'S REASON for the hide, and the only fact that lets
+   * main tell the browser's own state pages (start page, load failure - hidden so
+   * their DOM can paint) from an overlay covering them. Shortcut ownership keys
+   * on it; presentation does not. See `TabRegistry.chromeVisible`. */
+  setViewVisible(visible, ownPage = false) {
+    this.registry.setViewVisible(visible, ownPage);
     if (!visible) this.clearPageFocus();
     return this.chromeState();
   }
@@ -67219,58 +68226,6 @@ function restrictMode(path2, log2) {
     );
   }
 }
-const DEV_DRIVER_ENV = "LOCAL_OPERATOR_UI_DEV_DRIVER";
-const DEV_DRIVER_OUT_ENV = "LOCAL_OPERATOR_UI_DEV_DRIVER_OUT";
-const DEV_DRIVER_ARG = "--lo-dev-driver";
-const DEV_DRIVER_CAPTURE = "dev-driver-capture";
-const DEV_DRIVER_FACTS = "dev-driver-facts";
-const DEV_DRIVER_ADDRESS_OVERLAY = "dev-driver-address-overlay";
-const TRUTHY = /* @__PURE__ */ new Set(["1", "true"]);
-function readOptIn(env) {
-  const raw = env[DEV_DRIVER_ENV];
-  if (raw === void 0 || raw.trim() === "")
-    return { asked: false, value: null };
-  return { asked: true, value: raw.trim() };
-}
-function resolveDevDriverArming(input) {
-  const off = (problems = []) => ({
-    armed: false,
-    outDir: null,
-    problems
-  });
-  const optIn = readOptIn(input.env);
-  if (!optIn.asked) return off();
-  if (!TRUTHY.has(optIn.value.toLowerCase())) {
-    return off([
-      `${DEV_DRIVER_ENV}=${optIn.value} is not an opt-in (accepted: 1, true); the renderer dev driver stayed off`
-    ]);
-  }
-  if (input.windowMode !== "headless" && input.windowMode !== "inactive") {
-    return off([
-      `the renderer dev driver refused to arm in a "${input.windowMode}" window; it never raises one, so use --window-mode=headless (or inactive)`
-    ]);
-  }
-  const outDir = input.env[DEV_DRIVER_OUT_ENV]?.trim() ?? "";
-  if (outDir === "" || !outDir.startsWith("/")) {
-    return off([
-      `${DEV_DRIVER_ENV} was set but ${DEV_DRIVER_OUT_ENV} is ${outDir === "" ? "missing" : `"${outDir}"`}; an absolute frames directory is required, so the driver did not arm`
-    ]);
-  }
-  return { armed: true, outDir, problems: [] };
-}
-function headlessExerciserAllowed(input) {
-  return input.arming.armed && input.windowMode === "headless";
-}
-function devDriverArgument(outDir) {
-  return `${DEV_DRIVER_ARG}=${outDir}`;
-}
-function describeDevDriverArming(arming) {
-  if (arming.armed) {
-    return `[dev-driver] ARMED; frames are written to ${arming.outDir}`;
-  }
-  if (arming.problems.length === 0) return null;
-  return `[dev-driver] not armed: ${arming.problems.join("; ")}`;
-}
 class StartupRollback {
   owners = [];
   add(cleanup) {
@@ -67373,7 +68328,8 @@ const BROWSER_IPC_CHANNELS = [
    * `unregisterBrowserIpc` remove it on a stop/retry like every other channel
    * (removing an unregistered handler is a no-op).
    */
-  DEV_DRIVER_ADDRESS_OVERLAY
+  DEV_DRIVER_ADDRESS_OVERLAY,
+  DEV_DRIVER_ADDRESS_OVERLAY_PROJECT
 ];
 function registerBrowserIpc(options) {
   function authorizeSender(event) {
@@ -67518,17 +68474,23 @@ function registerBrowserIpc(options) {
     }
     return host.historyActive(direction);
   });
-  electron.ipcMain.handle("browser-set-content-rect", (event, rect) => {
+  electron.ipcMain.handle("browser-set-content-rect", (event, rect2) => {
     const host = authorize(event);
-    return host.setContentRect(contentRectOrNull(rect));
+    return host.setContentRect(contentRectOrNull(rect2));
   });
-  electron.ipcMain.handle("browser-set-visible", (event, visible) => {
-    const host = authorize(event);
-    if (typeof visible !== "boolean") {
-      throw new Error("Visibility must be a boolean.");
+  electron.ipcMain.handle(
+    "browser-set-visible",
+    (event, visible, ownPage) => {
+      const host = authorize(event);
+      if (typeof visible !== "boolean") {
+        throw new Error("Visibility must be a boolean.");
+      }
+      if (ownPage !== void 0 && typeof ownPage !== "boolean") {
+        throw new Error("The view-hidden reason must be a boolean.");
+      }
+      return host.setViewVisible(visible, ownPage === true);
     }
-    return host.setViewVisible(visible);
-  });
+  );
   electron.ipcMain.handle(
     "browser-hand-over",
     (event, tabId, sessionId2) => {
@@ -67620,21 +68582,40 @@ function registerBrowserIpc(options) {
     return { retried: true };
   });
   if (options.addressOverlayProbe) {
-    electron.ipcMain.handle(DEV_DRIVER_ADDRESS_OVERLAY, (event, action) => {
-      authorizeSender(event);
-      if (action !== "show" && action !== "hide" && action !== "facts") {
-        throw new Error(
-          "address_overlay_invalid_action: expected 'show', 'hide' or 'facts'."
-        );
+    electron.ipcMain.handle(
+      DEV_DRIVER_ADDRESS_OVERLAY,
+      (event, action, argument) => {
+        authorizeSender(event);
+        if (action !== "show" && action !== "hide" && action !== "facts" && action !== "click" && action !== "measure" && action !== "key") {
+          throw new Error(
+            "address_overlay_invalid_action: expected 'show', 'hide', 'facts', 'click', 'measure' or 'key'."
+          );
+        }
+        const probe = options.addressOverlayProbe;
+        if (!probe) {
+          throw new Error(
+            "address_overlay_unavailable: the overlay probe is not running."
+          );
+        }
+        const readsArgument = action === "click" || action === "measure" || action === "key";
+        return probe(action, readsArgument ? argument : void 0);
       }
-      const probe = options.addressOverlayProbe;
-      if (!probe) {
-        throw new Error(
-          "address_overlay_unavailable: the overlay probe is not running."
-        );
+    );
+  }
+  if (options.addressOverlayProject) {
+    electron.ipcMain.handle(
+      DEV_DRIVER_ADDRESS_OVERLAY_PROJECT,
+      (event, payload) => {
+        authorizeSender(event);
+        const project = options.addressOverlayProject;
+        if (!project) {
+          throw new Error(
+            "address_overlay_unavailable: the overlay projection is not running."
+          );
+        }
+        return project(payload);
       }
-      return probe(action);
-    });
+    );
   }
 }
 function unregisterBrowserIpc() {
@@ -67699,17 +68680,17 @@ function contentRectOrNull(value) {
   if (value === null || value === void 0) return null;
   if (typeof value !== "object")
     throw new Error("Content rect must be an object.");
-  const rect = value;
+  const rect2 = value;
   for (const key of ["x", "y", "width", "height"]) {
-    if (typeof rect[key] !== "number" || !Number.isFinite(rect[key])) {
+    if (typeof rect2[key] !== "number" || !Number.isFinite(rect2[key])) {
       throw new Error("Content rect needs finite x, y, width and height.");
     }
   }
   return {
-    x: rect.x,
-    y: rect.y,
-    width: rect.width,
-    height: rect.height
+    x: rect2.x,
+    y: rect2.y,
+    width: rect2.width,
+    height: rect2.height
   };
 }
 function paneNavigationDirection(input) {
@@ -69619,15 +70600,30 @@ function startBrowserHost(options) {
      * replaces it) rather than capturing a controller here.
      */
     ...options.addressOverlay?.enabled ? {
-      addressOverlayProbe: (action) => {
+      addressOverlayProbe: (action, argument) => {
         const probe = bindings.addressOverlayProbe;
         if (!probe) {
           throw new Error(
             "address_overlay_unavailable: the overlay controller is not running."
           );
         }
-        return probe(action);
-      }
+        return probe(action, argument);
+      },
+      /* S2's projection. Registered only with the S1 probe, because the
+       * projection can only drive a child the probe's gate also armed. The
+       * current attempt's handler is read through `bindings` per call, like
+       * the probe above, so a retry cannot leave a stale controller. */
+      ...options.addressOverlay.list === true ? {
+        addressOverlayProject: (payload) => {
+          const project = bindings.addressOverlayProject;
+          if (!project) {
+            throw new Error(
+              "address_overlay_unavailable: the overlay controller is not running."
+            );
+          }
+          return project(payload);
+        }
+      } : {}
     } : {},
     log: options.log
   });
@@ -70017,6 +71013,18 @@ async function initializeBrowserHost(options, bindings) {
     const addressOverlay = options.addressOverlay?.enabled === true ? new AddressOverlayController({
       window: options.window,
       documentUrl: options.addressOverlay.documentUrl,
+      javascript: options.addressOverlay.list === true,
+      visible: options.addressOverlay.visible === true,
+      // The only consumer of a validated row click: the owner window's own
+      // renderer. Guarded because a stop can race a queued mouse event.
+      onEvent: (event) => {
+        if (!options.window.isDestroyed()) {
+          options.window.webContents.send(
+            DEV_DRIVER_ADDRESS_OVERLAY_EVENT,
+            event
+          );
+        }
+      },
       log: log2,
       appMetrics: () => electron.app.getAppMetrics().map((metric) => ({
         pid: metric.pid,
@@ -70325,13 +71333,13 @@ async function initializeBrowserHost(options, bindings) {
     );
     rollback.add(() => stateWriter?.clear());
     stateWriter.start(server.port, sessionKey);
-    const probeAddressOverlay = async (action) => {
+    const probeAddressOverlay = async (action, argument) => {
       if (!addressOverlay) {
         throw new Error(
           "address_overlay_unavailable: this host owns no controller."
         );
       }
-      const facts2 = await addressOverlay.probe(action);
+      const facts2 = await addressOverlay.probe(action, argument);
       const record = registry.activeTab;
       const page = record ? {
         tabId: record.tabId,
@@ -70341,8 +71349,19 @@ async function initializeBrowserHost(options, bindings) {
       } : null;
       return { ...facts2, page };
     };
+    const projectAddressOverlay = (payload) => {
+      if (!addressOverlay) {
+        throw new Error(
+          "address_overlay_unavailable: this host owns no controller."
+        );
+      }
+      return addressOverlay.project(payload);
+    };
     if (addressOverlay) {
       bindings.addressOverlayProbe = probeAddressOverlay;
+      if (options.addressOverlay?.list === true) {
+        bindings.addressOverlayProject = projectAddressOverlay;
+      }
     }
     Object.assign(bindings, {
       window: () => options.window,
@@ -81704,11 +82723,12 @@ if (devDriverLine) console.log(devDriverLine);
 const addressOverlayGate = resolveAddressOverlayGate({
   env: launchEnv,
   devDriverArmed: devDriverArming.armed,
-  windowMode: windowLaunch.mode
+  windowMode: windowLaunch.mode,
+  packaged: electron.app.isPackaged
 });
 if (addressOverlayGate.asked) {
   console.log(
-    addressOverlayGate.enabled ? "[address-overlay] ARMED (S1 probe: native child, no product path)" : `[address-overlay] not armed: ${addressOverlayGate.reason}`
+    addressOverlayGate.enabled ? addressOverlayGate.visible ? "[address-overlay] ARMED (S3 VISIBLE probe, inactive window, 120 s cap, no product path)" : `[address-overlay] ARMED (S${addressOverlayGate.list ? "2 probe: mirror list" : "1 probe: native child"}, no product path)` : `[address-overlay] not armed: ${addressOverlayGate.reason}`
   );
 }
 const devDriverWebPreferences = devDriverArming.armed && devDriverArming.outDir ? { additionalArguments: [devDriverArgument(devDriverArming.outDir)] } : {};
@@ -81982,7 +83002,10 @@ electron.app.whenReady().then(async () => {
   const launcher = resolveLauncherWatchPlan({
     mode: windowLaunch.mode,
     launcherPid: process.ppid,
-    env: launchEnv
+    env: launchEnv,
+    // S3 only: the one visible run nobody is watching still must not
+    // outlive its launcher. False for every product launch.
+    boundedVisibleProbe: addressOverlayGate.visible
   });
   logger.info(`[window-mode] ${launcher.reason}`, LogFileType.BACKEND);
   if (windowLaunch.mode !== "normal") {
@@ -81997,12 +83020,23 @@ electron.app.whenReady().then(async () => {
       onLauncherGone: ({ message, detail }) => endHeadlessRun(message, detail)
     });
   }
-  if (windowLaunch.mode === "headless") {
+  if (addressOverlayGate.visible) {
+    const cap = setTimeout(() => {
+      endHeadlessRun(
+        `the visible address-overlay probe reached its ${ADDRESS_OVERLAY_VISIBLE_MAX_MS / 1e3} s cap`
+      );
+    }, ADDRESS_OVERLAY_VISIBLE_MAX_MS);
+    cap.unref();
+    console.log(
+      `[address-overlay] visible probe cap: ${ADDRESS_OVERLAY_VISIBLE_MAX_MS / 1e3} s from launch`
+    );
+  }
+  if (windowLaunch.mode === "headless" || addressOverlayGate.visible) {
     for (const signal of ["SIGTERM", "SIGINT"]) {
       process.on(signal, () => endHeadlessRun(`received ${signal}`));
     }
   }
-  if (windowLaunch.mode !== "headless") {
+  if (windowLaunch.mode !== "headless" && !addressOverlayGate.visible) {
     const onSigtermDuringQuit = () => {
       if (!quitState.isQuitting()) {
         process.removeListener("SIGTERM", onSigtermDuringQuit);
@@ -82114,7 +83148,7 @@ electron.app.whenReady().then(async () => {
   });
   const rendererUrl = rendererDocumentUrl();
   const consoleCaptureUrl = consoleCaptureUrlFor(rendererUrl);
-  const addressOverlayDocumentUrl = addressOverlayDocumentUrlFor(rendererUrl);
+  const addressOverlayDocumentUrl = addressOverlayGate.list ? addressListDocumentUrlFor(rendererUrl) : addressOverlayDocumentUrlFor(rendererUrl);
   backendService.observeDesktopFeed(
     (frame) => {
       if (frame.type === "notification") {
@@ -82928,6 +83962,8 @@ electron.app.whenReady().then(async () => {
         ...addressOverlayGate.enabled ? {
           addressOverlay: {
             enabled: true,
+            list: addressOverlayGate.list,
+            visible: addressOverlayGate.visible,
             documentUrl: addressOverlayDocumentUrl
           }
         } : {},