getobsrv 0.6.0 → 0.7.1

package/README.md

@@ -91,6 +91,13 @@ 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,
@@ -128,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

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-BKW32VA5.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);
@@ -370,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++) {
@@ -381,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})`
@@ -407,6 +408,7 @@ function diffMetrics(target, reference, referenceDeviceRows) {
     }
   }
   return {
+    settled,
     inkCoverage: { target: targetCoverage, reference: referenceCoverage, delta: targetCoverage - referenceCoverage },
     rows: {
       target: targetRows,
@@ -414,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) {
@@ -587,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);
@@ -598,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-BKW32VA5.js");
+const targetSource = require("./targetSource-CbJwfugi.js");
 const node_http = require("node:http");
 const node_url = require("node:url");
 const IPC = {
@@ -35,7 +35,11 @@ const IPC = {
   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;
@@ -136,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;
@@ -149,7 +157,14 @@ function parseUiState(raw) {
   if (typeof profileId !== "string" || profileId.length === 0 || profileId.length > MAX_UI_ID) return null;
   if (viewMode !== "1:1" && viewMode !== "fit") return null;
   if (mode !== "url" && mode !== "image") return null;
-  return { presetId, profileId, viewMode, mode, targetBounds: parseRect(raw.targetBounds) };
+  return {
+    presetId,
+    profileId,
+    viewMode,
+    mode,
+    targetBounds: parseRect(raw.targetBounds),
+    canvasBounds: parseRect(raw.canvasBounds)
+  };
 }
 function parseScrollPos(raw) {
   if (!isRecord$1(raw)) return null;
@@ -262,6 +277,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"));
@@ -270,7 +286,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 };
@@ -279,9 +299,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;
@@ -482,6 +560,49 @@ 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;
@@ -645,6 +766,7 @@ function registerIpc(ctx) {
   });
   const uiState = { presetId: "1080p-24", profileId: "reference", viewMode: "1:1", mode: "url" };
   let targetBounds = null;
+  let canvasBounds = null;
   const MAX_PENDING_APPLIES = 32;
   let rendererReported = false;
   let warnedPendingOverflow = false;
@@ -653,9 +775,10 @@ function registerIpc(ctx) {
     if (!fromRenderer(e)) return;
     const s = parseUiState(raw);
     if (!s) return;
-    const { targetBounds: bounds, ...state } = s;
+    const { targetBounds: bounds, canvasBounds: canvas, ...state } = s;
     Object.assign(uiState, state);
     targetBounds = bounds ?? null;
+    canvasBounds = canvas ?? null;
     if (!rendererReported) {
       rendererReported = true;
       for (const patch of pendingApplies.splice(0)) {
@@ -663,6 +786,46 @@ function registerIpc(ctx) {
       }
     }
   });
+  const SETTLE_POLL_MS = 80;
+  const SETTLE_STABLE_READS = 2;
+  const SETTLE_BUDGET_MS = 4e3;
+  const SETTLE_DRAW_MS = 120;
+  const nextFrame = (budgetMs) => new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      target.off("frame", onFrame);
+      resolve(false);
+    }, budgetMs);
+    const onFrame = () => {
+      clearTimeout(timer);
+      target.off("frame", onFrame);
+      resolve(true);
+    };
+    target.on("frame", onFrame);
+    target.invalidate();
+  });
+  const settleTarget = async () => {
+    const deadline = Date.now() + SETTLE_BUDGET_MS;
+    let last = "";
+    let stable = 0;
+    while (Date.now() < deadline) {
+      const v = target.getViewport();
+      const key = `${v.width}x${v.height}`;
+      stable = key === last ? stable + 1 : 0;
+      last = key;
+      if (stable >= SETTLE_STABLE_READS) break;
+      await new Promise((r) => setTimeout(r, SETTLE_POLL_MS));
+    }
+    if (stable < SETTLE_STABLE_READS) return false;
+    const painted = await nextFrame(Math.max(0, deadline - Date.now()));
+    await new Promise((r) => setTimeout(r, SETTLE_DRAW_MS));
+    return painted;
+  };
+  const roundRect = (r) => ({
+    x: Math.round(r.x),
+    y: Math.round(r.y),
+    width: Math.max(1, Math.round(r.width)),
+    height: Math.max(1, Math.round(r.height))
+  });
   const appVersion = (() => {
     try {
       const pkg = JSON.parse(node_fs.readFileSync(node_path.join(__dirname, "..", "..", "package.json"), "utf8"));
@@ -671,6 +834,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 = "";
@@ -697,20 +894,26 @@ function registerIpc(ctx) {
       win.webContents.send(IPC.agentApply, patch);
     },
     captureVisible: async () => {
+      await settleTarget();
       const image = await win.webContents.capturePage();
       const size = image.getSize();
       return { data: image.toPNG().toString("base64"), width: size.width, height: size.height };
     },
     captureTarget: async () => {
-      const bounds = targetBounds;
+      const settled = await settleTarget();
+      const bounds = canvasBounds ?? targetBounds;
       const known = bounds !== null && bounds.width >= 1 && bounds.height >= 1;
-      const image = await win.webContents.capturePage(known ? bounds : void 0);
+      const image = await win.webContents.capturePage(known ? roundRect(bounds) : void 0);
       const size = image.getSize();
+      const warnings = [];
+      if (!known) warnings.push("the renderer has not reported the pane bounds yet; captured the full window instead");
+      else if (canvasBounds === null) warnings.push("the renderer has not reported the render bounds yet; captured the whole pane instead");
+      if (!settled) warnings.push("the target was still resizing when the capture budget ran out; the PNG may show a transitional frame");
       return {
         data: image.toPNG().toString("base64"),
         width: size.width,
         height: size.height,
-        warnings: known ? [] : ["the renderer has not reported the target pane bounds yet; captured the full window instead"]
+        warnings
       };
     },
     viewport: () => target.getViewport(),

package/out/main/{targetSource-BKW32VA5.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" },

package/out/mcp/server.js

@@ -12,6 +12,7 @@ const args_1 = require("../cli/args");
 const control_1 = require("../shared/control");
 const presets_1 = require("../shared/presets");
 const types_1 = require("../shared/types");
+const url_1 = require("../shared/url");
 const control_2 = require("./control");
 const lib_1 = require("./lib");
 /**
@@ -127,8 +128,9 @@ const snapInputShape = {
     capture: zod_1.z
         .enum(['window', 'pane'])
         .optional()
-        .describe("Live mode only: what the returned PNG shows — 'window' (default) is the whole app window, 'pane' is just " +
-        'the target pane (its footer readout included). Ignored (with a note) when the render is headless.'),
+        .describe("Live mode only: what the returned PNG shows — 'window' (default) is the whole app window, 'pane' is the " +
+        'rendered screen cropped to itself, so a minified mobile preset is phone-shaped rather than a small phone ' +
+        'in a large rectangle. Ignored (with a note) when the render is headless.'),
 };
 const snapOutputShape = {
     mode: zod_1.z
@@ -144,7 +146,14 @@ const snapOutputShape = {
         .boolean()
         .describe('Headless: the page went paint-quiet and every pixel painted. False is still a usable capture — a page that ' +
         'kept animating, or one whose repaint never completed, is returned as-is with a warning saying what was ' +
-        'missing. Live: the app confirmed the navigation before the capture.'),
+        'missing. Live: the app confirmed the navigation before the capture (trivially true when the app was ' +
+        'already showing the URL and nothing was navigated).'),
+    navigated: zod_1.z
+        .boolean()
+        .optional()
+        .describe('Live only: false when the app was already showing this URL, so no reload was issued and the capture kept ' +
+        'the current scroll position, pan and in-page state. True when the app was pointed somewhere new — that is ' +
+        'a fresh load, which starts at the top of the page.'),
     warnings: zod_1.z.array(zod_1.z.string()),
     pngPath: zod_1.z.string().describe('Absolute path of the captured PNG (kept in a per-call temp dir).'),
     url: zod_1.z.string().optional().describe('Live only: the URL the app reports showing.'),
@@ -182,6 +191,12 @@ const diffInputShape = {
         .describe(`Per-render budget for load + paint quiescence, in ms. Default ${args_1.DEFAULT_TIMEOUT_MS}.`),
 };
 const diffOutputShape = {
+    settled: zod_1.z
+        .boolean()
+        .describe('False when either render was a best-effort capture of a page that never stopped painting. The two captures ' +
+        'are then different frames, so the band deltas are frame-to-frame noise rather than rendering evidence — ' +
+        '`findings` says so instead of interpreting them.'),
+    warnings: zod_1.z.array(zod_1.z.string()).describe('Anything either render warned about, prefixed target: / reference:.'),
     url: zod_1.z.string(),
     preset: zod_1.z.string(),
     profile: zod_1.z.string(),
@@ -273,6 +288,14 @@ const driveInputShape = {
         .optional()
         .describe('Draw a temporary neutral marker over this target-pixel rect in the pane (durationMs default 2000, clamped ' +
         '250-10000). A new highlight replaces the previous one.'),
+    capture: zod_1.z
+        .enum(['window', 'pane'])
+        .optional()
+        .describe("Capture the app after the commands run: 'pane' crops to the rendered screen itself (the render, not the " +
+        "empty pane around it — a minified mobile preset comes back phone-shaped), 'window' takes the whole app " +
+        'window. The capture waits for a preset resize to finish first, so the PNG matches the status beside it. ' +
+        'This is how you see a scrolled or panned state — unlike obsrv_snap, nothing is navigated, so the scroll ' +
+        'position survives. The PNG comes back inline when it is within the 1.5 MiB cap, and always as pngPath.'),
 };
 const driveOutputShape = {
     version: zod_1.z.string().describe('The running app version.'),
@@ -293,6 +316,15 @@ const driveOutputShape = {
         .optional()
         .describe("Only when `scroll` was requested: 'root' if the document scrolled, 'element' if an inner scroll container did."),
     warnings: zod_1.z.array(zod_1.z.string()).optional().describe('Anything worth knowing about the commands that ran (e.g. a scrollSelector that matched nothing).'),
+    pngPath: zod_1.z.string().optional().describe('Only when `capture` was requested: absolute path of the PNG (kept in a per-call temp dir).'),
+    width: zod_1.z
+        .number()
+        .optional()
+        .describe('Only when `capture` was requested: captured width in device-independent px; the raster is this times the display scale.'),
+    height: zod_1.z
+        .number()
+        .optional()
+        .describe('Only when `capture` was requested: captured height in device-independent px.'),
 };
 // --- live drive --------------------------------------------------------------
 /** Budget for one control `status` round-trip once the app is known live. */
@@ -317,20 +349,83 @@ function liveFailure(e) {
 }
 const sleep = (ms) => new Promise(r => setTimeout(r, ms));
 /**
- * The live `obsrv_snap` path: navigate the visible app (plus preset/profile
- * when given), wait — bounded — for the app to report the navigation, then
- * capture the window exactly as the user sees it.
+ * One short grace before a live capture: the renderer repaints the pane a
+ * frame or two after the store confirms, and a capture racing that would show
+ * a half-applied flip.
+ */
+const LIVE_CAPTURE_GRACE_MS = 300;
+/**
+ * Is the app already showing this page? Compared as parsed URLs so a request
+ * for `http://host:5173` matches the `http://host:5173/` the browser commits,
+ * and through the same normaliser the URL bar uses so a bare host works too.
+ * Anything unparseable falls back to a trimmed string compare.
+ */
+function sameUrl(a, b) {
+    const norm = (raw) => {
+        const t = raw.trim();
+        if (t === '')
+            return '';
+        try {
+            return new URL((0, url_1.normalizeUrl)(t)).href;
+        }
+        catch {
+            return t;
+        }
+    };
+    const x = norm(a);
+    const y = norm(b);
+    return x !== '' && x === y;
+}
+/**
+ * Capture the app window — or just the target pane — over the control server
+ * and write it to a per-call temp PNG. Shared by the live `obsrv_snap` path
+ * and `obsrv_drive`'s `capture`, so both produce byte-identical results.
+ */
+async function liveCapture(info, what) {
+    // `pane` crops to the target pane; both answer with the same
+    // { data, width, height } shape plus their own warnings (e.g. the pre-mount
+    // full-window fallback), which join the tool's.
+    const command = what === 'pane' ? 'captureTarget' : 'captureVisible';
+    const capture = await (0, control_2.controlCall)(info, command, {}, LIVE_CAPTURE_TIMEOUT_MS);
+    const { data, width, height } = capture;
+    if (typeof data !== 'string' || typeof width !== 'number' || typeof height !== 'number') {
+        throw new Error('the control server returned a malformed capture');
+    }
+    const warnings = [];
+    if (Array.isArray(capture['warnings'])) {
+        for (const w of capture['warnings'])
+            if (typeof w === 'string')
+                warnings.push(w);
+    }
+    const dir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'obsrv-mcp-'));
+    const pngPath = (0, node_path_1.join)(dir, 'live.png');
+    await (0, promises_1.writeFile)(pngPath, Buffer.from(data, 'base64'));
+    return { pngPath, width, height, warnings };
+}
+/**
+ * The live `obsrv_snap` path: point the visible app at the URL (plus
+ * preset/profile when given), wait — bounded — for it to report the
+ * navigation, then capture the window exactly as the user sees it.
+ *
+ * When the app is already showing that URL the navigation is skipped entirely.
+ * A navigate is a fresh `loadURL`, which resets the scroll position, so
+ * reloading here would make `obsrv_drive { scroll }` followed by a snap of the
+ * same page always capture the top. `navigated: false` says which happened.
  */
 async function liveSnap(app, input, notes) {
     const { info } = app;
     const warnings = [...notes];
     const before = app.status.url;
-    let applied = '';
+    // Already there? Then leave the page alone — see the note above.
+    const navigated = !sameUrl(before, input.url);
+    let applied = before;
     try {
-        // The navigate command answers once both panes finished loading, so it
-        // carries the same per-render budget the headless path polices.
-        const nav = await (0, control_2.controlCall)(info, 'navigate', { url: input.url.trim() }, (input.timeoutMs ?? args_1.DEFAULT_TIMEOUT_MS) + 10_000);
-        applied = typeof nav['url'] === 'string' ? nav['url'] : '';
+        if (navigated) {
+            // The navigate command answers once both panes finished loading, so it
+            // carries the same per-render budget the headless path polices.
+            const nav = await (0, control_2.controlCall)(info, 'navigate', { url: input.url.trim() }, (input.timeoutMs ?? args_1.DEFAULT_TIMEOUT_MS) + 10_000);
+            applied = typeof nav['url'] === 'string' ? nav['url'] : '';
+        }
         if (input.preset !== undefined)
             await (0, control_2.controlCall)(info, 'setPreset', { id: input.preset }, LIVE_APPLY_TIMEOUT_MS);
         if (input.profile !== undefined)
@@ -341,15 +436,18 @@ async function liveSnap(app, input, notes) {
     }
     // The app settles when it reports the applied URL — or, after a redirect,
     // any committed non-blank URL that is no longer the pre-navigation one.
+    // Nothing to settle when no navigation was issued; one status read still
+    // refreshes the preset/profile/view the result reports.
     let status = app.status;
-    let settled = false;
+    let settled = !navigated;
     const deadline = Date.now() + LIVE_SETTLE_MS;
     for (;;) {
         try {
             const s = (0, control_1.parseControlStatus)(await (0, control_2.controlCall)(info, 'status', {}, LIVE_STATUS_TIMEOUT_MS));
             if (s) {
                 status = s;
-                settled = s.url === applied || (applied !== '' && s.url !== before && s.url !== 'about:blank');
+                if (navigated)
+                    settled = s.url === applied || (applied !== '' && s.url !== before && s.url !== 'about:blank');
             }
         }
         catch (e) {
@@ -361,33 +459,16 @@ async function liveSnap(app, input, notes) {
     }
     if (!settled)
         warnings.push('the app did not confirm the navigation before capture; the PNG may show the previous page.');
-    // One short grace after the state settles: the renderer repaints the pane
-    // (and any preset resize) a frame or two after the store confirms, and a
-    // capture racing that would show a half-applied flip.
-    await sleep(300);
-    // `capture: 'pane'` crops to the target pane; the command answers with the
-    // same { data, width, height } shape plus its own warnings (e.g. the
-    // pre-mount full-window fallback), which join the tool's.
+    await sleep(LIVE_CAPTURE_GRACE_MS);
     let capture;
     try {
-        const command = input.capture === 'pane' ? 'captureTarget' : 'captureVisible';
-        capture = await (0, control_2.controlCall)(info, command, {}, LIVE_CAPTURE_TIMEOUT_MS);
+        capture = await liveCapture(info, input.capture === 'pane' ? 'pane' : 'window');
     }
     catch (e) {
         return toolError(liveFailure(e));
     }
-    const { data, width, height } = capture;
-    if (typeof data !== 'string' || typeof width !== 'number' || typeof height !== 'number') {
-        return toolError('the control server returned a malformed capture');
-    }
-    if (Array.isArray(capture['warnings'])) {
-        for (const w of capture['warnings'])
-            if (typeof w === 'string')
-                warnings.push(w);
-    }
-    const dir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'obsrv-mcp-'));
-    const pngPath = (0, node_path_1.join)(dir, 'live.png');
-    await (0, promises_1.writeFile)(pngPath, Buffer.from(data, 'base64'));
+    warnings.push(...capture.warnings);
+    const { pngPath, width, height } = capture;
     const structured = {
         mode: 'live',
         url: status.url,
@@ -397,6 +478,7 @@ async function liveSnap(app, input, notes) {
         width,
         height,
         settled,
+        navigated,
         warnings,
         pngPath,
     };
@@ -428,7 +510,10 @@ server.registerTool('obsrv_snap', {
         `ignored in live mode. \`mode: "live"\` errors when the app is not reachable; \`mode: "headless"\` never ` +
         `touches it. Note: although this tool is annotated read-only (it renders and captures), a live snap steers ` +
         `the open app window — navigating it and flipping its preset in front of the user — as its means of ` +
-        `capture; that visible steering is the point of live mode.`,
+        `capture; that visible steering is the point of live mode.\n\n` +
+        `A live snap only navigates when the app is showing a different URL; the result's \`navigated\` says which ` +
+        `happened. Navigating is a fresh load, so it starts at the top of the page — to photograph a scrolled or ` +
+        `panned state, use obsrv_drive with \`capture\` instead, which never navigates unless you ask it to.`,
     inputSchema: snapInputShape,
     outputSchema: snapOutputShape,
     annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true },
@@ -492,6 +577,9 @@ server.registerTool('obsrv_diff', {
         `8 horizontal band deltas with humanised findings (informational — apply your own thresholds), and the ` +
         `paths of target.png / reference.png in a per-call temp dir. \`includeImages: true\` also inlines both ` +
         `PNGs (1.5 MiB cap each).\n\n` +
+        `Check \`settled\` before believing the bands: a page that never stops painting (animation, video) yields ` +
+        `two captures of *different frames*, so every delta is frame-to-frame noise. When it is false the numbers ` +
+        `are still returned but \`findings\` says so instead of interpreting them.\n\n` +
         `1x presets only (e.g. laptop-768, 1080p-24): dense presets (phones) and CSS viewports over 2048px are ` +
         `refused with an explanatory error — use obsrv_snap for those.\n\n` +
         `Headless-only: a diff always performs its own two renders and never drives a running Obsrv app window ` +
@@ -532,7 +620,8 @@ server.registerTool('obsrv_drive', {
         `both panes, pan the target pane to a pixel, click the live page, and highlight a rect with a temporary ` +
         `neutral marker, all while the user watches.\n\n` +
         `Only the supplied inputs run (none = just read the current state), in this fixed order: focus → url → ` +
-        `preset → profile → viewMode → pixelExact → reload → back → forward → scroll → panTo → click → highlight. ` +
+        `preset → profile → viewMode → pixelExact → reload → back → forward → scroll → panTo → click → highlight → ` +
+        `capture. ` +
         `The result is the final status: app version, the URL showing, and the selected preset/profile/view. A ` +
         `click that navigates is reflected in that status — the call waits briefly (up to 2 s) for the commit. A ` +
         `scroll adds \`scrolled\` (the offset actually reached) and \`scroller\` ('root' or 'element'): compare ` +
@@ -541,9 +630,12 @@ server.registerTool('obsrv_drive', {
         `Coordinates: click takes CSS-viewport px of the page (the valid range is 0 up to but not including the ` +
         `viewport size); panTo and highlight take target-pane pixels (device px of the render — identical to CSS px ` +
         `on 1x presets); scroll takes page CSS px.\n\n` +
+        `Pass \`capture\` to get a PNG back once the commands have run. Nothing in this tool navigates unless you ` +
+        `pass \`url\`, so this is how you photograph a scrolled or panned state: scroll, then capture, in one call. ` +
+        `obsrv_snap is the other way round — it points the app at a URL first, and pointing it somewhere new is a ` +
+        `fresh load that starts at the top.\n\n` +
         `Requires the app to be open with its "Agent control" toolbar toggle on; errors otherwise. This tool ` +
-        `mutates visible app state (it changes what the user's window shows, and a click can act on the live page) ` +
-        `but renders nothing itself — use obsrv_snap for a capture.`,
+        `mutates visible app state (it changes what the user's window shows, and a click can act on the live page).`,
     inputSchema: driveInputShape,
     outputSchema: driveOutputShape,
     // Honest annotation: this changes what the user's window is showing.
@@ -621,6 +713,15 @@ server.registerTool('obsrv_drive', {
         }
         if (input.highlight !== undefined)
             await (0, control_2.controlCall)(live.info, 'highlight', input.highlight, LIVE_APPLY_TIMEOUT_MS);
+        // Capture last, so the PNG shows everything the commands above did.
+        // Nothing here navigates, so a scroll or pan applied in this same call
+        // is still in place when the shutter fires.
+        let capture = null;
+        if (input.capture !== undefined) {
+            await sleep(LIVE_CAPTURE_GRACE_MS);
+            capture = await liveCapture(live.info, input.capture);
+            warnings.push(...capture.warnings);
+        }
         const status = (0, control_1.parseControlStatus)(await (0, control_2.controlCall)(live.info, 'status', {}, LIVE_STATUS_TIMEOUT_MS));
         if (!status)
             return toolError('the control server returned a malformed status');
@@ -629,11 +730,14 @@ server.registerTool('obsrv_drive', {
             ...(input.scroll !== undefined ? { scrolled: scrolled ?? null } : {}),
             ...(scroller !== undefined ? { scroller } : {}),
             ...(warnings.length > 0 ? { warnings } : {}),
+            ...(capture !== null ? { pngPath: capture.pngPath, width: capture.width, height: capture.height } : {}),
         };
-        return {
-            content: [{ type: 'text', text: JSON.stringify(structured, null, 2) }],
-            structuredContent: structured,
-        };
+        const content = [{ type: 'text', text: JSON.stringify(structured, null, 2) }];
+        if (capture !== null) {
+            const label = input.capture === 'pane' ? 'The captured target pane' : 'The captured app window';
+            content.push(await imageOrNote(capture.pngPath, label, 'read the file at pngPath'));
+        }
+        return { content, structuredContent: structured };
     }
     catch (e) {
         return toolError(liveFailure(e));

package/out/preload/app.js

@@ -25,7 +25,11 @@ const IPC = {
   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 subscribe(channel, cb) {
   const listener = (_e, v) => cb(v);
@@ -94,6 +98,10 @@ const api = {
     return () => {
       electron.ipcRenderer.removeListener(IPC.agentActivity, listener);
     };
-  }
+  },
+  getUpdate: () => electron.ipcRenderer.invoke(IPC.getUpdate),
+  checkUpdate: () => electron.ipcRenderer.invoke(IPC.checkUpdate),
+  openRelease: () => electron.ipcRenderer.invoke(IPC.openRelease),
+  onUpdateStatus: (cb) => subscribe(IPC.updateStatus, cb)
 };
 electron.contextBridge.exposeInMainWorld("obsrv", api);

package/out/renderer/assets/{index-CHF-G97L.css → index-BeroS4wv.css}

@@ -477,3 +477,49 @@ html, body, #root { margin: 0; height: 100%; background: var(--chrome-0); color:
 }
 .browser-notice p { margin: 0.75rem 0 0; color: var(--text-1); }
 .browser-notice code { font-family: var(--mono); }
+
+/* An update is neither a warning nor an error, so it carries no colour: the
+   only chromatic pixels in this chrome stay reserved for real attention. */
+/* `.toolbar button` is (0,1,1) and pins every button to a 26px square, so this
+   needs two classes to outrank it — a bare `.update-button` renders as "v0.". */
+.toolbar .update-button {
+  font-family: var(--mono);
+  font-variant-numeric: tabular-nums;
+  white-space: nowrap;
+  width: auto;
+  flex: 0 0 auto;
+  padding: 0 8px;
+}
+.version-block { margin: 8px 0; }
+.version-row {
+  display: flex;
+  justify-content: space-between;
+  gap: 10px;
+  padding: 3px 0;
+  color: var(--text-1);
+}
+.version-row .version-current,
+.version-row .version-latest,
+.version-row .version-checked {
+  color: var(--text-0);
+  text-align: right;
+}
+.link {
+  background: none;
+  border: 0;
+  padding: 0;
+  color: var(--text-0);
+  text-decoration: underline;
+  cursor: pointer;
+  font: inherit;
+}
+.check-now {
+  width: 100%;
+  height: 24px;
+  margin-top: 8px;
+  background: var(--chrome-2);
+  color: var(--text-0);
+  border: 1px solid var(--line);
+  border-radius: 4px;
+  cursor: pointer;
+}

package/out/renderer/assets/{index-DyCD4ih_.js → index-Cgx8iixu.js}

@@ -12688,7 +12688,13 @@ const createImpl = (createState) => {
 };
 const create = ((createState) => createImpl);
 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" },
@@ -12773,6 +12779,7 @@ const useStore = create()((set) => ({
   targetLoading: false,
   error: null,
   toast: null,
+  update: null,
   image: null,
   surround: "graphite",
   viewMode: "1:1",
@@ -12798,6 +12805,7 @@ const useStore = create()((set) => ({
   // Both panes report the same `loadError` for one failed navigation; the
   // duplicate must not replace the object and re-render everything twice.
   setError: (error) => set((s) => sameError(s.error, error) ? {} : { error }),
+  setUpdate: (update) => set({ update }),
   setToast: (toast) => set({ toast }),
   setImage: (image) => set({ image }),
   setSurround: (surround) => set({ surround }),
@@ -13228,6 +13236,18 @@ function PanelControls() {
     /* @__PURE__ */ jsxRuntimeExports.jsx("p", { className: "muted", children: "Choosing a profile in the toolbar resets these." })
   ] });
 }
+const MINUTE = 6e4;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+const plural = (n, unit) => `${n} ${unit}${n === 1 ? "" : "s"} ago`;
+function formatAge(checkedAt, now) {
+  if (!Number.isFinite(checkedAt) || checkedAt <= 0) return "never";
+  const age = now - checkedAt;
+  if (age < MINUTE) return "just now";
+  if (age < HOUR) return plural(Math.floor(age / MINUTE), "minute");
+  if (age < DAY) return plural(Math.floor(age / HOUR), "hour");
+  return plural(Math.floor(age / DAY), "day");
+}
 function NumberField({ className, label, unit, value, min, step, onCommit, onInvalid }) {
   const ref = reactExports.useRef(null);
   const [draft, setDraft] = reactExports.useState(String(value));
@@ -13278,6 +13298,7 @@ function NumberField({ className, label, unit, value, min, step, onCommit, onInv
 function SettingsPanel() {
   const host = useStore(useShallow((s) => s.host));
   const settings = useStore(useShallow((s) => s.settings));
+  const update = useStore((s) => s.update);
   const custom = useStore(useShallow((s) => s.custom));
   const viewport = useStore(useShallow(selectViewport));
   const scale = useStore(selectScale);
@@ -13396,7 +13417,45 @@ function SettingsPanel() {
       viewport.height,
       "."
     ] }),
-    /* @__PURE__ */ jsxRuntimeExports.jsx("p", { className: "readout", children: custom.diagonalInches > 0 ? `${ppi(custom.width, custom.height, custom.diagonalInches).toFixed(0)} PPI` : "Enter a diagonal to compute PPI" })
+    /* @__PURE__ */ jsxRuntimeExports.jsx("p", { className: "readout", children: custom.diagonalInches > 0 ? `${ppi(custom.width, custom.height, custom.diagonalInches).toFixed(0)} PPI` : "Enter a diagonal to compute PPI" }),
+    /* @__PURE__ */ jsxRuntimeExports.jsx("h2", { children: "Updates" }),
+    /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "version-block", children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "version-row", children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: "Version" }),
+        /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "version-current num", children: update?.current ?? "—" })
+      ] }),
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "version-row", children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: "Latest" }),
+        /* @__PURE__ */ jsxRuntimeExports.jsxs("span", { className: "version-latest", children: [
+          update === null && "Not checked yet",
+          update?.status === "current" && update.checkedAt === 0 && "Not checked yet",
+          update?.status === "current" && update.checkedAt > 0 && "Up to date",
+          update?.status === "error" && "Couldn’t check",
+          update?.status === "available" && update.latest !== void 0 && /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "num", children: update.latest }),
+            " · ",
+            /* @__PURE__ */ jsxRuntimeExports.jsx("button", { type: "button", className: "link", onClick: () => void window.obsrv.openRelease(), children: "Download" })
+          ] })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "version-row", children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: "Last checked" }),
+        /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "version-checked num", children: update === null ? "never" : formatAge(update.checkedAt, Date.now()) })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxRuntimeExports.jsxs("label", { className: "control inline update-check-toggle", children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx(
+        "input",
+        {
+          type: "checkbox",
+          checked: settings.updateCheck,
+          onChange: (e) => commit({ ...settings, updateCheck: e.target.checked })
+        }
+      ),
+      /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: "Check for updates automatically" })
+    ] }),
+    /* @__PURE__ */ jsxRuntimeExports.jsx("button", { type: "button", className: "check-now", onClick: () => void window.obsrv.checkUpdate(), children: "Check now" }),
+    /* @__PURE__ */ jsxRuntimeExports.jsx("p", { className: "muted", children: "One unauthenticated request to GitHub, at most once a day. No identifiers are sent." })
   ] });
 }
 const VERT_SRC = `#version 300 es
@@ -14237,6 +14296,7 @@ function Toolbar({ drawer, onTogglePanel, onToggleSettings }) {
   const setPixelExact = useStore((s) => s.setPixelExact);
   const setError = useStore((s) => s.setError);
   const surround = useStore((s) => s.surround);
+  const update = useStore((s) => s.update);
   const setSurround = useStore((s) => s.setSurround);
   const viewMode = useStore((s) => s.viewMode);
   const setViewMode = useStore((s) => s.setViewMode);
@@ -14367,6 +14427,20 @@ function Toolbar({ drawer, onTogglePanel, onToggleSettings }) {
       ),
       "Pixel-exact"
     ] }),
+    update?.status === "available" && update.latest !== void 0 && /* @__PURE__ */ jsxRuntimeExports.jsxs(
+      "button",
+      {
+        className: "update-button",
+        type: "button",
+        title: `Obsrv ${update.latest} is available — opens the download page`,
+        onClick: () => void window.obsrv.openRelease(),
+        children: [
+          "v",
+          update.latest,
+          " ↓"
+        ]
+      }
+    ),
     /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "surround-control", role: "group", "aria-label": "Pane surround", children: SURROUNDS.map((s) => /* @__PURE__ */ jsxRuntimeExports.jsx(
       "button",
       {
@@ -14425,12 +14499,14 @@ function App() {
   const dropToken = reactExports.useRef(0);
   const targetPaneRef = reactExports.useRef(null);
   const [targetBounds, setTargetBounds] = reactExports.useState(null);
+  const [canvasBounds, setCanvasBounds] = reactExports.useState(null);
   const toggle = (which) => () => setDrawer((d) => d === which ? "none" : which);
   const setHost = useStore((s) => s.setHost);
   const setSettings = useStore((s) => s.setSettings);
   const setUrl = useStore((s) => s.setUrl);
   const setError = useStore((s) => s.setError);
   const setTargetLoading = useStore((s) => s.setTargetLoading);
+  const setUpdate = useStore((s) => s.setUpdate);
   const setImageMeta = useStore((s) => s.setImage);
   const setMode = useStore((s) => s.setMode);
   const setToast = useStore((s) => s.setToast);
@@ -14444,6 +14520,7 @@ function App() {
   reactExports.useEffect(() => {
     window.obsrv.getHostInfo().then(setHost, (e) => console.warn("obsrv: getHostInfo failed", e));
     window.obsrv.getSettings().then(setSettings, (e) => console.warn("obsrv: getSettings failed", e));
+    window.obsrv.getUpdate().then(setUpdate, (e) => console.warn("obsrv: getUpdate failed", e));
     const offs = [
       window.obsrv.onHostChanged(setHost),
       // A committed navigation — back, forward, reload, a link — supersedes
@@ -14454,12 +14531,13 @@ function App() {
         setUrl(url);
       }),
       window.obsrv.onLoadError(setError),
-      window.obsrv.onTargetLoading(setTargetLoading)
+      window.obsrv.onTargetLoading(setTargetLoading),
+      window.obsrv.onUpdateStatus(setUpdate)
     ];
     return () => {
       for (const off of offs) off();
     };
-  }, [setHost, setSettings, setUrl, setError, setTargetLoading]);
+  }, [setHost, setSettings, setUrl, setError, setTargetLoading, setUpdate]);
   reactExports.useEffect(() => {
     void window.obsrv.setViewport(viewport.width, viewport.height, deviceScaleFactor);
   }, [viewport.width, viewport.height, deviceScaleFactor]);
@@ -14470,17 +14548,34 @@ function App() {
     const el = targetPaneRef.current;
     if (!el) return;
     const measure = () => {
-      const r = el.getBoundingClientRect();
-      setTargetBounds({ x: r.x, y: r.y, width: r.width, height: r.height });
+      const pane = el.getBoundingClientRect();
+      setTargetBounds({ x: pane.x, y: pane.y, width: pane.width, height: pane.height });
+      const canvas2 = el.querySelector("canvas");
+      if (!canvas2) {
+        setCanvasBounds(null);
+        return;
+      }
+      const c = canvas2.getBoundingClientRect();
+      const x = Math.max(pane.x, c.x);
+      const y = Math.max(pane.y, c.y);
+      const right = Math.min(pane.x + pane.width, c.x + c.width);
+      const bottom = Math.min(pane.y + pane.height, c.y + c.height);
+      setCanvasBounds(right > x && bottom > y ? { x, y, width: right - x, height: bottom - y } : null);
     };
     const ro = new ResizeObserver(measure);
     ro.observe(el);
+    const canvas = el.querySelector("canvas");
+    if (canvas) ro.observe(canvas);
+    el.addEventListener("scroll", measure, { passive: true });
     measure();
-    return () => ro.disconnect();
+    return () => {
+      ro.disconnect();
+      el.removeEventListener("scroll", measure);
+    };
   }, []);
   reactExports.useEffect(() => {
-    window.obsrv.reportUiState({ presetId, profileId, viewMode, mode, targetBounds });
-  }, [presetId, profileId, viewMode, mode, targetBounds]);
+    window.obsrv.reportUiState({ presetId, profileId, viewMode, mode, targetBounds, canvasBounds });
+  }, [presetId, profileId, viewMode, mode, targetBounds, canvasBounds]);
   reactExports.useEffect(() => {
     return window.obsrv.onAgentApply((patch) => {
       const s = useStore.getState();

package/out/renderer/index.html

@@ -4,8 +4,8 @@
     <meta charset="UTF-8" />
     <meta http-equiv="Content-Security-Policy" content="default-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' blob: data:" />
     <title>Obsrv</title>
-    <script type="module" crossorigin src="./assets/index-DyCD4ih_.js"></script>
-    <link rel="stylesheet" crossorigin href="./assets/index-CHF-G97L.css">
+    <script type="module" crossorigin src="./assets/index-Cgx8iixu.js"></script>
+    <link rel="stylesheet" crossorigin href="./assets/index-BeroS4wv.css">
   </head>
   <body>
     <div id="root"></div>

package/out/shared/ipcPayloads.js

@@ -99,9 +99,10 @@ function parseDeviceScaleFactor(raw) {
     return raw;
 }
 /**
- * Copies exactly the three known keys; the numbers must be finite and
- * positive. A missing `agentControl` means false (the pre-live-drive wire
- * shape); any non-boolean value is refused, never coerced.
+ * Copies exactly the five known keys; the numbers must be finite and
+ * positive. A missing `agentControl` means false and a missing `updateCheck`
+ * means true (the pre-feature wire shapes); any non-boolean value is refused,
+ * never coerced.
  */
 function parseSettings(raw) {
     if (!isRecord(raw))
@@ -114,7 +115,13 @@ function parseSettings(raw) {
     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;
@@ -146,7 +153,14 @@ function parseUiState(raw) {
         return null;
     if (mode !== 'url' && mode !== 'image')
         return null;
-    return { presetId, profileId, viewMode, mode, targetBounds: parseRect(raw.targetBounds) };
+    return {
+        presetId,
+        profileId,
+        viewMode,
+        mode,
+        targetBounds: parseRect(raw.targetBounds),
+        canvasBounds: parseRect(raw.canvasBounds),
+    };
 }
 /**
  * A scroll offset reported by the sync preload in a page webContents. Both

package/out/shared/presets.js

@@ -4,7 +4,13 @@ exports.PANEL_PROFILES = exports.SCREEN_PRESETS = exports.DEFAULT_SETTINGS = exp
 exports.findPreset = findPreset;
 exports.findProfile = findProfile;
 exports.MAX_VIEWPORT = 4096;
-exports.DEFAULT_SETTINGS = { hostDiagonalInches: 27, hostNits: 500, agentControl: false };
+exports.DEFAULT_SETTINGS = {
+    hostDiagonalInches: 27,
+    hostNits: 500,
+    agentControl: false,
+    updateCheck: true,
+    lastUpdateCheck: 0,
+};
 exports.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' },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "getobsrv",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "See your site the way 1x screens see it",
   "main": "./out/main/index.js",
   "bin": {

package/skills/obsrv-screens/SKILL.md

@@ -54,6 +54,13 @@ comes back inline. If the Obsrv desktop app is open with "Agent control" on
 click, pan and highlight to walk the user through what it found; no app
 means the usual headless render.
 
+To see anything below the fold, scroll and capture in the **same**
+`obsrv_drive` call — `{ scroll: { x: 0, y: 1500 }, capture: 'pane' }`. That
+tool never navigates unless you pass `url`, so the scroll is still in place
+when the PNG is taken. Reaching for `obsrv_snap` after a scroll works only
+when the app is already on that exact URL (it answers `navigated: false`);
+snapping a different URL is a fresh load and lands back at the top.
+
 ## The loop that catches real regressions
 
 1. Snap the dev URL across `--matrix laptop-768,android-65,1080p-24`, plus a
@@ -80,6 +87,9 @@ happened on the matrix snaps.
   not colorimetry of one specific panel.
 - `diff` is 1x-only in v1: dsf>1 presets and CSS viewports over 2048px exit
   with an error. Its findings are informational — apply your own thresholds.
+- `diff` on an animating page compares two different frames. Check `settled`
+  in its output: when false the band deltas are frame-to-frame noise and
+  `findings` says so rather than interpreting them. Snap that page instead.
 - `diff` cannot say "the hairline vanished": a 0.5px hairline renders one
   device row at 1x *and* 2x. It reports ink deltas and row ratios; vanishing
   is judged by reading the PNG.