getobsrv 0.5.0 → 0.7.0

package/out/mcp/server.js

@@ -11,6 +11,8 @@ const zod_1 = require("zod");
 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");
 /**
@@ -141,7 +143,16 @@ const snapOutputShape = {
     profile: zod_1.z.string().optional().describe('Headless only: applied panel profile id.'),
     settled: zod_1.z
         .boolean()
-        .describe('Headless: the page went paint-quiet. Live: the app confirmed the navigation before the capture.'),
+        .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 (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.'),
@@ -179,6 +190,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(),
@@ -233,9 +250,24 @@ const driveInputShape = {
     back: zod_1.z.boolean().optional().describe('true: history back (native pane history; the target mirrors the committed page).'),
     forward: zod_1.z.boolean().optional().describe('true: history forward (native pane history; the target mirrors it).'),
     scroll: zod_1.z
-        .object({ x: zod_1.z.number().min(0), y: zod_1.z.number().min(0) })
+        .object({
+        x: zod_1.z.number().min(0),
+        y: zod_1.z.number().min(0),
+        scrollSelector: zod_1.z
+            .string()
+            .min(1)
+            .max(types_1.MAX_SCROLL_SELECTOR)
+            .optional()
+            .describe('Escape hatch: a CSS selector naming the element to scroll, for pages whose scroll host the automatic ' +
+            'detection misjudges (several large scrollers, a virtualised list that translates content). No fallback ' +
+            'if it matches nothing — the result says so. Same reach as the detection: light DOM of the top-level ' +
+            'document only, so a scroller inside a shadow root or an iframe cannot be targeted.'),
+    })
         .optional()
-        .describe('Scroll both panes to this absolute page offset in CSS px.'),
+        .describe('Scroll both panes to this absolute page offset in CSS px. Pages whose root cannot scroll (app shells with ' +
+        '`html, body { overflow: hidden }` and an inner `overflow-y: auto` container) are handled: the largest ' +
+        'visible inner scroller is found and scrolled instead. Check `scrolled` in the result for the offset ' +
+        'actually reached — that is how you tell a real scroll from one that clamped.'),
     panTo: zod_1.z
         .object({ x: zod_1.z.number().min(0), y: zod_1.z.number().min(0) })
         .optional()
@@ -255,6 +287,13 @@ 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 target pane (the 1x render on its own), " +
+        "'window' takes the whole app window. 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.'),
@@ -263,6 +302,27 @@ const driveOutputShape = {
     profileId: zod_1.z.string(),
     viewMode: zod_1.z.string(),
     mode: zod_1.z.string().describe("The app's pane mode: 'url' (live page) or 'image' (a dropped design export)."),
+    scrolled: zod_1.z
+        .object({ x: zod_1.z.number(), y: zod_1.z.number() })
+        .nullable()
+        .optional()
+        .describe('Only when `scroll` was requested: the offset the target pane actually reached, read back after the write. ' +
+        'Less than you asked for means the content clamped (short page, or the wrong scroller). Null means the ' +
+        'pane did not confirm in time — the scroll may still have landed.'),
+    scroller: zod_1.z
+        .enum(['root', 'element'])
+        .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. */
@@ -287,20 +347,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)
@@ -311,15 +434,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) {
@@ -331,33 +457,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,
@@ -367,6 +476,7 @@ async function liveSnap(app, input, notes) {
         width,
         height,
         settled,
+        navigated,
         warnings,
         pngPath,
     };
@@ -398,7 +508,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 },
@@ -462,6 +575,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 ` +
@@ -502,15 +618,22 @@ 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. ` +
+        `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 ` +
+        `\`scrolled\` with what you asked for rather than trusting the call's success, and use \`scroll.scrollSelector\` ` +
+        `when the automatic scroll-host detection picks the wrong container.\n\n` +
         `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.
@@ -548,8 +671,25 @@ server.registerTool('obsrv_drive', {
             await (0, control_2.controlCall)(live.info, 'back', {}, LIVE_APPLY_TIMEOUT_MS);
         if (input.forward)
             await (0, control_2.controlCall)(live.info, 'forward', {}, LIVE_APPLY_TIMEOUT_MS);
-        if (input.scroll !== undefined)
-            await (0, control_2.controlCall)(live.info, 'scroll', input.scroll, LIVE_APPLY_TIMEOUT_MS);
+        // The scroll answer is the interesting half: it reports the offset the
+        // pane reached, which is the only way to tell a scroll from a clamp.
+        let scrolled;
+        let scroller;
+        const warnings = [];
+        if (input.scroll !== undefined) {
+            const r = await (0, control_2.controlCall)(live.info, 'scroll', input.scroll, LIVE_APPLY_TIMEOUT_MS);
+            const at = r['scrolled'];
+            scrolled =
+                at !== null && typeof at === 'object' && typeof at.x === 'number' && typeof at.y === 'number'
+                    ? { x: at.x, y: at.y }
+                    : null;
+            if (r['scroller'] === 'root' || r['scroller'] === 'element')
+                scroller = r['scroller'];
+            if (Array.isArray(r['warnings']))
+                for (const w of r['warnings'])
+                    if (typeof w === 'string')
+                        warnings.push(w);
+        }
         if (input.panTo !== undefined)
             await (0, control_2.controlCall)(live.info, 'panTo', input.panTo, LIVE_APPLY_TIMEOUT_MS);
         if (input.click !== undefined) {
@@ -571,13 +711,31 @@ 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');
-        return {
-            content: [{ type: 'text', text: JSON.stringify(status, null, 2) }],
-            structuredContent: { ...status },
+        const structured = {
+            ...status,
+            ...(input.scroll !== undefined ? { scrolled: scrolled ?? null } : {}),
+            ...(scroller !== undefined ? { scroller } : {}),
+            ...(warnings.length > 0 ? { warnings } : {}),
+            ...(capture !== null ? { pngPath: capture.pngPath, width: capture.width, height: capture.height } : {}),
         };
+        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/preload/sync.js

@@ -1,8 +1,12 @@
 "use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const electron = require("electron");
 const SUPPRESS_MS = 120;
 const SYNC_SCROLL = "obsrv:sync-scroll";
 const APPLY_SCROLL = "obsrv:apply-scroll";
+const SCROLL_RESULT = "obsrv:scroll-result";
+const MAX_VISITED = 2e3;
+const SCROLL_EPSILON = 1;
 let suppressUntil = 0;
 let lastApplied = null;
 let rafId = 0;
@@ -33,9 +37,102 @@ window.addEventListener(
   },
   { passive: true }
 );
-electron.ipcRenderer.on(APPLY_SCROLL, (_e, pos) => {
-  lastApplied = pos;
-  if (window.scrollX === pos.x && window.scrollY === pos.y) return;
-  suppressUntil = performance.now() + SUPPRESS_MS;
-  window.scrollTo(pos.x, pos.y);
+function rootScrolls() {
+  const el = document.scrollingElement;
+  if (!el) return false;
+  return el.scrollHeight > el.clientHeight + SCROLL_EPSILON || el.scrollWidth > el.clientWidth + SCROLL_EPSILON;
+}
+function canScroll(el) {
+  const overflowsY = el.scrollHeight > el.clientHeight + SCROLL_EPSILON;
+  const overflowsX = el.scrollWidth > el.clientWidth + SCROLL_EPSILON;
+  if (!overflowsY && !overflowsX) return false;
+  const style = window.getComputedStyle(el);
+  const scrollableY = style.overflowY === "auto" || style.overflowY === "scroll";
+  const scrollableX = style.overflowX === "auto" || style.overflowX === "scroll";
+  return overflowsY && scrollableY || overflowsX && scrollableX;
+}
+function isVisible(el) {
+  const check = el.checkVisibility;
+  if (typeof check !== "function") return el.getClientRects().length > 0;
+  return check.call(el, { visibilityProperty: true, opacityProperty: true });
+}
+function findScroller(root = document.body) {
+  if (!root) return null;
+  let best = null;
+  let bestArea = 0;
+  let visited = 0;
+  const stack = [root];
+  while (stack.length > 0) {
+    const el = stack.pop();
+    if (visited++ >= MAX_VISITED) break;
+    const area = el.clientWidth * el.clientHeight;
+    if (area <= 0 && el.getClientRects().length === 0 && window.getComputedStyle(el).display === "none") continue;
+    if (area > bestArea && canScroll(el) && isVisible(el)) {
+      best = el;
+      bestArea = area;
+    }
+    const kids = el.children;
+    for (let i = kids.length - 1; i >= 0; i--) stack.push(kids[i]);
+  }
+  return best;
+}
+let cachedScroller = null;
+function resolveScroller() {
+  if (rootScrolls()) {
+    cachedScroller = null;
+    return null;
+  }
+  if (cachedScroller && cachedScroller.isConnected && canScroll(cachedScroller)) return cachedScroller;
+  cachedScroller = findScroller();
+  return cachedScroller;
+}
+function applyTo(el, pos) {
+  if (el) {
+    el.scrollTo({ left: pos.x, top: pos.y, behavior: "instant" });
+    return { x: el.scrollLeft, y: el.scrollTop };
+  }
+  window.scrollTo({ left: pos.x, top: pos.y, behavior: "instant" });
+  return { x: window.scrollX, y: window.scrollY };
+}
+electron.ipcRenderer.on(APPLY_SCROLL, (_e, req) => {
+  const pos = { x: req.x, y: req.y };
+  const warnings = [];
+  let scroller = "root";
+  let reached;
+  if (typeof req.selector === "string") {
+    let el = null;
+    try {
+      el = document.querySelector(req.selector);
+    } catch {
+      warnings.push(`scrollSelector ${JSON.stringify(req.selector)} is not a valid CSS selector; nothing was scrolled`);
+    }
+    if (el) {
+      scroller = "element";
+      reached = applyTo(el, pos);
+      if (reached.x !== pos.x || reached.y !== pos.y) {
+        warnings.push(
+          `scrollSelector ${JSON.stringify(req.selector)} matched an element that could not reach (${pos.x}, ${pos.y}); it stopped at (${reached.x}, ${reached.y})`
+        );
+      }
+    } else {
+      if (warnings.length === 0) {
+        warnings.push(`scrollSelector ${JSON.stringify(req.selector)} matched no element; nothing was scrolled`);
+      }
+      reached = { x: window.scrollX, y: window.scrollY };
+    }
+  } else {
+    const el = resolveScroller();
+    scroller = el ? "element" : "root";
+    if (!el) {
+      lastApplied = pos;
+      if (window.scrollX !== pos.x || window.scrollY !== pos.y) suppressUntil = performance.now() + SUPPRESS_MS;
+    }
+    reached = applyTo(el, pos);
+  }
+  if (typeof req.id === "number") {
+    electron.ipcRenderer.send(SCROLL_RESULT, { id: req.id, x: reached.x, y: reached.y, scroller, warnings });
+  }
 });
+exports.MAX_VISITED = MAX_VISITED;
+exports.findScroller = findScroller;
+exports.resolveScroller = resolveScroller;