local-operator-ui 0.38.1 → 0.39.1

package/out/main/index.js

@@ -190,6 +190,17 @@ zod.z.object({
     }).passthrough()
   }).passthrough()
 }).passthrough();
+const SIDEBAR_DESTINATION_IDS = [
+  "aida",
+  "library",
+  "projects",
+  "agents",
+  "schedules",
+  "browser",
+  "team-bridge",
+  "agent-hub",
+  "mesh"
+];
 const JOURNAL_ORDER_QUERY_BYTES = 6 * 1024;
 const JOURNAL_ORDER_ID_LIMIT = 512;
 function appendJournalOrderIds(query, path2, ids) {
@@ -488,6 +499,11 @@ const PROJECTS_SEARCH_MAX_CHARS = 256;
 const PROJECTS_SEARCH_DEFAULT_LIMIT = 100;
 const PROJECTS_SEARCH_MAX_LIMIT = 200;
 const hubItemKind = zod.z.enum(["agent", "team", "skill"]);
+const sidebarDestinationId = zod.z.enum(SIDEBAR_DESTINATION_IDS);
+const sidebarLayoutSchema = zod.z.object({
+  visible: zod.z.array(sidebarDestinationId).max(SIDEBAR_DESTINATION_IDS.length),
+  more: zod.z.array(sidebarDestinationId).max(SIDEBAR_DESTINATION_IDS.length)
+}).strict();
 const desktopRequestUnion = zod.z.discriminatedUnion("op", [
   zod.z.object({ op: zod.z.literal("capabilities") }).strict(),
   /*
@@ -2989,6 +3005,23 @@ const desktopRequestUnion = zod.z.discriminatedUnion("op", [
     op: zod.z.literal("library.librarian"),
     /** `status` is the read's own op; the other four are the writes. */
     action: zod.z.enum(["status", "open", "pause", "resume", "run"]).optional()
+  }).strict(),
+  /*
+   * THE SIDEBAR LAYOUT RESOURCE (design contract § 2, § 4). One read and one
+   * write, mirroring the two HTTP verbs: the resource is a single document, and
+   * a patch vocabulary over a nine-entry ordered list would have to invent
+   * operations for moves the client already knows how to compute.
+   *
+   * The write carries the WHOLE layout rather than a delta because the route
+   * normalises and persists a complete document (last writer wins, atomic file
+   * replace). Sending the full list is also what makes an optimistic write
+   * self-describing on the retry path: the body a retry replays is the layout
+   * the user saw, not a move that could be applied twice.
+   */
+  zod.z.object({ op: zod.z.literal("sidebar_layout.get") }).strict(),
+  zod.z.object({
+    op: zod.z.literal("sidebar_layout.set"),
+    layout: sidebarLayoutSchema
   }).strict()
 ]);
 const desktopRequestSchema = desktopRequestUnion.superRefine(
@@ -5387,6 +5420,22 @@ function desktopEndpoint(request) {
           ttl_s: request.ttlS
         }
       };
+    /*
+     * The sidebar customisation resource (design contract § 4). A GET/PUT pair
+     * on one route, with the layout in an envelope rather than as the bare body:
+     * the route answers `{layout}` and accepts `{layout}`, so a future field
+     * beside it is additive instead of a breaking shape change. The PUT sends
+     * the stored ids verbatim - the client owns the order, the route owns
+     * validation and the default fill - so nothing is re-sorted in transit.
+     */
+    case "sidebar_layout.get":
+      return { path: "/v1/desktop/sidebar-layout", method: "GET" };
+    case "sidebar_layout.set":
+      return {
+        path: "/v1/desktop/sidebar-layout",
+        method: "PUT",
+        body: { layout: request.layout }
+      };
   }
 }
 const MAX_PROBE_PATHS = 64;
@@ -14955,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) {
@@ -26003,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"),
@@ -26043,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())) {
@@ -27011,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) {
@@ -27787,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.`);
     }
@@ -28292,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;
@@ -28714,6 +28831,1572 @@ 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;
+const DIP_INT32_MAX = 2 ** 31 - 1;
+const INDEX_DOCUMENT_SUFFIX$2 = /\/?index\.html(\?.*)?$/;
+const TRAILING_SLASH$1 = /\/$/;
+function addressOverlayDocumentUrlFor(rendererUrl) {
+  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() === "") {
+    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"
+    };
+  }
+  if (input.windowMode !== "headless") {
+    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,
+    list: listAsked,
+    visible: false,
+    reason: null
+  };
+}
+function int32(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  const rounded = Math.round(value);
+  return Math.abs(rounded) > DIP_INT32_MAX ? null : rounded;
+}
+function overlayBoundsFor(contentRect, owner) {
+  if (contentRect === null) return null;
+  const x = int32(contentRect.x);
+  const y = int32(contentRect.y);
+  const width = int32(contentRect.width);
+  const height = int32(contentRect.height);
+  const ownerWidth = int32(owner.width);
+  const ownerHeight = int32(owner.height);
+  if (x === null || y === null || width === null || height === null || ownerWidth === null || ownerHeight === null)
+    return null;
+  if (width <= 0 || height <= 0 || ownerWidth <= 0 || ownerHeight <= 0) {
+    return null;
+  }
+  const left = Math.max(0, x);
+  const top = Math.max(0, y);
+  const right = Math.min(ownerWidth, x + width);
+  const bottom = Math.min(
+    ownerHeight,
+    y + Math.min(height, ADDRESS_OVERLAY_MAX_HEIGHT_DIP)
+  );
+  if (right <= left || bottom <= top) return null;
+  return { x: left, y: top, width: right - left, height: bottom - top };
+}
+function copyLayout(snapshot2) {
+  return {
+    activeTabId: snapshot2.activeTabId,
+    presented: snapshot2.presented,
+    contentRect: snapshot2.contentRect ? {
+      x: snapshot2.contentRect.x,
+      y: snapshot2.contentRect.y,
+      width: snapshot2.contentRect.width,
+      height: snapshot2.contentRect.height
+    } : null,
+    revision: snapshot2.revision
+  };
+}
+function layoutKeyOf(snapshot2) {
+  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(options) {
+  const partition = `address-overlay-${node_crypto.randomUUID()}`;
+  const childSession = electron.session.fromPartition(partition);
+  childSession.setPermissionRequestHandler(
+    (_contents, _permission, callback) => {
+      callback(false);
+    }
+  );
+  childSession.setPermissionCheckHandler(() => false);
+  childSession.on("will-download", (event) => {
+    event.preventDefault();
+  });
+  const view = new electron.WebContentsView({
+    webPreferences: {
+      partition,
+      sandbox: true,
+      contextIsolation: true,
+      nodeIntegration: false,
+      webSecurity: true,
+      allowRunningInsecureContent: 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" }));
+  view.setBackgroundColor(OVERLAY_BACKGROUND);
+  return view;
+}
+class AddressOverlayController {
+  window;
+  documentUrl;
+  createView;
+  javascript;
+  onEvent;
+  readinessTimeoutMs;
+  log;
+  now;
+  appMetrics;
+  view;
+  childWebContentsId;
+  state;
+  failedReason;
+  hiddenReason;
+  generation;
+  childCreatedCount;
+  shownCount;
+  lastShow;
+  layout;
+  layoutKey;
+  boundTabId;
+  domReady;
+  finished;
+  loadStartedAt;
+  loadMs;
+  readyWaiter;
+  readinessTimer;
+  showInFlight;
+  disposingChild;
+  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({ 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 ?? (() => {
+    });
+    this.now = deps.now ?? (() => Date.now());
+    this.appMetrics = deps.appMetrics ?? null;
+    this.view = null;
+    this.childWebContentsId = null;
+    this.state = "absent";
+    this.failedReason = null;
+    this.hiddenReason = null;
+    this.generation = 0;
+    this.childCreatedCount = 0;
+    this.shownCount = 0;
+    this.lastShow = null;
+    this.layout = {
+      activeTabId: null,
+      presented: false,
+      contentRect: null,
+      revision: 0
+    };
+    this.layoutKey = "none";
+    this.boundTabId = null;
+    this.domReady = false;
+    this.finished = false;
+    this.loadStartedAt = null;
+    this.loadMs = null;
+    this.readyWaiter = null;
+    this.readinessTimer = null;
+    this.showInFlight = null;
+    this.disposingChild = false;
+    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 ------------------------------------------------------
+  /**
+   * The registry's post-layout hook. Called after every page layout pass,
+   * including null and suppressed ones.
+   *
+   * A changed key (tab, presentation or rectangle) hides and invalidates first:
+   * a moved page must never keep a stale rectangle floating over it, and a
+   * resized window invalidates old geometry until a fresh renderer rect
+   * arrives. An unchanged key is the background-page-creation case: the layout
+   * pass may have added a page above the child, so the child is re-added last
+   * and given the same rectangle. It never re-opens by itself; showing again is
+   * always an explicit probe call.
+   */
+  onLayout(snapshot2) {
+    if (this.disposed) return;
+    const next = copyLayout(snapshot2);
+    const nextKey = layoutKeyOf(next);
+    const previousKey = this.layoutKey;
+    this.layout = next;
+    this.layoutKey = nextKey;
+    if (previousKey !== nextKey) {
+      this.hide("layout");
+      return;
+    }
+    if (this.state !== "shown") return;
+    const view = this.view;
+    if (!view || this.viewUsable(view) === false) return;
+    const bounds = this.lastProjection !== null ? this.lastAppliedBounds : overlayBoundsFor(next.contentRect, this.ownerSize());
+    if (bounds === null || !next.presented) {
+      this.hide("layout_invalid");
+      return;
+    }
+    try {
+      view.setBounds(bounds);
+      this.raiseChild(view);
+    } catch (error) {
+      this.releaseChild("layout_error");
+      this.log(`[browser] address overlay layout failed: ${String(error)}`);
+    }
+  }
+  /** The bound page is going away. Dispose the child before the page release. */
+  onTabReleased(tabId) {
+    if (this.disposed) return;
+    if (this.boundTabId !== tabId) return;
+    this.releaseChild("bound-tab-released");
+  }
+  /** The bound page's renderer died but its webContents survives (a crashed tab).
+   * The child is bound to that page's rectangle, so it goes with the renderer; a
+   * later explicit show may create a fresh one. */
+  onPageGone(tabId) {
+    if (this.disposed) return;
+    if (this.boundTabId !== tabId) return;
+    this.releaseChild("page-crash");
+  }
+  // ---- probe surface ------------------------------------------------------
+  async showOverlay() {
+    if (this.showInFlight) return this.showInFlight;
+    const pending = this.showOnce();
+    this.showInFlight = pending;
+    void pending.then(
+      () => {
+        if (this.showInFlight === pending) this.showInFlight = null;
+      },
+      () => {
+        if (this.showInFlight === pending) this.showInFlight = null;
+      }
+    );
+    return pending;
+  }
+  hide(reason = "hide") {
+    if (this.disposed) return;
+    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 {
+        view.setVisible(false);
+      } catch {
+      }
+    }
+    if (this.state === "shown") {
+      this.state = this.failedReason ? "failed" : this.domReady && this.finished ? "ready" : "loading";
+    }
+    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;
+    let child = null;
+    if (view) {
+      let visible = false;
+      let bounds = null;
+      let order = -1;
+      let childCount = 0;
+      try {
+        visible = view.getVisible();
+        bounds = view.getBounds();
+        const children = this.window.contentView.children;
+        childCount = children.length;
+        order = children.indexOf(view);
+      } catch {
+      }
+      child = {
+        webContentsId: this.childWebContentsId ?? view.webContents.id,
+        visible,
+        bounds,
+        order,
+        childCount,
+        focusEvents: this.childFocusEvents,
+        blurEvents: this.childBlurEvents,
+        isFocused: this.childIsFocused(view)
+      };
+    }
+    let ownerDestroyed = true;
+    let contentBounds = null;
+    try {
+      ownerDestroyed = this.window.isDestroyed();
+      if (!ownerDestroyed) contentBounds = this.ownerSize();
+    } 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,
+      failedReason: this.failedReason,
+      hiddenReason: this.hiddenReason,
+      generation: this.generation,
+      childCreatedCount: this.childCreatedCount,
+      shownCount: this.shownCount,
+      lastShow: this.lastShow,
+      readiness: {
+        domReady: this.domReady,
+        finished: this.finished,
+        loadMs: this.loadMs
+      },
+      child,
+      owner: {
+        windowId: typeof this.window.id === "number" ? this.window.id : null,
+        destroyed: ownerDestroyed,
+        contentBounds
+      },
+      layout: copyLayout(this.layout),
+      listeners: {
+        owner: this.ownerListeners.length,
+        child: this.childListeners.length
+      },
+      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, argument) {
+    if (action === "show") {
+      await this.showOverlay();
+      return this.facts();
+    }
+    if (action === "hide") {
+      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
+   * `WebContentsView` does not release its renderer.
+   */
+  dispose(reason) {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.generation += 1;
+    this.settleReady(false);
+    this.detachOwnerListeners();
+    this.destroyChild();
+    this.state = "disposed";
+    this.hiddenReason = reason;
+    this.log(`[browser] address overlay disposed: ${reason}`);
+  }
+  get isDisposed() {
+    return this.disposed;
+  }
+  // ---- show path ----------------------------------------------------------
+  async showOnce() {
+    const refuse = (reason) => {
+      this.lastShow = { shown: false, reason, bounds: null, at: this.now() };
+      return { shown: false, reason, bounds: null };
+    };
+    try {
+      if (this.disposed) return refuse("disposed");
+      if (this.failedReason) return refuse(this.failedReason);
+      if (this.ownerUnavailable()) {
+        this.releaseChild("owner_unavailable");
+        return refuse("owner_unavailable");
+      }
+      const snapshot2 = this.layout;
+      const bounds = overlayBoundsFor(snapshot2.contentRect, this.ownerSize());
+      if (snapshot2.activeTabId === null || !snapshot2.presented || bounds === null) {
+        return refuse("no_layout");
+      }
+      this.generation += 1;
+      const generation = this.generation;
+      this.boundTabId = snapshot2.activeTabId;
+      if (!this.view) {
+        const created = this.createChild(bounds);
+        if (!created) return refuse(this.failedReason ?? "child_create_failed");
+      }
+      if (!(this.domReady && this.finished)) {
+        this.state = "loading";
+        const ready = await this.waitForReady();
+        if (!ready) return refuse(this.failedReason ?? "invalidated");
+      }
+      if (this.disposed || generation !== this.generation) {
+        return refuse("invalidated");
+      }
+      if (this.ownerUnavailable()) {
+        this.releaseChild("owner_unavailable");
+        return refuse("owner_unavailable");
+      }
+      const view = this.view;
+      if (!view) return refuse("child_missing");
+      const finalBounds = overlayBoundsFor(
+        this.layout.contentRect,
+        this.ownerSize()
+      );
+      if (finalBounds === null || this.layout.activeTabId === null || !this.layout.presented || this.layout.activeTabId !== this.boundTabId) {
+        return refuse("invalidated");
+      }
+      view.setBounds(finalBounds);
+      this.raiseChild(view);
+      view.setVisible(true);
+      this.state = "shown";
+      this.hiddenReason = null;
+      this.shownCount += 1;
+      this.lastShow = {
+        shown: true,
+        reason: null,
+        bounds: finalBounds,
+        at: this.now()
+      };
+      this.log(
+        `[browser] address overlay shown tab=${this.boundTabId} bounds=${finalBounds.x},${finalBounds.y},${finalBounds.width},${finalBounds.height} generation=${generation}`
+      );
+      return { shown: true, reason: null, bounds: finalBounds };
+    } catch (error) {
+      this.failChild(`show_error:${String(error)}`);
+      return refuse("child_error");
+    }
+  }
+  createChild(bounds) {
+    let view;
+    try {
+      view = this.createView();
+    } catch (error) {
+      this.failChild(`child_create_failed:${String(error)}`);
+      return false;
+    }
+    this.view = view;
+    this.childWebContentsId = view.webContents.id;
+    this.childCreatedCount += 1;
+    this.domReady = false;
+    this.finished = false;
+    this.loadMs = null;
+    this.loadStartedAt = null;
+    try {
+      this.window.contentView.addChildView(view);
+      view.setBounds(bounds);
+      view.setVisible(false);
+    } catch (error) {
+      this.failChild(`child_attach_failed:${String(error)}`);
+      return false;
+    }
+    this.wireChild(view);
+    this.loadStartedAt = this.now();
+    try {
+      const loading = view.webContents.loadURL(this.documentUrl);
+      void Promise.resolve(loading).catch((error) => {
+        if (this.disposed || this.view !== view) return;
+        this.failChild(`load_failed:${String(error)}`);
+      });
+    } catch (error) {
+      this.failChild(`load_failed:${String(error)}`);
+      return false;
+    }
+    this.log(
+      `[browser] address overlay child created wc=${view.webContents.id}`
+    );
+    return true;
+  }
+  waitForReady() {
+    if (this.domReady && this.finished) return Promise.resolve(true);
+    if (this.readyWaiter) {
+      return Promise.resolve(false);
+    }
+    return new Promise((resolve) => {
+      this.readyWaiter = resolve;
+      this.readinessTimer = setTimeout(() => {
+        this.readinessTimer = null;
+        if (this.readyWaiter) this.failChild("load_timeout");
+      }, this.readinessTimeoutMs);
+    });
+  }
+  settleReady(ok) {
+    if (this.readinessTimer !== null) {
+      clearTimeout(this.readinessTimer);
+      this.readinessTimer = null;
+    }
+    const waiter = this.readyWaiter;
+    this.readyWaiter = null;
+    if (waiter) waiter(ok);
+  }
+  maybeReady() {
+    if (!(this.domReady && this.finished)) return;
+    if (this.loadStartedAt !== null && this.loadMs === null) {
+      this.loadMs = this.now() - this.loadStartedAt;
+    }
+    if (this.state === "loading" || this.state === "absent") {
+      this.state = this.readyWaiter ? this.state : "ready";
+    }
+    this.settleReady(true);
+  }
+  // ---- child wiring -------------------------------------------------------
+  wireChild(view) {
+    const contents = view.webContents;
+    const on = (target2, event, listener) => {
+      const emitter = target2;
+      emitter.on(event, listener);
+      this.childListeners.push(() => {
+        try {
+          emitter.removeListener(event, listener);
+        } catch {
+        }
+      });
+    };
+    on(contents, "dom-ready", () => {
+      if (this.view !== view) return;
+      this.domReady = true;
+      this.maybeReady();
+    });
+    on(contents, "did-finish-load", () => {
+      if (this.view !== view) return;
+      this.finished = true;
+      this.maybeReady();
+    });
+    on(contents, "did-fail-load", (...args) => {
+      if (this.view !== view) return;
+      const code = typeof args[1] === "number" ? args[1] : 0;
+      const isMainFrame = args[4] !== false;
+      if (!isMainFrame || code === -3) return;
+      this.failChild(`load_failed:${code}`);
+    });
+    on(contents, "render-process-gone", () => {
+      if (this.view !== view) return;
+      this.failChild("child_crash");
+    });
+    on(contents, "destroyed", () => {
+      if (this.view !== view) return;
+      if (this.disposingChild) return;
+      this.failChild("child_destroyed");
+    });
+    on(contents, "will-navigate", (...args) => {
+      const url = typeof args[1] === "string" ? args[1] : "";
+      const event = args[0];
+      if (url === this.documentUrl) return;
+      event?.preventDefault?.();
+      this.log(`[browser] address overlay refused navigation to ${url}`);
+    });
+    on(contents, "will-redirect", (...args) => {
+      const url = typeof args[1] === "string" ? args[1] : "";
+      const event = args[0];
+      if (url === this.documentUrl) return;
+      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) {
+    if (this.failedReason) return;
+    this.failedReason = reason;
+    this.state = "failed";
+    this.settleReady(false);
+    this.destroyChild();
+    this.log(`[browser] address overlay failed: ${reason}`);
+  }
+  /** Recoverable: the child goes, a later explicit show may lazily recreate one. */
+  releaseChild(reason) {
+    this.generation += 1;
+    this.settleReady(false);
+    this.destroyChild();
+    if (!this.failedReason) this.state = "absent";
+    this.boundTabId = null;
+    this.domReady = false;
+    this.finished = false;
+    this.loadStartedAt = null;
+    this.log(`[browser] address overlay child released: ${reason}`);
+  }
+  destroyChild() {
+    const view = this.view;
+    if (!view) return;
+    this.view = null;
+    this.childWebContentsId = null;
+    this.disposingChild = true;
+    for (const remove of this.childListeners.splice(0)) remove();
+    try {
+      if (!view.webContents.isDestroyed()) view.webContents.close();
+    } catch {
+    }
+    try {
+      this.window.contentView.removeChildView(view);
+    } catch {
+    }
+    this.disposingChild = false;
+  }
+  raiseChild(view) {
+    this.window.contentView.addChildView(view);
+  }
+  viewUsable(view) {
+    try {
+      return !view.webContents.isDestroyed();
+    } catch {
+      return false;
+    }
+  }
+  // ---- owner wiring -------------------------------------------------------
+  attachOwnerListeners() {
+    const on = (target2, event, listener) => {
+      const emitter = target2;
+      emitter.on(event, listener);
+      this.ownerListeners.push(() => {
+        try {
+          emitter.removeListener(event, listener);
+        } catch {
+        }
+      });
+    };
+    on(this.window, "blur", () => {
+      this.hide("window_blur");
+    });
+    on(this.window, "minimize", () => {
+      this.hide("window_minimize");
+    });
+    on(this.window, "closed", () => {
+      this.dispose("window_closed");
+    });
+    const contents = this.window.webContents;
+    on(contents, "render-process-gone", () => {
+      this.releaseChild("owner_crash");
+    });
+    on(contents, "destroyed", () => {
+      this.dispose("owner_destroyed");
+    });
+    on(contents, "did-start-navigation", (...args) => {
+      const details = args[0];
+      if (details?.isMainFrame && details.isSameDocument !== true) {
+        this.releaseChild("owner_navigation");
+      }
+    });
+  }
+  detachOwnerListeners() {
+    for (const remove of this.ownerListeners.splice(0)) remove();
+  }
+  ownerSize() {
+    const bounds = this.window.getContentBounds();
+    return { width: bounds.width, height: bounds.height };
+  }
+  ownerUnavailable() {
+    try {
+      return this.window.isDestroyed() || this.window.webContents.isDestroyed();
+    } catch {
+      return true;
+    }
+  }
+}
 const PRIVATE_FILE_MODE = 384;
 const PRIVATE_DIR_MODE = 448;
 function writeJsonAtomic(path2, value) {
@@ -34003,7 +35686,7 @@ const enUiCommandPalette = {
   "ui.command_palette.palette_search.unread": "Unread",
   "ui.command_palette.palette_search.untitled_chat": "Untitled chat",
   "ui.command_palette.use_palette_sources.agent_chat": "Agent chat",
-  "ui.command_palette.use_palette_sources.agent_hub": "Agent hub",
+  "ui.command_palette.use_palette_sources.agent_hub": "Agent Hub",
   "ui.command_palette.use_palette_sources.agent_settings": "Agent settings",
   "ui.command_palette.use_palette_sources.analytics": "Analytics",
   "ui.command_palette.use_palette_sources.app_backend_and_environment": "App, backend and environment",
@@ -36509,7 +38192,7 @@ const enUiSettingsUpdates = {
 const enUiShell = {
   "ui.shell.collapsible_app_logo.local_operator": "Local Operator",
   "ui.shell.panel_rail.panels": "Panels",
-  "ui.shell.sidebar_navigation.agent_hub": "Agent hub",
+  "ui.shell.sidebar_navigation.agent_hub": "Agent Hub",
   "ui.shell.sidebar_navigation.agents": "Agents",
   "ui.shell.sidebar_navigation.aida_missed": "{name}, {count, plural, one {{count, number, ::group-off} missed message} other {{count, number, ::group-off} missed messages}}",
   "ui.shell.sidebar_navigation.aida_working": "{name}, working",
@@ -36517,17 +38200,31 @@ const enUiShell = {
   "ui.shell.sidebar_navigation.browser_waiting": "Browser, {count, plural, one {{countText} waiting} other {{countText} waiting}}",
   "ui.shell.sidebar_navigation.close_sidebar": "Close sidebar",
   "ui.shell.sidebar_navigation.collapse_sidebar": "Collapse sidebar",
+  "ui.shell.sidebar_navigation.drag_armed": "Moving {name}. Press Escape to cancel.",
   "ui.shell.sidebar_navigation.expand_sidebar": "Expand sidebar",
   "ui.shell.sidebar_navigation.mesh": "Mesh",
   "ui.shell.sidebar_navigation.mesh_waiting": "Mesh, {count, plural, one {{countText} waiting} other {{countText} waiting}}",
+  "ui.shell.sidebar_navigation.more_waiting": "More, {count, plural, one {{countText} waiting} other {{countText} waiting}}",
+  "ui.shell.sidebar_navigation.more_working": "More, working",
+  "ui.shell.sidebar_navigation.move_down": "Move down",
+  "ui.shell.sidebar_navigation.move_note": "Moved {name} to position {position} of {total}.",
+  "ui.shell.sidebar_navigation.move_to_more": "Move to More",
+  "ui.shell.sidebar_navigation.move_to_more_note": "{name} moved to More.",
+  "ui.shell.sidebar_navigation.move_up": "Move up",
   "ui.shell.sidebar_navigation.new_chat": "New chat",
   "ui.shell.sidebar_navigation.new_chat_shortcut": "New chat ({shortcut})",
   "ui.shell.sidebar_navigation.projects": "Projects",
+  "ui.shell.sidebar_navigation.reset_layout": "Reset sidebar layout",
+  "ui.shell.sidebar_navigation.reset_note": "Sidebar layout reset.",
+  "ui.shell.sidebar_navigation.row_actions": "Actions for {name}",
+  "ui.shell.sidebar_navigation.save_failed": "Could not save the sidebar layout.",
   "ui.shell.sidebar_navigation.schedules": "Schedules",
   "ui.shell.sidebar_navigation.search": "Search",
   "ui.shell.sidebar_navigation.search_accessible": "Search ({everything}) — chats ({chats})",
   "ui.shell.sidebar_navigation.search_tooltip": "Search everything ({everything}) · your chats ({chats})",
   "ui.shell.sidebar_navigation.settings": "Settings",
+  "ui.shell.sidebar_navigation.show_in_sidebar": "Show in sidebar",
+  "ui.shell.sidebar_navigation.show_in_sidebar_note": "{name} shown in the sidebar.",
   "ui.shell.user_profile_sidebar.account_settings": "Account settings",
   "ui.shell.user_profile_sidebar.account_unavailable": "Account unavailable",
   "ui.shell.user_profile_sidebar.checking_account": "Checking account…",
@@ -40081,17 +41778,31 @@ const esUiShell = {
   "ui.shell.sidebar_navigation.browser_waiting": "Navegador, {count, plural, one {{countText} en espera} many {{countText} en espera} other {{countText} en espera}}",
   "ui.shell.sidebar_navigation.close_sidebar": "Cerrar barra lateral",
   "ui.shell.sidebar_navigation.collapse_sidebar": "Contraer barra lateral",
+  "ui.shell.sidebar_navigation.drag_armed": "Moviendo {name}. Pulsa Esc para cancelar.",
   "ui.shell.sidebar_navigation.expand_sidebar": "Expandir barra lateral",
   "ui.shell.sidebar_navigation.mesh": "Mesh",
   "ui.shell.sidebar_navigation.mesh_waiting": "Mesh, {count, plural, one {{countText} en espera} many {{countText} en espera} other {{countText} en espera}}",
+  "ui.shell.sidebar_navigation.more_waiting": "Más, {count, plural, one {{countText} en espera} many {{countText} en espera} other {{countText} en espera}}",
+  "ui.shell.sidebar_navigation.more_working": "Más, trabajando",
+  "ui.shell.sidebar_navigation.move_down": "Bajar",
+  "ui.shell.sidebar_navigation.move_note": "Se movió {name} a la posición {position} de {total}.",
+  "ui.shell.sidebar_navigation.move_to_more": "Mover a Más",
+  "ui.shell.sidebar_navigation.move_to_more_note": "{name} se movió a Más.",
+  "ui.shell.sidebar_navigation.move_up": "Subir",
   "ui.shell.sidebar_navigation.new_chat": "Nuevo chat",
   "ui.shell.sidebar_navigation.new_chat_shortcut": "Nuevo chat ({shortcut})",
   "ui.shell.sidebar_navigation.projects": "Proyectos",
+  "ui.shell.sidebar_navigation.reset_layout": "Restablecer la disposición",
+  "ui.shell.sidebar_navigation.reset_note": "Disposición de la barra lateral restablecida.",
+  "ui.shell.sidebar_navigation.row_actions": "Acciones para {name}",
+  "ui.shell.sidebar_navigation.save_failed": "No se pudo guardar la disposición de la barra lateral.",
   "ui.shell.sidebar_navigation.schedules": "Programaciones",
   "ui.shell.sidebar_navigation.search": "Buscar",
   "ui.shell.sidebar_navigation.search_accessible": "Buscar en todo ({everything}) — chats ({chats})",
   "ui.shell.sidebar_navigation.search_tooltip": "Buscar en todo ({everything}) · tus chats ({chats})",
   "ui.shell.sidebar_navigation.settings": "Ajustes",
+  "ui.shell.sidebar_navigation.show_in_sidebar": "Mostrar en la barra lateral",
+  "ui.shell.sidebar_navigation.show_in_sidebar_note": "{name} ahora aparece en la barra lateral.",
   "ui.shell.user_profile_sidebar.account_settings": "Ajustes de cuenta",
   "ui.shell.user_profile_sidebar.account_unavailable": "Cuenta no disponible",
   "ui.shell.user_profile_sidebar.checking_account": "Comprobando la cuenta…",
@@ -43645,17 +45356,31 @@ const frUiShell = {
   "ui.shell.sidebar_navigation.browser_waiting": "Navigateur, {count, plural, one {{countText} approbation en attente} many {{countText} d’approbations en attente} other {{countText} approbations en attente}}",
   "ui.shell.sidebar_navigation.close_sidebar": "Fermer la barre latérale",
   "ui.shell.sidebar_navigation.collapse_sidebar": "Réduire la barre latérale",
+  "ui.shell.sidebar_navigation.drag_armed": "Déplacement de {name}. Appuyez sur Esc pour annuler.",
   "ui.shell.sidebar_navigation.expand_sidebar": "Développer la barre latérale",
   "ui.shell.sidebar_navigation.mesh": "Maillage",
   "ui.shell.sidebar_navigation.mesh_waiting": "Mesh, {count, plural, one {{countText} demande en attente} many {{countText} de demandes en attente} other {{countText} demandes en attente}}",
+  "ui.shell.sidebar_navigation.more_waiting": "Plus, {count, plural, one {{countText} en attente} many {{countText} en attente} other {{countText} en attente}}",
+  "ui.shell.sidebar_navigation.more_working": "Plus, en cours",
+  "ui.shell.sidebar_navigation.move_down": "Déplacer vers le bas",
+  "ui.shell.sidebar_navigation.move_note": "{name} est maintenant en position {position} sur {total}.",
+  "ui.shell.sidebar_navigation.move_to_more": "Déplacer vers Plus",
+  "ui.shell.sidebar_navigation.move_to_more_note": "{name} fait maintenant partie de Plus.",
+  "ui.shell.sidebar_navigation.move_up": "Déplacer vers le haut",
   "ui.shell.sidebar_navigation.new_chat": "Nouvelle conversation",
   "ui.shell.sidebar_navigation.new_chat_shortcut": "Nouvelle conversation ({shortcut})",
   "ui.shell.sidebar_navigation.projects": "Projets",
+  "ui.shell.sidebar_navigation.reset_layout": "Réinitialiser la disposition",
+  "ui.shell.sidebar_navigation.reset_note": "Disposition de la barre latérale réinitialisée.",
+  "ui.shell.sidebar_navigation.row_actions": "Actions pour {name}",
+  "ui.shell.sidebar_navigation.save_failed": "Impossible d’enregistrer la disposition de la barre latérale.",
   "ui.shell.sidebar_navigation.schedules": "Planifications",
   "ui.shell.sidebar_navigation.search": "Rechercher",
   "ui.shell.sidebar_navigation.search_accessible": "Rechercher ({everything}) — conversations ({chats})",
   "ui.shell.sidebar_navigation.search_tooltip": "Tout rechercher ({everything}) · vos conversations ({chats})",
   "ui.shell.sidebar_navigation.settings": "Paramètres",
+  "ui.shell.sidebar_navigation.show_in_sidebar": "Afficher dans la barre latérale",
+  "ui.shell.sidebar_navigation.show_in_sidebar_note": "{name} apparaît maintenant dans la barre latérale.",
   "ui.shell.user_profile_sidebar.account_settings": "Paramètres du compte",
   "ui.shell.user_profile_sidebar.account_unavailable": "Compte indisponible",
   "ui.shell.user_profile_sidebar.checking_account": "Vérification du compte…",
@@ -47167,17 +48892,31 @@ const hiUiShell = {
   "ui.shell.sidebar_navigation.browser_waiting": "ब्राउज़र, {count, plural, one {{countText} इंतज़ार में} other {{countText} इंतज़ार में}}",
   "ui.shell.sidebar_navigation.close_sidebar": "साइडबार बंद करें",
   "ui.shell.sidebar_navigation.collapse_sidebar": "साइडबार समेटें",
+  "ui.shell.sidebar_navigation.drag_armed": "{name} को ले जाया जा रहा है। रद्द करने के लिए Esc दबाएँ।",
   "ui.shell.sidebar_navigation.expand_sidebar": "साइडबार फैलाएँ",
   "ui.shell.sidebar_navigation.mesh": "मेश",
   "ui.shell.sidebar_navigation.mesh_waiting": "मेश, {count, plural, one {{countText} इंतज़ार में} other {{countText} इंतज़ार में}}",
+  "ui.shell.sidebar_navigation.more_waiting": "और, {count, plural, one {{countText} इंतज़ार में} other {{countText} इंतज़ार में}}",
+  "ui.shell.sidebar_navigation.more_working": "और, काम जारी है",
+  "ui.shell.sidebar_navigation.move_down": "नीचे ले जाएँ",
+  "ui.shell.sidebar_navigation.move_note": "{name} को कुल {total} में से स्थान {position} पर ले जाया गया।",
+  "ui.shell.sidebar_navigation.move_to_more": "और सेक्शन में ले जाएँ",
+  "ui.shell.sidebar_navigation.move_to_more_note": "{name} को और सेक्शन में ले जाया गया।",
+  "ui.shell.sidebar_navigation.move_up": "ऊपर ले जाएँ",
   "ui.shell.sidebar_navigation.new_chat": "नई चैट",
   "ui.shell.sidebar_navigation.new_chat_shortcut": "नई चैट ({shortcut})",
   "ui.shell.sidebar_navigation.projects": "प्रोजेक्ट",
+  "ui.shell.sidebar_navigation.reset_layout": "साइडबार लेआउट रीसेट करें",
+  "ui.shell.sidebar_navigation.reset_note": "साइडबार लेआउट रीसेट हो गया।",
+  "ui.shell.sidebar_navigation.row_actions": "{name} की कार्रवाइयाँ",
+  "ui.shell.sidebar_navigation.save_failed": "साइडबार लेआउट सहेजा नहीं जा सका।",
   "ui.shell.sidebar_navigation.schedules": "शेड्यूल",
   "ui.shell.sidebar_navigation.search": "खोजें",
   "ui.shell.sidebar_navigation.search_accessible": "खोजें ({everything}) — चैट ({chats})",
   "ui.shell.sidebar_navigation.search_tooltip": "सब कुछ खोजें ({everything}) · आपकी चैट ({chats})",
   "ui.shell.sidebar_navigation.settings": "सेटिंग्स",
+  "ui.shell.sidebar_navigation.show_in_sidebar": "साइडबार में दिखाएँ",
+  "ui.shell.sidebar_navigation.show_in_sidebar_note": "{name} अब साइडबार में है।",
   "ui.shell.user_profile_sidebar.account_settings": "खाते की सेटिंग्स",
   "ui.shell.user_profile_sidebar.account_unavailable": "खाता उपलब्ध नहीं",
   "ui.shell.user_profile_sidebar.checking_account": "खाता जाँचा जा रहा है…",
@@ -50528,17 +52267,31 @@ const ruUiShell = {
   "ui.shell.sidebar_navigation.browser_waiting": "Браузер, {count, plural, one {ожидает {countText}} few {ожидают {countText}} many {ожидают {countText}} other {ожидают {countText}}}",
   "ui.shell.sidebar_navigation.close_sidebar": "Закрыть боковую панель",
   "ui.shell.sidebar_navigation.collapse_sidebar": "Свернуть боковую панель",
+  "ui.shell.sidebar_navigation.drag_armed": "Перемещение: {name}. Нажмите Esc, чтобы отменить.",
   "ui.shell.sidebar_navigation.expand_sidebar": "Развернуть боковую панель",
   "ui.shell.sidebar_navigation.mesh": "Меш-сеть",
   "ui.shell.sidebar_navigation.mesh_waiting": "Меш-сеть, {count, plural, one {ожидает {countText}} few {ожидают {countText}} many {ожидают {countText}} other {ожидают {countText}}}",
+  "ui.shell.sidebar_navigation.more_waiting": "Ещё, {count, plural, one {ожидает {countText}} few {ожидают {countText}} many {ожидают {countText}} other {ожидают {countText}}}",
+  "ui.shell.sidebar_navigation.more_working": "Ещё, идёт работа",
+  "ui.shell.sidebar_navigation.move_down": "Переместить ниже",
+  "ui.shell.sidebar_navigation.move_note": "{name} теперь на позиции {position} из {total}.",
+  "ui.shell.sidebar_navigation.move_to_more": "Переместить в «Ещё»",
+  "ui.shell.sidebar_navigation.move_to_more_note": "{name} теперь в «Ещё».",
+  "ui.shell.sidebar_navigation.move_up": "Переместить выше",
   "ui.shell.sidebar_navigation.new_chat": "Новый чат",
   "ui.shell.sidebar_navigation.new_chat_shortcut": "Новый чат ({shortcut})",
   "ui.shell.sidebar_navigation.projects": "Проекты",
+  "ui.shell.sidebar_navigation.reset_layout": "Сбросить расположение боковой панели",
+  "ui.shell.sidebar_navigation.reset_note": "Расположение боковой панели сброшено.",
+  "ui.shell.sidebar_navigation.row_actions": "Действия для {name}",
+  "ui.shell.sidebar_navigation.save_failed": "Не удалось сохранить расположение боковой панели.",
   "ui.shell.sidebar_navigation.schedules": "Расписания",
   "ui.shell.sidebar_navigation.search": "Поиск",
   "ui.shell.sidebar_navigation.search_accessible": "Поиск ({everything}) — чаты ({chats})",
   "ui.shell.sidebar_navigation.search_tooltip": "Поиск по всему ({everything}) · ваши чаты ({chats})",
   "ui.shell.sidebar_navigation.settings": "Настройки",
+  "ui.shell.sidebar_navigation.show_in_sidebar": "Показать на боковой панели",
+  "ui.shell.sidebar_navigation.show_in_sidebar_note": "{name} теперь отображается на боковой панели.",
   "ui.shell.user_profile_sidebar.account_settings": "Настройки учётной записи",
   "ui.shell.user_profile_sidebar.account_unavailable": "Учётная запись недоступна",
   "ui.shell.user_profile_sidebar.checking_account": "Проверка учётной записи…",
@@ -53975,17 +55728,31 @@ const urUiShell = {
   "ui.shell.sidebar_navigation.browser_waiting": "براؤزر، {count, plural, one {{countText} منتظر} other {{countText} منتظر}}",
   "ui.shell.sidebar_navigation.close_sidebar": "سائیڈ بار بند کریں",
   "ui.shell.sidebar_navigation.collapse_sidebar": "سائیڈ بار سمیٹیں",
+  "ui.shell.sidebar_navigation.drag_armed": "{name} منتقل کیا جا رہا ہے۔ منسوخ کرنے کے لیے Esc دبائیں۔",
   "ui.shell.sidebar_navigation.expand_sidebar": "سائیڈ بار پھیلائیں",
   "ui.shell.sidebar_navigation.mesh": "Mesh",
   "ui.shell.sidebar_navigation.mesh_waiting": "Mesh، {count, plural, one {{countText} منتظر} other {{countText} منتظر}}",
+  "ui.shell.sidebar_navigation.more_waiting": "مزید، {count, plural, one {{countText} منتظر} other {{countText} منتظر}}",
+  "ui.shell.sidebar_navigation.more_working": "مزید، کام جاری ہے",
+  "ui.shell.sidebar_navigation.move_down": "نیچے کریں",
+  "ui.shell.sidebar_navigation.move_note": "{name} کو {total} میں سے {position} مقام پر منتقل کر دیا گیا۔",
+  "ui.shell.sidebar_navigation.move_to_more": "مزید حصے میں منتقل کریں",
+  "ui.shell.sidebar_navigation.move_to_more_note": "{name} کو مزید حصے میں منتقل کر دیا گیا۔",
+  "ui.shell.sidebar_navigation.move_up": "اوپر کریں",
   "ui.shell.sidebar_navigation.new_chat": "نئی چیٹ",
   "ui.shell.sidebar_navigation.new_chat_shortcut": "نئی چیٹ — {shortcut}",
   "ui.shell.sidebar_navigation.projects": "پروجیکٹس",
+  "ui.shell.sidebar_navigation.reset_layout": "سائیڈ بار کا لے آؤٹ ری سیٹ کریں",
+  "ui.shell.sidebar_navigation.reset_note": "سائیڈ بار کا لے آؤٹ ری سیٹ ہو گیا۔",
+  "ui.shell.sidebar_navigation.row_actions": "{name} کے لیے اقدامات",
+  "ui.shell.sidebar_navigation.save_failed": "سائیڈ بار کا لے آؤٹ محفوظ نہیں ہو سکا۔",
   "ui.shell.sidebar_navigation.schedules": "شیڈول",
   "ui.shell.sidebar_navigation.search": "تلاش کریں",
   "ui.shell.sidebar_navigation.search_accessible": "تلاش — {everything} — چیٹس — {chats}",
   "ui.shell.sidebar_navigation.search_tooltip": "سب کچھ تلاش کریں — {everything} · آپ کی چیٹس — {chats}",
   "ui.shell.sidebar_navigation.settings": "ترتیبات",
+  "ui.shell.sidebar_navigation.show_in_sidebar": "سائیڈ بار میں دکھائیں",
+  "ui.shell.sidebar_navigation.show_in_sidebar_note": "{name} اب سائیڈ بار میں ہے۔",
   "ui.shell.user_profile_sidebar.account_settings": "اکاؤنٹ کی ترتیبات",
   "ui.shell.user_profile_sidebar.account_unavailable": "اکاؤنٹ دستیاب نہیں",
   "ui.shell.user_profile_sidebar.checking_account": "اکاؤنٹ کی جانچ ہو رہی ہے…",
@@ -57145,17 +58912,31 @@ const viUiShell = {
   "ui.shell.sidebar_navigation.browser_waiting": "Trình duyệt, {count, plural, other {{countText} đang chờ}}",
   "ui.shell.sidebar_navigation.close_sidebar": "Đóng thanh bên",
   "ui.shell.sidebar_navigation.collapse_sidebar": "Thu gọn thanh bên",
+  "ui.shell.sidebar_navigation.drag_armed": "Đang chuyển {name}. Nhấn Esc để hủy.",
   "ui.shell.sidebar_navigation.expand_sidebar": "Mở rộng thanh bên",
   "ui.shell.sidebar_navigation.mesh": "Mạng lưới",
   "ui.shell.sidebar_navigation.mesh_waiting": "Mạng lưới, {count, plural, other {{countText} đang chờ}}",
+  "ui.shell.sidebar_navigation.more_waiting": "Khác, {count, plural, other {{countText} đang chờ}}",
+  "ui.shell.sidebar_navigation.more_working": "Khác, đang làm việc",
+  "ui.shell.sidebar_navigation.move_down": "Chuyển xuống",
+  "ui.shell.sidebar_navigation.move_note": "Đã chuyển {name} đến vị trí {position} trên {total}.",
+  "ui.shell.sidebar_navigation.move_to_more": "Chuyển vào mục Khác",
+  "ui.shell.sidebar_navigation.move_to_more_note": "Đã chuyển {name} vào mục Khác.",
+  "ui.shell.sidebar_navigation.move_up": "Chuyển lên",
   "ui.shell.sidebar_navigation.new_chat": "Cuộc trò chuyện mới",
   "ui.shell.sidebar_navigation.new_chat_shortcut": "Cuộc trò chuyện mới ({shortcut})",
   "ui.shell.sidebar_navigation.projects": "Dự án",
+  "ui.shell.sidebar_navigation.reset_layout": "Đặt lại bố cục thanh bên",
+  "ui.shell.sidebar_navigation.reset_note": "Đã đặt lại bố cục thanh bên.",
+  "ui.shell.sidebar_navigation.row_actions": "Thao tác cho {name}",
+  "ui.shell.sidebar_navigation.save_failed": "Không lưu được bố cục thanh bên.",
   "ui.shell.sidebar_navigation.schedules": "Lịch chạy",
   "ui.shell.sidebar_navigation.search": "Tìm kiếm",
   "ui.shell.sidebar_navigation.search_accessible": "Tìm kiếm ({everything}) — cuộc trò chuyện ({chats})",
   "ui.shell.sidebar_navigation.search_tooltip": "Tìm mọi thứ ({everything}) · cuộc trò chuyện của bạn ({chats})",
   "ui.shell.sidebar_navigation.settings": "Cài đặt",
+  "ui.shell.sidebar_navigation.show_in_sidebar": "Hiện trong thanh bên",
+  "ui.shell.sidebar_navigation.show_in_sidebar_note": "{name} đã được hiển thị trong thanh bên.",
   "ui.shell.user_profile_sidebar.account_settings": "Cài đặt tài khoản",
   "ui.shell.user_profile_sidebar.account_unavailable": "Không truy cập được tài khoản",
   "ui.shell.user_profile_sidebar.checking_account": "Đang kiểm tra tài khoản…",
@@ -60614,17 +62395,31 @@ const zhCNUiShell = {
   "ui.shell.sidebar_navigation.browser_waiting": "浏览器，{count, plural, other {{countText}项待处理}}",
   "ui.shell.sidebar_navigation.close_sidebar": "关闭侧边栏",
   "ui.shell.sidebar_navigation.collapse_sidebar": "收起侧边栏",
+  "ui.shell.sidebar_navigation.drag_armed": "正在移动{name}。按Esc取消。",
   "ui.shell.sidebar_navigation.expand_sidebar": "展开侧边栏",
   "ui.shell.sidebar_navigation.mesh": "网格",
   "ui.shell.sidebar_navigation.mesh_waiting": "网格，{count, plural, other {{countText}项待处理}}",
+  "ui.shell.sidebar_navigation.more_waiting": "更多，{count, plural, other {{countText}项待处理}}",
+  "ui.shell.sidebar_navigation.more_working": "更多，工作中",
+  "ui.shell.sidebar_navigation.move_down": "下移",
+  "ui.shell.sidebar_navigation.move_note": "已将{name}移至第{position}位，共{total}个。",
+  "ui.shell.sidebar_navigation.move_to_more": "移至更多",
+  "ui.shell.sidebar_navigation.move_to_more_note": "{name}已移至更多。",
+  "ui.shell.sidebar_navigation.move_up": "上移",
   "ui.shell.sidebar_navigation.new_chat": "新建对话",
   "ui.shell.sidebar_navigation.new_chat_shortcut": "新建对话（{shortcut}）",
   "ui.shell.sidebar_navigation.projects": "项目",
+  "ui.shell.sidebar_navigation.reset_layout": "重置侧边栏布局",
+  "ui.shell.sidebar_navigation.reset_note": "侧边栏布局已重置。",
+  "ui.shell.sidebar_navigation.row_actions": "{name}的操作",
+  "ui.shell.sidebar_navigation.save_failed": "无法保存侧边栏布局。",
   "ui.shell.sidebar_navigation.schedules": "定时任务",
   "ui.shell.sidebar_navigation.search": "搜索",
   "ui.shell.sidebar_navigation.search_accessible": "搜索（{everything}）—对话（{chats}）",
   "ui.shell.sidebar_navigation.search_tooltip": "搜索全部内容（{everything}）·搜索对话（{chats}）",
   "ui.shell.sidebar_navigation.settings": "设置",
+  "ui.shell.sidebar_navigation.show_in_sidebar": "在侧边栏中显示",
+  "ui.shell.sidebar_navigation.show_in_sidebar_note": "{name}已显示在侧边栏中。",
   "ui.shell.user_profile_sidebar.account_settings": "账户设置",
   "ui.shell.user_profile_sidebar.account_unavailable": "账户不可用",
   "ui.shell.user_profile_sidebar.checking_account": "正在检查账户……",
@@ -62955,10 +64750,29 @@ function mintNonce() {
   return node_crypto.randomBytes(16).toString("hex");
 }
 class TabRegistry {
-  constructor(viewFactory, onRemove, onChanged) {
+  /**
+   * The fourth callback is a post-layout observer, optional and defaulted so
+   * every existing three-argument construction is unchanged.
+   *
+   * WHY IT EXISTS: a native child positioned over a page has to know that the
+   * presented tab, its presentation bit or the content rectangle moved. Polling
+   * the registry would read a rectangle that is already stale, and `onChanged`
+   * is deliberately NOT that signal (`setContentRect` does not call it). The
+   * snapshot is copied and delivered after every pass — including null and
+   * suppressed layouts — because "nothing is presented now" is exactly when a
+   * stale overlay must hide.
+   *
+   * WHY IT CANNOT FAIL THE LAYOUT: page geometry is the product's behaviour and
+   * an observer is infrastructure around it. A throwing observer is swallowed
+   * here (the controller logs its own failure) so one experimental child can
+   * never leave pages unlaid-out.
+   */
+  constructor(viewFactory, onRemove, onChanged, onLayout = () => {
+  }) {
     this.viewFactory = viewFactory;
     this.onRemove = onRemove;
     this.onChanged = onChanged;
+    this.onLayout = onLayout;
   }
   tabs = /* @__PURE__ */ new Map();
   nextTabId = 1;
@@ -62968,6 +64782,9 @@ class TabRegistry {
   /** Tabs with a command in flight, keyed by tabId. See `lane`. */
   busy = /* @__PURE__ */ new Set();
   epochListeners = [];
+  /** Monotone count of layout passes, for an observer that needs identity, not
+   * just values (S1's address overlay). */
+  layoutRevision = 0;
   // ---- creation, addressing, listing ---------------------------------------
   /**
    * Create a tab. A user tab becomes active (the user asked for it); an AGENT
@@ -63244,8 +65061,8 @@ 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
@@ -63270,6 +65087,22 @@ class TabRegistry {
       );
       record.view.setVisible(record.presented);
     }
+    this.layoutRevision += 1;
+    const rect2 = this.contentRect;
+    try {
+      this.onLayout({
+        activeTabId: this.activeTabId,
+        presented: active?.presented === true,
+        contentRect: rect2 ? {
+          x: rect2.x,
+          y: rect2.y,
+          width: rect2.width,
+          height: rect2.height
+        } : null,
+        revision: this.layoutRevision
+      });
+    } catch {
+    }
   }
   // ---- removal -------------------------------------------------------------
   /**
@@ -65433,9 +67266,9 @@ 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
@@ -66460,7 +68293,15 @@ const BROWSER_IPC_CHANNELS = [
   "browser-reveal-downloads",
   /** The user's own recovery click on the `unavailable` state (round 1, D1a).
    * Named here so the namespace stays the one place that lists its channels. */
-  "browser-retry"
+  "browser-retry",
+  /**
+   * S1's probe-only channel. Listed here for unregistration only: the handler
+   * below is registered only when the launch gate passed, and this entry makes
+   * `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_PROJECT
 ];
 function registerBrowserIpc(options) {
   function authorizeSender(event) {
@@ -66605,9 +68446,9 @@ 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);
@@ -66706,6 +68547,42 @@ function registerBrowserIpc(options) {
     await options.retry();
     return { retried: true };
   });
+  if (options.addressOverlayProbe) {
+    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);
+      }
+    );
+  }
+  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);
+      }
+    );
+  }
 }
 function unregisterBrowserIpc() {
   for (const channel of BROWSER_IPC_CHANNELS) electron.ipcMain.removeHandler(channel);
@@ -66769,17 +68646,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) {
@@ -68683,6 +70560,37 @@ function startBrowserHost(options) {
       await startBrowserHost(options).catch(() => {
       });
     },
+    /*
+     * S1's probe channel is registered ONLY when this launch's gate passed, and
+     * then it reads the current attempt's callback through `bindings` (a retry
+     * replaces it) rather than capturing a controller here.
+     */
+    ...options.addressOverlay?.enabled ? {
+      addressOverlayProbe: (action, argument) => {
+        const probe = bindings.addressOverlayProbe;
+        if (!probe) {
+          throw new Error(
+            "address_overlay_unavailable: the overlay controller is not running."
+          );
+        }
+        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
   });
   starting = startWithRetries({
@@ -68719,6 +70627,7 @@ async function initializeBrowserHost(options, bindings) {
   };
   try {
     let releaseTab = function(tabId, webContentsId) {
+      addressOverlay?.onTabReleased(tabId);
       const view = views.get(tabId);
       views.delete(tabId);
       downloads.forget(tabId);
@@ -68870,6 +70779,9 @@ async function initializeBrowserHost(options, bindings) {
       });
       contents.on("did-stop-loading", notifyChrome);
       contents.on("page-title-updated", notifyChrome);
+      contents.on("render-process-gone", () => {
+        addressOverlay?.onPageGone(tabId);
+      });
       contents.on(
         "did-fail-load",
         (_event, code, description, url, isMainFrame) => {
@@ -69064,6 +70976,27 @@ async function initializeBrowserHost(options, bindings) {
     const views = /* @__PURE__ */ new Map();
     const releases = /* @__PURE__ */ new Set();
     let stateWriter = null;
+    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,
+        type: metric.type
+      }))
+    }) : null;
     const sessionStore = new BrowserSessionStore({
       dir: path$1.join(options.userDataDir, "browser"),
       log: log2
@@ -69104,7 +71037,9 @@ async function initializeBrowserHost(options, bindings) {
     };
     const notifyChanged = () => {
       stateWriter?.publishNow();
-      options.window.webContents.send("browser-state-changed");
+      if (!options.window.isDestroyed() && !options.window.webContents.isDestroyed()) {
+        options.window.webContents.send("browser-state-changed");
+      }
       captureSession();
     };
     const registry = new TabRegistry(
@@ -69115,7 +71050,8 @@ async function initializeBrowserHost(options, bindings) {
         return view;
       },
       releaseTab,
-      notifyChanged
+      notifyChanged,
+      (snapshot2) => addressOverlay?.onLayout(snapshot2)
     );
     registryForDownloads = registry;
     rollback.add(async () => {
@@ -69124,6 +71060,7 @@ async function initializeBrowserHost(options, bindings) {
       registry.destroyAll();
       await Promise.allSettled([...releases]);
     });
+    rollback.add(() => addressOverlay?.dispose("startup-rollback"));
     const ownership = new OwnershipLedger({
       mayAdopt: (token, requester) => {
         const record = registry.requireSurface(token);
@@ -69150,7 +71087,9 @@ async function initializeBrowserHost(options, bindings) {
     const approvals = new ApprovalStore({
       dir: path$1.join(options.userDataDir, "browser"),
       onChanged: () => {
-        options.window.webContents.send("browser-consent-changed");
+        if (!options.window.isDestroyed() && !options.window.webContents.isDestroyed()) {
+          options.window.webContents.send("browser-consent-changed");
+        }
         consentNotifier.announce(approvals.pendingEntries());
       },
       log: log2
@@ -69232,6 +71171,7 @@ async function initializeBrowserHost(options, bindings) {
       host.clearPageFocus();
     };
     const resetMenuShortcutSuppression = () => {
+      if (options.window.isDestroyed()) return;
       if (!options.window.webContents.isDestroyed())
         options.window.webContents.setIgnoreMenuShortcuts(false);
     };
@@ -69249,6 +71189,7 @@ async function initializeBrowserHost(options, bindings) {
     options.window.webContents.on("render-process-gone", resetChordFocus);
     const detachChords = () => {
       host.clearChordState();
+      if (options.window.isDestroyed()) return;
       options.window.webContents.removeListener(
         "before-input-event",
         onChromeInput
@@ -69358,6 +71299,36 @@ async function initializeBrowserHost(options, bindings) {
     );
     rollback.add(() => stateWriter?.clear());
     stateWriter.start(server.port, sessionKey);
+    const probeAddressOverlay = async (action, argument) => {
+      if (!addressOverlay) {
+        throw new Error(
+          "address_overlay_unavailable: this host owns no controller."
+        );
+      }
+      const facts2 = await addressOverlay.probe(action, argument);
+      const record = registry.activeTab;
+      const page = record ? {
+        tabId: record.tabId,
+        presented: record.presented,
+        bounds: record.view.getBounds?.() ?? null,
+        visible: record.view.getVisible?.() ?? false
+      } : 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,
       expectedUrl: options.expectedUrl,
@@ -69387,6 +71358,7 @@ async function initializeBrowserHost(options, bindings) {
       profileDir,
       agentTabs: () => registry.agentTabCount(),
       sessionCookies: () => restoreReport,
+      ...addressOverlay ? { addressOverlay: probeAddressOverlay } : {},
       stop: async () => {
         detachChords();
         const atStop = captureTabs(
@@ -69401,6 +71373,7 @@ async function initializeBrowserHost(options, bindings) {
           );
         }
         sessionStore.flush();
+        addressOverlay?.dispose("host-stop");
         registry.destroyAll();
         await Promise.allSettled([...releases]);
         await cdp.close();
@@ -70419,57 +72392,6 @@ class DesktopNotifier {
     notification.show();
   }
 }
-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 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 FRAME_LABEL = /^[a-z0-9][a-z0-9_-]{0,63}$/;
 function registerDevDriverIPC(options) {
   const { window, expectedUrl, outDir, identity: identity2 } = options;
@@ -80764,6 +82686,17 @@ const devDriverArming = resolveDevDriverArming({
 });
 const devDriverLine = describeDevDriverArming(devDriverArming);
 if (devDriverLine) console.log(devDriverLine);
+const addressOverlayGate = resolveAddressOverlayGate({
+  env: launchEnv,
+  devDriverArmed: devDriverArming.armed,
+  windowMode: windowLaunch.mode,
+  packaged: electron.app.isPackaged
+});
+if (addressOverlayGate.asked) {
+  console.log(
+    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)] } : {};
 const telemetryWebPreferences = {
   additionalArguments: [telemetryArgument(telemetryLaunch.enabled)]
@@ -81035,7 +82968,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") {
@@ -81050,12 +82986,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);
@@ -81167,6 +83114,7 @@ electron.app.whenReady().then(async () => {
   });
   const rendererUrl = rendererDocumentUrl();
   const consoleCaptureUrl = consoleCaptureUrlFor(rendererUrl);
+  const addressOverlayDocumentUrl = addressOverlayGate.list ? addressListDocumentUrlFor(rendererUrl) : addressOverlayDocumentUrlFor(rendererUrl);
   backendService.observeDesktopFeed(
     (frame) => {
       if (frame.type === "notification") {
@@ -81975,6 +83923,16 @@ electron.app.whenReady().then(async () => {
         // document, and the preload every renderer in this app gets, which is what
         // lets main feed the reconstruction to it.
         consoleCaptureUrl,
+        // S1: only a gated headless probe arm gets this option at all. The
+        // URL is this app's own packaged document, not a caller's string.
+        ...addressOverlayGate.enabled ? {
+          addressOverlay: {
+            enabled: true,
+            list: addressOverlayGate.list,
+            visible: addressOverlayGate.visible,
+            documentUrl: addressOverlayDocumentUrl
+          }
+        } : {},
         preloadPath: path$1.join(__dirname, "../preload/index.js"),
         /*
          * The console's surfaces are handed the user's own PATH, from the same