getobsrv 0.5.0 → 0.7.0

package/README.md

@@ -85,9 +85,25 @@ If the desktop app is open with the toolbar's **Agent control** toggle on,
 the preset flip, and the agent gets back a capture of the app exactly as you
 see it (plus `obsrv_drive` to flip URL/preset/profile directly). Agents can
 also scroll, click, pan and highlight while you watch — a drive session works
-as a guided demo. With no app running, everything falls back to the headless
+as a guided demo. A `scroll` reports the offset it actually reached
+(`scrolled` / `scroller`), finds the inner scroll container on pages whose
+root cannot scroll, and takes a `scrollSelector` when you need to name the
+container yourself. With no app running, everything falls back to the headless
 render automatically.
 
+To photograph a scrolled or panned state, pass `capture: 'window' | 'pane'` to
+`obsrv_drive`: it captures after its commands run, and nothing in that tool
+navigates unless you pass `url`, so the scroll survives the shutter. A live
+`obsrv_snap` only navigates when the app is showing a *different* URL — its
+`navigated` field says which happened — and navigating is a fresh load, which
+starts at the top of the page.
+
+A headless `snap` returns `settled: true` when the page went paint-quiet and
+every pixel painted. `settled: false` is still a usable capture, not a
+failure — a page that kept animating, or one whose repaint never completed,
+comes back as-is (exit code 0) with a warning saying what was missing. Only a
+render that painted nothing at all is an error.
+
 Build first, then register:
 
 ```bash
@@ -119,6 +135,11 @@ yet notarised, so macOS falsely reports it as "damaged"):
 xattr -cr /Applications/Obsrv.app
 ```
 
+Obsrv checks GitHub for a newer release once a day and, when there is one, shows
+it in the toolbar; clicking opens the release page. It is a single
+unauthenticated request carrying no identifiers, and Settings → Updates turns it
+off.
+
 ## Distribution
 
 Publish via a packed tarball, never bare `npm publish`: `npm publish` snapshots
@@ -140,6 +161,16 @@ belongs to an unrelated package.
   looks different again; a Windows build would show Windows truth natively.
 - Panel simulation is an approximation, not colourimetric.
 - Non-ASCII text input does not type into the target pane (Electron `sendInputEvent`
-  limitation); nested scroll containers aren't mirrored.
+  limitation).
+- Inner-scroller *reporting* is one-way. An agent `scroll` finds the page's real scroll
+  host — the app-shell pattern (`html, body { overflow: hidden }` with an inner
+  `overflow-y: auto` container) is handled, and the result reports the offset actually
+  reached — but scrolling a nested container **by hand** in the native pane is not
+  mirrored to the target: element scroll events don't bubble to `window`, so the report
+  side never sees them. Dragging the page itself still syncs both ways.
+- Scroll targeting stops at the light DOM of the top-level document. A scroller inside a
+  shadow root or an iframe can't be found automatically *or* named with `scrollSelector`
+  (`document.querySelector` doesn't cross either boundary), so a web-component app that
+  hides its scroller in a shadow root has no escape hatch.
 - Frame delivery has no renderer-side backpressure mailbox (see plan header); at 30 fps
   with dirty rects it has not been needed.

package/out/cli/args.js

@@ -44,7 +44,11 @@ diff flags:
 
 Repeated flags: the last occurrence wins.
 Machine output (JSON) goes to stdout; everything human goes to stderr.
-Exit code 0 on success — diff findings are informational, never a failure.`;
+Exit code 0 on success — diff findings are informational, never a failure.
+snap's "settled" is true when the page went paint-quiet and every pixel
+painted. False is a rescued capture, not a failure: a page that kept animating
+(or whose repaint never completed) is written as-is, exit code 0, with a
+warning naming what was missing. Only a render that painted nothing errors.`;
 }
 /** Flags that take no value. */
 const BOOLEAN_FLAGS = new Set(['full-page', 'json']);

package/out/main/cli.js

@@ -3,7 +3,7 @@ const electron = require("electron");
 const node_fs = require("node:fs");
 const node_os = require("node:os");
 const node_path = require("node:path");
-const targetSource = require("./targetSource-DkXWE0ha.js");
+const targetSource = require("./targetSource-CbJwfugi.js");
 function boxDownsample(src, factor) {
   if (!Number.isInteger(factor) || factor < 1) throw new RangeError("factor must be an integer >= 1");
   const width = Math.floor(src.width / factor);
@@ -75,7 +75,11 @@ diff flags:
 
 Repeated flags: the last occurrence wins.
 Machine output (JSON) goes to stdout; everything human goes to stderr.
-Exit code 0 on success — diff findings are informational, never a failure.`;
+Exit code 0 on success — diff findings are informational, never a failure.
+snap's "settled" is true when the page went paint-quiet and every pixel
+painted. False is a rescued capture, not a failure: a page that kept animating
+(or whose repaint never completed) is written as-is, exit code 0, with a
+warning naming what was missing. Only a render that painted nothing errors.`;
 }
 const BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["full-page", "json"]);
 const VALUE_FLAGS = /* @__PURE__ */ new Set(["preset", "profile", "out", "out-dir", "wait", "timeout", "matrix", "width", "height", "dsf", "diagonal"]);
@@ -218,6 +222,37 @@ ${usage()}`);
 }
 const sleep$1 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 const DEFAULT_SETTLE_MS = 400;
+function uncoveredBounds(mask, width, height) {
+  const rowHasGap = (y) => {
+    const row = y * width;
+    for (let x = 0; x < width; x++) if (mask[row + x] === 0) return true;
+    return false;
+  };
+  let y0 = -1;
+  for (let y = 0; y < height; y++) {
+    if (rowHasGap(y)) {
+      y0 = y;
+      break;
+    }
+  }
+  if (y0 < 0) return null;
+  let y1 = y0;
+  for (let y = height - 1; y > y0; y--) {
+    if (rowHasGap(y)) {
+      y1 = y;
+      break;
+    }
+  }
+  const columnHasGap = (x) => {
+    for (let y = y0; y <= y1; y++) if (mask[y * width + x] === 0) return true;
+    return false;
+  };
+  let x0 = 0;
+  while (x0 < width && !columnHasGap(x0)) x0++;
+  let x1 = width - 1;
+  while (x1 > x0 && !columnHasGap(x1)) x1--;
+  return { x: x0, y: y0, width: x1 - x0 + 1, height: y1 - y0 + 1 };
+}
 async function captureQuiescent(source, options = {}) {
   const settleMs = options.settleMs ?? DEFAULT_SETTLE_MS;
   const timeoutMs = options.timeoutMs ?? 3e4;
@@ -228,8 +263,10 @@ async function captureQuiescent(source, options = {}) {
   let mask = null;
   let uncovered = 0;
   let lastPaint = Date.now();
+  let frames = 0;
   const onFrame = (m) => {
     lastPaint = Date.now();
+    frames++;
     if (m.frameWidth !== width || m.frameHeight !== height) {
       width = m.frameWidth;
       height = m.frameHeight;
@@ -275,9 +312,19 @@ async function captureQuiescent(source, options = {}) {
       if (failed) throw failed;
       if (covered && Date.now() - lastPaint >= settleMs) break;
       if (Date.now() >= deadline) {
-        if (!covered) throw new Error(`no full frame painted within ${timeoutMs} ms`);
-        options.onWarn?.(`page kept painting for ${timeoutMs} ms (animation?); capturing the current frame`);
         settled = false;
+        if (covered) {
+          options.onWarn?.(`page kept painting for ${timeoutMs} ms (animation?); capturing the current frame`);
+          break;
+        }
+        if (frames === 0 || width === 0 || height === 0) {
+          throw new Error(`no frame painted within ${timeoutMs} ms`);
+        }
+        const total = width * height;
+        const box = mask ? uncoveredBounds(mask, width, height) : null;
+        options.onWarn?.(
+          `warning: ${(uncovered / total * 100).toFixed(1)}% of the ${width}x${height} frame never painted within ${timeoutMs} ms` + (box ? ` (uncovered region ${box.width}x${box.height} at ${box.x},${box.y})` : "") + `; those pixels are transparent, not page content. Returning the frame as captured (settled: false)`
+        );
         break;
       }
       await sleep$1(Math.min(50, settleMs));
@@ -323,6 +370,7 @@ function inkRows(img) {
   }
   return rows;
 }
+const UNSETTLED_FINDING = "renders did not go paint-quiet within the budget (animation or video), so the two captures are different frames — the band deltas below are frame-to-frame noise, not evidence about rasterisation. Compare a static page, or pass a longer --timeout if the page merely settles late.";
 function bandInk(img, y0, y1) {
   let ink = 0;
   for (let y = y0; y < y1; y++) {
@@ -334,7 +382,7 @@ function bandInk(img, y0, y1) {
   return pixels === 0 ? 0 : ink / pixels;
 }
 const pct = (v) => `${(v * 100).toFixed(2)}%`;
-function diffMetrics(target, reference, referenceDeviceRows) {
+function diffMetrics(target, reference, referenceDeviceRows, settled = true) {
   if (target.width !== reference.width || target.height !== reference.height) {
     throw new RangeError(
       `diffMetrics: mismatched dimensions (target ${target.width}x${target.height}, reference ${reference.width}x${reference.height})`
@@ -360,6 +408,7 @@ function diffMetrics(target, reference, referenceDeviceRows) {
     }
   }
   return {
+    settled,
     inkCoverage: { target: targetCoverage, reference: referenceCoverage, delta: targetCoverage - referenceCoverage },
     rows: {
       target: targetRows,
@@ -367,7 +416,7 @@ function diffMetrics(target, reference, referenceDeviceRows) {
       ratio: referenceDeviceRows > 0 ? targetRows / referenceDeviceRows : null
     },
     bands,
-    findings
+    findings: settled ? findings : [UNSETTLED_FINDING]
   };
 }
 function profileToParams(p, hostNits) {
@@ -540,7 +589,12 @@ async function runDiff(cmd) {
   const referenceFull = bgraToRgba(r.frame.bgra, r.frame.width, r.frame.height);
   const referenceDeviceRows = inkRows(referenceFull);
   const reference = boxDownsample(referenceFull, 2);
-  const metrics = diffMetrics(target, reference, referenceDeviceRows);
+  const settled = t.frame.settled && r.frame.settled;
+  const warnings = [
+    ...t.warnings.map((w) => `target: ${w}`),
+    ...r.warnings.map((w) => `reference: ${w}`)
+  ];
+  const metrics = diffMetrics(target, reference, referenceDeviceRows, settled);
   let files;
   if (cmd.outDir) {
     const dir = node_path.resolve(cmd.outDir);
@@ -551,14 +605,15 @@ async function runDiff(cmd) {
   }
   const pct2 = (v) => `${(v * 100).toFixed(2)}%`;
   human(
-    `diff ${cmd.url} @ ${cmd.spec.presetId} (profile ${profile.id}): ink ${pct2(metrics.inkCoverage.target)} vs ${pct2(metrics.inkCoverage.reference)} reference, rows ${metrics.rows.target}/${metrics.rows.reference} (ratio ${metrics.rows.ratio?.toFixed(2) ?? "n/a"}), ${metrics.findings.length} finding(s)`
+    `diff ${cmd.url} @ ${cmd.spec.presetId} (profile ${profile.id}): ink ${pct2(metrics.inkCoverage.target)} vs ${pct2(metrics.inkCoverage.reference)} reference, rows ${metrics.rows.target}/${metrics.rows.reference} (ratio ${metrics.rows.ratio?.toFixed(2) ?? "n/a"}), ${metrics.findings.length} finding(s)${settled ? "" : " — UNSETTLED, deltas are not rendering evidence"}`
   );
   await machine({
     url: cmd.url,
     preset: cmd.spec.presetId,
     profile: profile.id,
     ...files ? { files } : {},
-    ...metrics
+    ...metrics,
+    warnings
   });
 }
 const userData = process.env.OBSRV_CLI_USER_DATA ?? node_fs.mkdtempSync(node_path.join(node_os.tmpdir(), "obsrv-cli-"));

package/out/main/index.js

@@ -4,7 +4,7 @@ const node_fs = require("node:fs");
 const promises = require("node:fs/promises");
 const node_path = require("node:path");
 const node_crypto = require("node:crypto");
-const targetSource = require("./targetSource-DkXWE0ha.js");
+const targetSource = require("./targetSource-CbJwfugi.js");
 const node_http = require("node:http");
 const node_url = require("node:url");
 const IPC = {
@@ -28,13 +28,18 @@ const IPC = {
   targetNavigating: "obsrv:target-navigating",
   syncScroll: "obsrv:sync-scroll",
   applyScroll: "obsrv:apply-scroll",
+  scrollResult: "obsrv:scroll-result",
   openImage: "obsrv:open-image",
   focusUrl: "obsrv:focus-url",
   openImagePath: "obsrv:open-image-path",
   readImageFile: "obsrv:read-image-file",
   uiState: "obsrv:ui-state",
   agentApply: "obsrv:agent-apply",
-  agentActivity: "obsrv:agent-activity"
+  agentActivity: "obsrv:agent-activity",
+  getUpdate: "obsrv:get-update",
+  checkUpdate: "obsrv:check-update",
+  openRelease: "obsrv:open-release",
+  updateStatus: "obsrv:update-status"
 };
 function attachFrameBus(target, win) {
   let ready = false;
@@ -68,7 +73,9 @@ function attachFrameBus(target, win) {
     }
   };
 }
+const MAX_SCROLL_SELECTOR = 512;
 const MAX_RECT = 16384;
+const MAX_SCROLL_WARNINGS = 4;
 const isFiniteNumber = (v) => typeof v === "number" && Number.isFinite(v);
 const isRecord$1 = (v) => typeof v === "object" && v !== null;
 function parseRect(raw) {
@@ -133,7 +140,11 @@ function parseSettings(raw) {
   if (!isFiniteNumber(hostNits) || hostNits <= 0) return null;
   const agentControl = raw.agentControl ?? false;
   if (typeof agentControl !== "boolean") return null;
-  return { hostDiagonalInches, hostNits, agentControl };
+  const updateCheck = raw.updateCheck ?? true;
+  if (typeof updateCheck !== "boolean") return null;
+  const lastUpdateCheck = raw.lastUpdateCheck ?? 0;
+  if (!isFiniteNumber(lastUpdateCheck) || lastUpdateCheck < 0) return null;
+  return { hostDiagonalInches, hostNits, agentControl, updateCheck, lastUpdateCheck };
 }
 function parseMode(raw) {
   return raw === "url" || raw === "image" ? raw : null;
@@ -154,6 +165,26 @@ function parseScrollPos(raw) {
   if (!isFiniteNumber(x) || !isFiniteNumber(y) || x < 0 || y < 0) return null;
   return { x, y };
 }
+function parseScrollRequest(raw) {
+  const pos = parseScrollPos(raw);
+  if (!pos) return "scroll payload must be { x, y } with finite, non-negative CSS-pixel offsets";
+  const selector = raw.scrollSelector;
+  if (selector === void 0 || selector === null) return pos;
+  if (typeof selector !== "string") return "scrollSelector must be a CSS selector string";
+  const trimmed = selector.trim();
+  if (trimmed === "") return "scrollSelector must not be empty";
+  if (trimmed.length > MAX_SCROLL_SELECTOR) return `scrollSelector must be at most ${MAX_SCROLL_SELECTOR} characters`;
+  return { ...pos, selector: trimmed };
+}
+function parseScrollReport(raw) {
+  if (!isRecord$1(raw)) return null;
+  const { id, x, y, scroller } = raw;
+  if (!isFiniteNumber(id)) return null;
+  if (!isFiniteNumber(x) || !isFiniteNumber(y)) return null;
+  if (scroller !== "root" && scroller !== "element") return null;
+  const warnings = Array.isArray(raw.warnings) ? raw.warnings.filter((w) => typeof w === "string").slice(0, MAX_SCROLL_WARNINGS) : [];
+  return { id, x, y, scroller, warnings };
+}
 const CONTROL_FILE_NAME = "control.json";
 const CONTROL_TOKEN_BYTES = 32;
 const CONTROL_COMMANDS = [
@@ -239,6 +270,7 @@ function parseHighlight(raw) {
   };
 }
 const isPositive = (v) => typeof v === "number" && Number.isFinite(v) && v > 0;
+const isStamp = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0;
 function loadSettings(file) {
   try {
     const raw = JSON.parse(node_fs.readFileSync(file, "utf8"));
@@ -247,7 +279,11 @@ function loadSettings(file) {
       hostNits: isPositive(raw.hostNits) ? raw.hostNits : targetSource.DEFAULT_SETTINGS.hostNits,
       // Anything but a literal true (older files have no key at all) means off:
       // a network-facing capability must never be enabled by a malformed file.
-      agentControl: raw.agentControl === true
+      agentControl: raw.agentControl === true,
+      // The opposite default: only a literal false turns the update check off,
+      // so a file from before this feature keeps it on.
+      updateCheck: raw.updateCheck !== false,
+      lastUpdateCheck: isStamp(raw.lastUpdateCheck) ? raw.lastUpdateCheck : 0
     };
   } catch {
     return { ...targetSource.DEFAULT_SETTINGS };
@@ -256,9 +292,67 @@ function loadSettings(file) {
 function saveSettings(file, s) {
   if (!isPositive(s.hostDiagonalInches) || !isPositive(s.hostNits)) throw new RangeError("settings values must be finite and > 0");
   if (typeof s.agentControl !== "boolean") throw new RangeError("agentControl must be a boolean");
+  if (typeof s.updateCheck !== "boolean") throw new RangeError("updateCheck must be a boolean");
+  if (!isStamp(s.lastUpdateCheck)) throw new RangeError("lastUpdateCheck must be a finite epoch ms >= 0");
   node_fs.mkdirSync(node_path.dirname(file), { recursive: true });
   node_fs.writeFileSync(file, JSON.stringify(s, null, 2));
 }
+const RELEASES_API = "https://api.github.com/repos/vibesyemmy/obsrv/releases/latest";
+const RELEASE_URL_PREFIX = "https://github.com/vibesyemmy/obsrv/releases/";
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+const CHECK_TIMEOUT_MS = 5e3;
+function parseVersion(raw) {
+  const trimmed = raw.trim().replace(/^v/i, "");
+  if (trimmed === "") return null;
+  const [core = "", ...rest] = trimmed.split("-");
+  const parts = core.split(".").map(Number);
+  if (parts.length === 0 || parts.some((n) => !Number.isInteger(n) || n < 0)) return null;
+  return { parts, pre: rest.length > 0 };
+}
+function isNewer(latest, current) {
+  const a = parseVersion(latest);
+  const b = parseVersion(current);
+  if (!a || !b) return false;
+  const len = Math.max(a.parts.length, b.parts.length);
+  for (let i = 0; i < len; i++) {
+    const x = a.parts[i] ?? 0;
+    const y = b.parts[i] ?? 0;
+    if (x !== y) return x > y;
+  }
+  return !a.pre && b.pre;
+}
+function isReleaseUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return false;
+  }
+  const allowed = new URL(RELEASE_URL_PREFIX);
+  return parsed.protocol === allowed.protocol && parsed.host === allowed.host && parsed.pathname.startsWith(allowed.pathname);
+}
+function readRelease(body, current, now) {
+  let raw;
+  try {
+    raw = JSON.parse(body);
+  } catch {
+    return null;
+  }
+  if (typeof raw !== "object" || raw === null) return null;
+  const { tag_name: tag, html_url: url } = raw;
+  if (typeof tag !== "string" || parseVersion(tag) === null) return null;
+  if (!isNewer(tag, current)) return { state: { status: "current", current, checkedAt: now }, url: "" };
+  if (typeof url !== "string" || !isReleaseUrl(url)) return null;
+  return {
+    state: { status: "available", current, latest: tag.trim().replace(/^v/i, ""), checkedAt: now },
+    url
+  };
+}
+function isCheckDue(lastUpdateCheck, now) {
+  if (!Number.isFinite(lastUpdateCheck) || lastUpdateCheck <= 0) return true;
+  if (lastUpdateCheck > now) return true;
+  return now - lastUpdateCheck >= CHECK_INTERVAL_MS;
+}
 const MAX_BODY_BYTES = 64 * 1024;
 const APPLY_WAIT_MS = 2e3;
 const APPLY_POLL_MS = 25;
@@ -374,10 +468,16 @@ class ControlServer {
         return reply(200, { ok: true, ...capture });
       }
       case "scroll": {
-        const pos = parseScrollPos(payload);
-        if (!pos) return reply(400, { error: "scroll payload must be { x, y } with finite, non-negative CSS-pixel offsets" });
-        this.deps.scroll(pos);
-        return reply(200, { ok: true });
+        const req2 = parseScrollRequest(payload);
+        if (typeof req2 === "string") return reply(400, { error: req2 });
+        const result = await this.deps.scroll(req2);
+        if (!result) return reply(200, { ok: true, scrolled: null, warnings: ["scroll offset could not be confirmed"] });
+        return reply(200, {
+          ok: true,
+          scrolled: { x: result.x, y: result.y },
+          scroller: result.scroller,
+          ...result.warnings.length > 0 ? { warnings: result.warnings } : {}
+        });
       }
       case "panTo": {
         const pos = parseScrollPos(payload);
@@ -453,8 +553,52 @@ class ControlServer {
     });
   }
 }
+async function checkForUpdate(current, now) {
+  const failed = { state: { status: "error", current, checkedAt: now }, url: "" };
+  const endpoint = process.env.OBSRV_RELEASES_API ?? RELEASES_API;
+  return new Promise((resolve) => {
+    let settled = false;
+    const done = (v) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(v);
+    };
+    let request;
+    try {
+      request = electron.net.request({ method: "GET", url: endpoint });
+    } catch {
+      resolve(failed);
+      return;
+    }
+    const timer = setTimeout(() => {
+      request.abort();
+      done(failed);
+    }, CHECK_TIMEOUT_MS);
+    request.setHeader("accept", "application/vnd.github+json");
+    request.setHeader("user-agent", "obsrv-update-check");
+    request.on("response", (response) => {
+      if (response.statusCode !== 200) {
+        response.on("data", () => void 0);
+        response.on("end", () => done(failed));
+        return;
+      }
+      const chunks = [];
+      response.on("data", (c) => chunks.push(Buffer.from(c)));
+      response.on("end", () => {
+        const parsed = readRelease(Buffer.concat(chunks).toString("utf8"), current, now);
+        done(parsed ?? failed);
+      });
+      response.on("error", () => done(failed));
+    });
+    request.on("error", () => done(failed));
+    request.on("abort", () => done(failed));
+    request.end();
+  });
+}
 const TOOLBAR_H = 44;
 const MAX_IMAGE_FILE_BYTES = 64 * 1024 * 1024;
+const SCROLL_REPLY_TIMEOUT_MS = 1e3;
 function hostInfo(win) {
   try {
     const d = electron.screen.getDisplayMatching(win.getBounds());
@@ -551,6 +695,37 @@ function registerIpc(ctx) {
     native.setBounds(rect);
     rendererDrivesLayout = true;
   });
+  let scrollSeq = 0;
+  const scrollWaiters = /* @__PURE__ */ new Map();
+  electron.ipcMain.on(IPC.scrollResult, (e, raw) => {
+    if (e.sender !== target.webContents && e.sender !== native.webContents) return;
+    const report = parseScrollReport(raw);
+    if (!report) return;
+    const waiter = scrollWaiters.get(report.id);
+    if (!waiter) return;
+    scrollWaiters.delete(report.id);
+    waiter(report);
+  });
+  const scrollBoth = async (req) => {
+    const base = { x: req.x, y: req.y };
+    if (req.selector !== void 0) base.selector = req.selector;
+    if (!native.webContents.isDestroyed()) native.webContents.send(IPC.applyScroll, base);
+    const wc = target.webContents;
+    if (wc.isDestroyed()) return null;
+    const id = ++scrollSeq;
+    const answered = new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        scrollWaiters.delete(id);
+        resolve(null);
+      }, SCROLL_REPLY_TIMEOUT_MS);
+      scrollWaiters.set(id, (report) => {
+        clearTimeout(timer);
+        resolve(report);
+      });
+    });
+    wc.send(IPC.applyScroll, { ...base, id });
+    return answered;
+  };
   electron.ipcMain.handle(IPC.getHostInfo, (e) => {
     assertRenderer(e);
     return hostInfo(win);
@@ -610,6 +785,40 @@ function registerIpc(ctx) {
       return electron.app.getVersion();
     }
   })();
+  let update = { status: "current", current: appVersion, checkedAt: 0 };
+  let releaseUrl = "";
+  const runUpdateCheck = async () => {
+    const now = Date.now();
+    const { state, url } = await checkForUpdate(appVersion, now);
+    update = state;
+    releaseUrl = state.status === "available" && isReleaseUrl(url) ? url : "";
+    const next = { ...settings, lastUpdateCheck: now };
+    try {
+      saveSettings(settingsFile, next);
+      settings = next;
+    } catch {
+    }
+    if (!win.isDestroyed()) win.webContents.send(IPC.updateStatus, state);
+    return state;
+  };
+  electron.ipcMain.handle(IPC.getUpdate, (e) => {
+    assertRenderer(e);
+    return update;
+  });
+  electron.ipcMain.handle(IPC.checkUpdate, (e) => {
+    assertRenderer(e);
+    return runUpdateCheck();
+  });
+  electron.ipcMain.handle(IPC.openRelease, async (e) => {
+    assertRenderer(e);
+    if (releaseUrl === "") return false;
+    await electron.shell.openExternal(releaseUrl);
+    return true;
+  });
+  const bootCheckAllowed = process.env.OBSRV_TEST !== "1" || process.env.OBSRV_RELEASES_API !== void 0;
+  if (bootCheckAllowed && settings.updateCheck && isCheckDue(settings.lastUpdateCheck, Date.now())) {
+    void runUpdateCheck();
+  }
   const control = new ControlServer(node_path.join(electron.app.getPath("userData"), CONTROL_FILE_NAME), {
     status: () => {
       let url = "";
@@ -653,11 +862,12 @@ function registerIpc(ctx) {
       };
     },
     viewport: () => target.getViewport(),
-    scroll: (pos) => {
-      for (const wc of [native.webContents, target.webContents]) {
-        if (!wc.isDestroyed()) wc.send(IPC.applyScroll, pos);
-      }
-    },
+    // An agent scroll drives both panes over the same `applyScroll` channel
+    // the pane-sync mirror uses — each pane's sync preload applies it and
+    // suppresses its own echo, so the two arrive together with no loop.
+    // Relying on the mirror instead would be silent: an applied scroll is
+    // deliberately not re-reported (see preload/sync.ts).
+    scroll: scrollBoth,
     click: (c) => {
       const down = parseInputEvent({ type: "mouseDown", x: c.x, y: c.y, button: c.button, clickCount: 1 });
       const up = parseInputEvent({ type: "mouseUp", x: c.x, y: c.y, button: c.button, clickCount: 1 });

package/out/main/{targetSource-DkXWE0ha.js → targetSource-CbJwfugi.js}

@@ -3,7 +3,13 @@ const electron = require("electron");
 const node_events = require("node:events");
 const node_path = require("node:path");
 const MAX_VIEWPORT = 4096;
-const DEFAULT_SETTINGS = { hostDiagonalInches: 27, hostNits: 500, agentControl: false };
+const DEFAULT_SETTINGS = {
+  hostDiagonalInches: 27,
+  hostNits: 500,
+  agentControl: false,
+  updateCheck: true,
+  lastUpdateCheck: 0
+};
 const SCREEN_PRESETS = [
   // Laptops — ordered largest to smallest panel, then the denser 1080p outlier.
   { id: "laptop-768", label: '1366×768 15.6"', width: 1366, height: 768, diagonalInches: 15.6, deviceScaleFactor: 1, group: "laptop" },
@@ -59,6 +65,15 @@ function classifyFileNavigation(from, to) {
   if (IMAGE_EXTENSIONS.test(path)) return "image";
   return from.startsWith("file:") ? "allow" : "block";
 }
+function isFullFrame(dirty, frameWidth, frameHeight, deviceScaleFactor) {
+  if (dirty.x !== 0 || dirty.y !== 0) return false;
+  if (dirty.width === frameWidth && dirty.height === frameHeight) return true;
+  if (!(deviceScaleFactor > 1)) return false;
+  return dirty.width === Math.round(frameWidth / deviceScaleFactor) && dirty.height === Math.round(frameHeight / deviceScaleFactor);
+}
+function fitsFrame(dirty, frameWidth, frameHeight) {
+  return dirty.x >= 0 && dirty.y >= 0 && dirty.width > 0 && dirty.height > 0 && dirty.x + dirty.width <= frameWidth && dirty.y + dirty.height <= frameHeight;
+}
 const SCHEME = /^[a-z][a-z0-9+.-]*:/i;
 const LOOPBACK = /^(localhost|127\.0\.0\.1|\[::1\])(:\d+)?(\/|$)/i;
 function normalizeUrl(input) {
@@ -159,13 +174,14 @@ class TargetSource extends node_events.EventEmitter {
       if (dirty.width <= 0 || dirty.height <= 0) return;
       if (image.isEmpty()) return;
       const full = image.getSize();
-      const isFull = dirty.x === 0 && dirty.y === 0 && dirty.width === full.width && dirty.height === full.height;
+      const isFull = isFullFrame(dirty, full.width, full.height, this.dsf);
+      if (!isFull && !fitsFrame(dirty, full.width, full.height)) return;
       this.emit("frame", {
         frame: {
-          x: dirty.x,
-          y: dirty.y,
-          width: dirty.width,
-          height: dirty.height,
+          x: isFull ? 0 : dirty.x,
+          y: isFull ? 0 : dirty.y,
+          width: isFull ? full.width : dirty.width,
+          height: isFull ? full.height : dirty.height,
           // `toBitmap()` already returns a fresh copy of the pixels (unlike the
           // deprecated `getBitmap()`, typed `void` in Electron 43), and a
           // Buffer is a Uint8Array, so this is the only copy of the slice.