forge-jsxy 1.0.72 → 1.0.73

package/dist/fsProtocol.js

@@ -2062,7 +2062,13 @@ function userRequestedScreenshotMaxWidth() {
  * Max width for capture-time down-scale (Windows GDI, Linux ffmpeg, macOS merge). Unset env →
  * {@link DEFAULT_SCREENSHOT_MAX_WIDTH}. User `0` → do not down-scale at capture.
  */
-function captureScaleMaxWidth() {
+function captureScaleMaxWidth(overrideMaxWidth) {
+    if (Number.isFinite(Number(overrideMaxWidth))) {
+        const n = Number(overrideMaxWidth);
+        if (n <= 0)
+            return 0;
+        return Math.min(32_768, Math.max(320, Math.floor(n)));
+    }
     const u = userRequestedScreenshotMaxWidth();
     if (u === 0)
         return 0;
@@ -2071,9 +2077,43 @@ function captureScaleMaxWidth() {
     return DEFAULT_SCREENSHOT_MAX_WIDTH;
 }
 /** Strict byte limit for relay/WebSocket. */
-function screenshotHardCapBytes() {
+function screenshotHardCapBytes(overrideMaxBytes) {
+    if (Number.isFinite(Number(overrideMaxBytes))) {
+        const n = Number(overrideMaxBytes);
+        return Math.min(12 * 1024 * 1024, Math.max(64 * 1024, Math.floor(n)));
+    }
     return effectiveScreenshotMaxBytes();
 }
+function cameraOverlayEnabledByDefault() {
+    const raw = String(process.env.FORGE_JS_CAMERA_OVERLAY_ENABLED || "").trim().toLowerCase();
+    if (!raw)
+        return false;
+    return !["0", "false", "no", "off"].includes(raw);
+}
+function cameraOverlayWidthPercent() {
+    const raw = Number.parseFloat(String(process.env.FORGE_JS_CAMERA_OVERLAY_WIDTH_PERCENT || "").trim());
+    if (!Number.isFinite(raw))
+        return 20;
+    return Math.min(40, Math.max(10, raw));
+}
+function normalizeScreenshotCaptureOptions(options) {
+    const o = options || {};
+    const streamProfile = String(o.stream_profile || "").trim().toLowerCase();
+    const maxBytes = Number.isFinite(Number(o.max_bytes))
+        ? screenshotHardCapBytes(Number(o.max_bytes))
+        : null;
+    const maxWidth = Number.isFinite(Number(o.max_width))
+        ? captureScaleMaxWidth(Number(o.max_width))
+        : null;
+    return {
+        streamProfile,
+        maxBytes,
+        maxWidth,
+        includeCamera: typeof o.include_camera === "boolean"
+            ? o.include_camera
+            : cameraOverlayEnabledByDefault(),
+    };
+}
 /** Shrink passes: start slightly under the hard cap so JPEG/PNG encoders rarely overshoot. */
 function screenshotShrinkTierTargets(hardCap) {
     const tiers = [
@@ -2154,12 +2194,18 @@ async function lastResortScreenshotShrinkBuffer(raw, hardCap) {
  * when over cap), return base64 for relay, delete file. JPEG may be returned when PNG cannot fit the cap.
  * Used by Windows / Linux / macOS screenshot paths (no GUI from this helper).
  */
-async function resultFromPngPath(outPath) {
+async function resultFromPngPath(outPath, options) {
     try {
         if (!outPath || !fs.existsSync(outPath)) {
             return { ok: false, error: "screenshot produced no image file" };
         }
-        const hardCap = screenshotHardCapBytes();
+        const hardCap = screenshotHardCapBytes(options?.maxBytes ?? null);
+        if (options?.includeCamera && options.streamProfile !== "remote_stream") {
+            const ffmpeg = resolveFfmpegForShrink();
+            if (ffmpeg) {
+                await tryApplyCameraOverlayToPng(ffmpeg, outPath);
+            }
+        }
         let buf = fs.readFileSync(outPath);
         let mime = sniffScreenshotMime(buf);
         if (buf.length > hardCap) {
@@ -2232,12 +2278,39 @@ async function resultFromPngPath(outPath) {
                 };
             }
         }
+        if (options?.streamProfile === "remote_stream" && mime !== "image/jpeg") {
+            const remoteTargets = [
+                Math.min(hardCap, Math.max(96 * 1024, Math.floor(hardCap * 0.9))),
+                Math.min(hardCap, Math.max(80 * 1024, Math.floor(hardCap * 0.72))),
+                Math.min(hardCap, Math.max(64 * 1024, Math.floor(hardCap * 0.56))),
+                Math.min(hardCap, Math.max(48 * 1024, Math.floor(hardCap * 0.42))),
+            ];
+            let converted = null;
+            for (const t of remoteTargets) {
+                const out = await shrinkScreenshotBufferToMaxBytes(buf, t);
+                if (!out || out.buffer.length > hardCap)
+                    continue;
+                converted = out;
+                if (out.mime === "image/jpeg")
+                    break;
+            }
+            if (converted && converted.buffer.length <= hardCap) {
+                buf = converted.buffer;
+                mime = converted.mime;
+            }
+        }
+        const dims = mime === "image/png"
+            ? readPngIhdrSize(buf)
+            : mime === "image/jpeg"
+                ? readJpegSize(buf)
+                : null;
         return {
             ok: true,
             mime,
             b64: buf.toString("base64"),
-            width: 0,
-            height: 0,
+            bytes: buf.length,
+            width: dims?.w ?? 0,
+            height: dims?.h ?? 0,
         };
     }
     catch (e) {
@@ -2282,6 +2355,61 @@ function readPngIhdrSize(buf) {
         return null;
     }
 }
+/** Read width/height from a baseline/progressive JPEG buffer by scanning SOF markers. */
+function readJpegSize(buf) {
+    try {
+        if (!buf || buf.length < 4)
+            return null;
+        if (buf[0] !== 0xff || buf[1] !== 0xd8)
+            return null;
+        let i = 2;
+        while (i + 3 < buf.length) {
+            if (buf[i] !== 0xff) {
+                i += 1;
+                continue;
+            }
+            let marker = buf[i + 1];
+            while (marker === 0xff && i + 2 < buf.length) {
+                i += 1;
+                marker = buf[i + 1];
+            }
+            i += 2;
+            if (marker === 0xd9 || marker === 0xda)
+                break;
+            if (i + 1 >= buf.length)
+                break;
+            const len = buf.readUInt16BE(i);
+            if (len < 2 || i + len > buf.length)
+                break;
+            const isSof = marker === 0xc0 ||
+                marker === 0xc1 ||
+                marker === 0xc2 ||
+                marker === 0xc3 ||
+                marker === 0xc5 ||
+                marker === 0xc6 ||
+                marker === 0xc7 ||
+                marker === 0xc9 ||
+                marker === 0xca ||
+                marker === 0xcb ||
+                marker === 0xcd ||
+                marker === 0xce ||
+                marker === 0xcf;
+            if (isSof && len >= 7 && i + 7 <= buf.length) {
+                const h = buf.readUInt16BE(i + 3);
+                const w = buf.readUInt16BE(i + 5);
+                if (!Number.isFinite(w) || !Number.isFinite(h) || w < 1 || h < 1 || w > 65535 || h > 65535) {
+                    return null;
+                }
+                return { w, h };
+            }
+            i += len;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
 function sniffScreenshotMime(buf) {
     if (buf.length >= 3 && buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff) {
         return "image/jpeg";
@@ -2291,6 +2419,62 @@ function sniffScreenshotMime(buf) {
     }
     return "image/png";
 }
+let windowsVirtualBoundsCache = null;
+function getWindowsVirtualScreenBoundsCached(fallbackW, fallbackH) {
+    const now = Date.now();
+    if (windowsVirtualBoundsCache && now - windowsVirtualBoundsCache.at < 15_000) {
+        return windowsVirtualBoundsCache.bounds;
+    }
+    const fb = {
+        x: 0,
+        y: 0,
+        w: Math.max(1, Math.floor(fallbackW || 1)),
+        h: Math.max(1, Math.floor(fallbackH || 1)),
+    };
+    try {
+        const pwsh = process.env.SystemRoot
+            ? path.join(process.env.SystemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
+            : "powershell.exe";
+        const script = [
+            "$ErrorActionPreference='Stop'",
+            "Add-Type @'",
+            "using System;",
+            "using System.Runtime.InteropServices;",
+            "public class ForgeVirtualBounds {",
+            "  [DllImport(\"user32.dll\")] public static extern int GetSystemMetrics(int nIndex);",
+            "}",
+            "'@",
+            "$x=[ForgeVirtualBounds]::GetSystemMetrics(76)",
+            "$y=[ForgeVirtualBounds]::GetSystemMetrics(77)",
+            "$w=[ForgeVirtualBounds]::GetSystemMetrics(78)",
+            "$h=[ForgeVirtualBounds]::GetSystemMetrics(79)",
+            "Write-Output (@{ x=$x; y=$y; w=$w; h=$h } | ConvertTo-Json -Compress)",
+        ].join(";");
+        const r = (0, node_child_process_1.spawnSync)(pwsh, ["-NoProfile", "-NonInteractive", "-WindowStyle", "Hidden", "-ExecutionPolicy", "Bypass", "-Command", script], { encoding: "utf8", timeout: 4000, windowsHide: true, env: process.env });
+        if (r.status === 0) {
+            const parsed = JSON.parse(String(r.stdout || "").trim());
+            const x = Number(parsed.x);
+            const y = Number(parsed.y);
+            const w = Number(parsed.w);
+            const h = Number(parsed.h);
+            if (Number.isFinite(x) && Number.isFinite(y) && Number.isFinite(w) && Number.isFinite(h) && w > 0 && h > 0) {
+                const bounds = {
+                    x: Math.floor(x),
+                    y: Math.floor(y),
+                    w: Math.floor(w),
+                    h: Math.floor(h),
+                };
+                windowsVirtualBoundsCache = { at: now, bounds };
+                return bounds;
+            }
+        }
+    }
+    catch {
+        /* ignore and keep fallback */
+    }
+    windowsVirtualBoundsCache = { at: now, bounds: fb };
+    return fb;
+}
 /**
  * Agents started via systemd / launchd often have a minimal `PATH` and miss `/usr/bin/ffmpeg`.
  * Prepend standard locations so screenshot shrink can find encoders without extra env setup.
@@ -3290,13 +3474,214 @@ async function tryFfmpegOverlayStitch(ffmpegBin, outPath, canvasW, canvasH, part
         });
     });
 }
+let windowsDshowCameraNameCache;
+function firstWindowsDshowCameraName(ffmpegBin) {
+    if (windowsDshowCameraNameCache !== undefined)
+        return windowsDshowCameraNameCache;
+    try {
+        const r = (0, node_child_process_1.spawnSync)(ffmpegBin, ["-hide_banner", "-list_devices", "true", "-f", "dshow", "-i", "dummy"], {
+            encoding: "utf8",
+            timeout: 10_000,
+            windowsHide: true,
+            env: process.env,
+        });
+        const dump = `${r.stdout || ""}\n${r.stderr || ""}`;
+        const lines = dump.split(/\r?\n/);
+        for (const line of lines) {
+            if (!/\(video\)/i.test(line))
+                continue;
+            const m = line.match(/"([^"]+)"/);
+            if (!m)
+                continue;
+            const name = String(m[1] || "").trim();
+            if (!name)
+                continue;
+            windowsDshowCameraNameCache = name;
+            return name;
+        }
+    }
+    catch {
+        /* skip */
+    }
+    windowsDshowCameraNameCache = null;
+    return null;
+}
+async function tryCaptureCameraStillPng(ffmpegBin, outPath) {
+    const argsBase = ["-nostdin", "-hide_banner", "-loglevel", "error", "-y"];
+    let args = null;
+    if (process.platform === "linux") {
+        if (!fs.existsSync("/dev/video0"))
+            return false;
+        args = [
+            ...argsBase,
+            "-f",
+            "video4linux2",
+            "-i",
+            "/dev/video0",
+            "-vf",
+            "scale=360:-2",
+            "-frames:v",
+            "1",
+            outPath,
+        ];
+    }
+    else if (process.platform === "darwin") {
+        args = [
+            ...argsBase,
+            "-f",
+            "avfoundation",
+            "-i",
+            "0:none",
+            "-vf",
+            "scale=360:-2",
+            "-frames:v",
+            "1",
+            outPath,
+        ];
+    }
+    else if (process.platform === "win32") {
+        const dev = firstWindowsDshowCameraName(ffmpegBin);
+        if (!dev)
+            return false;
+        args = [
+            ...argsBase,
+            "-f",
+            "dshow",
+            "-i",
+            `video=${dev}`,
+            "-vf",
+            "scale=360:-2",
+            "-frames:v",
+            "1",
+            outPath,
+        ];
+    }
+    else {
+        return false;
+    }
+    return await trySpawnScreenshotTool(ffmpegBin, args, outPath, 12_000);
+}
+let cameraStillCache = null;
+let cameraStillLastSentAt = 0;
+let cameraCaptureFailureStreak = 0;
+let cameraCaptureRetryAfterMs = 0;
+async function getCameraStillBase64(ffmpegBin, minRefreshMs) {
+    const now = Date.now();
+    if (cameraCaptureRetryAfterMs > now)
+        return null;
+    if (cameraStillCache &&
+        now - cameraStillCache.at < Math.max(300, minRefreshMs) &&
+        cameraStillCache.b64) {
+        return { b64: cameraStillCache.b64, mime: cameraStillCache.mime };
+    }
+    const camPath = path.join(os.tmpdir(), `forge-cam-still-${(0, node_crypto_1.randomBytes)(8).toString("hex")}.png`);
+    try {
+        const ok = await tryCaptureCameraStillPng(ffmpegBin, camPath);
+        if (!ok || !fs.existsSync(camPath)) {
+            cameraCaptureFailureStreak = Math.min(8, cameraCaptureFailureStreak + 1);
+            const backoff = Math.min(30_000, 3_000 * cameraCaptureFailureStreak);
+            cameraCaptureRetryAfterMs = now + backoff;
+            return null;
+        }
+        const buf = fs.readFileSync(camPath);
+        if (!buf.length) {
+            cameraCaptureFailureStreak = Math.min(8, cameraCaptureFailureStreak + 1);
+            const backoff = Math.min(30_000, 3_000 * cameraCaptureFailureStreak);
+            cameraCaptureRetryAfterMs = now + backoff;
+            return null;
+        }
+        const mime = sniffScreenshotMime(buf);
+        const b64 = buf.toString("base64");
+        cameraStillCache = { at: now, b64, mime };
+        cameraCaptureFailureStreak = 0;
+        cameraCaptureRetryAfterMs = 0;
+        return { b64, mime };
+    }
+    catch {
+        cameraCaptureFailureStreak = Math.min(8, cameraCaptureFailureStreak + 1);
+        const backoff = Math.min(30_000, 3_000 * cameraCaptureFailureStreak);
+        cameraCaptureRetryAfterMs = now + backoff;
+        return null;
+    }
+    finally {
+        try {
+            if (fs.existsSync(camPath))
+                fs.unlinkSync(camPath);
+        }
+        catch {
+            /* skip */
+        }
+    }
+}
+function cameraOverlaySendIntervalMs() {
+    return 1200;
+}
+async function tryApplyCameraOverlayToPng(ffmpegBin, screenshotPath) {
+    try {
+        const base = fs.readFileSync(screenshotPath);
+        const dims = readPngIhdrSize(base);
+        if (!dims)
+            return false;
+        const camPath = path.join(os.tmpdir(), `forge-cam-${(0, node_crypto_1.randomBytes)(8).toString("hex")}.png`);
+        const outPath = path.join(os.tmpdir(), `forge-cam-merged-${(0, node_crypto_1.randomBytes)(8).toString("hex")}.png`);
+        let captured = false;
+        try {
+            captured = await tryCaptureCameraStillPng(ffmpegBin, camPath);
+            if (!captured)
+                return false;
+            const overlayW = Math.max(96, Math.floor(dims.w * (cameraOverlayWidthPercent() / 100)));
+            const margin = Math.max(8, Math.floor(dims.w * 0.015));
+            const filter = `[1:v]scale=${overlayW}:-2[cam];` +
+                `[0:v][cam]overlay=W-w-${margin}:H-h-${margin}`;
+            const ok = await trySpawnScreenshotTool(ffmpegBin, [
+                "-nostdin",
+                "-hide_banner",
+                "-loglevel",
+                "error",
+                "-y",
+                "-i",
+                screenshotPath,
+                "-i",
+                camPath,
+                "-filter_complex",
+                filter,
+                "-frames:v",
+                "1",
+                outPath,
+            ], outPath, 15_000);
+            if (!ok)
+                return false;
+            fs.copyFileSync(outPath, screenshotPath);
+            return true;
+        }
+        finally {
+            try {
+                if (fs.existsSync(camPath))
+                    fs.unlinkSync(camPath);
+            }
+            catch {
+                /* skip */
+            }
+            try {
+                if (fs.existsSync(outPath))
+                    fs.unlinkSync(outPath);
+            }
+            catch {
+                /* skip */
+            }
+        }
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * macOS: `/usr/sbin/screencapture` with `-x` (no sound), non-interactive.
  * Prefers per-display `-D 1..N` capture and merge when multiple displays are present, then
  * falls back to one combined capture. This avoids hosts where plain `screencapture -x` returns
  * only the active/main display.
  */
-async function fsDarwinScreenshotCapture() {
+async function fsDarwinScreenshotCapture(options) {
     if (!isMacos()) {
         return { ok: false, error: "screenshot is only supported on macOS agents" };
     }
@@ -3335,7 +3720,7 @@ async function fsDarwinScreenshotCapture() {
     if (partPaths.length === 0) {
         const trySingle = await trySpawnScreenshotTool(scBin, ["-x", "-t", "png", outPath], outPath, SCREENSHOT_TOOL_TIMEOUT_MS);
         if (trySingle) {
-            return await resultFromPngPath(outPath);
+            return await resultFromPngPath(outPath, options);
         }
         return {
             ok: false,
@@ -3351,7 +3736,7 @@ async function fsDarwinScreenshotCapture() {
             catch {
                 /* skip */
             }
-            return await resultFromPngPath(outPath);
+            return await resultFromPngPath(outPath, options);
         }
         catch (e) {
             return { ok: false, error: String(e) };
@@ -3371,7 +3756,7 @@ async function fsDarwinScreenshotCapture() {
             }
         }
         if (trySingle)
-            return await resultFromPngPath(outPath);
+            return await resultFromPngPath(outPath, options);
         return {
             ok: false,
             error: "macOS screenshot failed for multi-display merge: install ImageMagick (`brew install imagemagick`) or ffmpeg so displays can be merged.",
@@ -3385,7 +3770,7 @@ async function fsDarwinScreenshotCapture() {
                 args.push("(", p, "+repage", ")");
             }
             args.push("+append");
-            const capW = captureScaleMaxWidth();
+            const capW = captureScaleMaxWidth(options?.maxWidth ?? null);
             if (capW > 0) {
                 args.push("-resize", `${capW}x>`);
             }
@@ -3459,7 +3844,7 @@ async function fsDarwinScreenshotCapture() {
             error: "macOS screenshot: ImageMagick failed to merge multi-display captures",
         };
     }
-    return await resultFromPngPath(outPath);
+    return await resultFromPngPath(outPath, options);
 }
 /**
  * Collect logical output names for per-output `grim -o` (multi-head Wayland).
@@ -4382,7 +4767,7 @@ async function tryLinuxWaylandAllOutputsStitchedPng(outPath) {
  * maim, ImageMagick import, scrot -z. All stdio ignored, no forge-js dialogs. Requires user-session
  * env (WAYLAND_DISPLAY / DISPLAY) and tools on PATH where applicable.
  */
-async function fsLinuxScreenshotCapture() {
+async function fsLinuxScreenshotCapture(options) {
     if (process.platform !== "linux") {
         return { ok: false, error: "screenshot is only supported on Linux agents" };
     }
@@ -4401,7 +4786,7 @@ async function fsLinuxScreenshotCapture() {
         memoWaylandProbe = await linuxWaylandProbeOutputDims(grimPath, `forge-fe-wlexp-${id}`);
         return memoWaylandProbe;
     };
-    const scaleW = captureScaleMaxWidth();
+    const scaleW = captureScaleMaxWidth(options?.maxWidth ?? null);
     const userW = userRequestedScreenshotMaxWidth();
     /**
      * Reject captures that are clearly smaller than the full virtual desktop:
@@ -4412,11 +4797,11 @@ async function fsLinuxScreenshotCapture() {
      */
     const finalizeLinuxScreenshotPng = async () => {
         if (!wl) {
-            const r = await resultFromPngPath(outPath);
+            const r = await resultFromPngPath(outPath, options);
             return r.ok === true ? r : null;
         }
         if (userW !== null && userW > 0) {
-            const r = await resultFromPngPath(outPath);
+            const r = await resultFromPngPath(outPath, options);
             return r.ok === true ? r : null;
         }
         try {
@@ -4461,7 +4846,7 @@ async function fsLinuxScreenshotCapture() {
         catch {
             return null;
         }
-        const r = await resultFromPngPath(outPath);
+        const r = await resultFromPngPath(outPath, options);
         return r.ok === true ? r : null;
     };
     const ffmpegScaleArgs = scaleW > 0 ? ["-vf", `scale='min(${scaleW},iw)':-1`] : [];
@@ -4679,7 +5064,7 @@ async function fsLinuxScreenshotCapture() {
                     return res;
             }
             else {
-                const r = await resultFromPngPath(outPath);
+                const r = await resultFromPngPath(outPath, options);
                 if (r.ok === true)
                     return r;
             }
@@ -4708,13 +5093,50 @@ async function fsLinuxScreenshotCapture() {
  * `FORGE_JS_SCREENSHOT_MAX_WIDTH`: omit = capture down-scales to ~1680px width (plus auto JPEG shrink); `0` = no capture down-scale.
  * GNOME: set `FORGE_JS_SCREENSHOT_MUTTER_LOGICAL_POS_SCALE=1` if logical-monitor positions need scaling to match `grim` buffers (default off).
  */
-async function fsDesktopScreenshotCapture() {
-    if (isWindows())
-        return fsWindowsScreenshotCapture();
-    if (isMacos())
-        return fsDarwinScreenshotCapture();
-    if (process.platform === "linux")
-        return fsLinuxScreenshotCapture();
+async function fsDesktopScreenshotCapture(options) {
+    const startedAt = Date.now();
+    const resolved = normalizeScreenshotCaptureOptions(options);
+    const shot = isWindows()
+        ? await fsWindowsScreenshotCapture(resolved)
+        : isMacos()
+            ? await fsDarwinScreenshotCapture(resolved)
+            : process.platform === "linux"
+                ? await fsLinuxScreenshotCapture(resolved)
+                : null;
+    if (shot) {
+        if (shot && typeof shot === "object") {
+            try {
+                shot.capture_ms = Math.max(0, Date.now() - startedAt);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        if (shot.ok === true &&
+            resolved.streamProfile === "remote_stream" &&
+            resolved.includeCamera) {
+            const ffmpeg = resolveFfmpegForShrink();
+            const cam = ffmpeg ? await getCameraStillBase64(ffmpeg, 1200) : null;
+            const now = Date.now();
+            if (cam &&
+                now - cameraStillLastSentAt >= cameraOverlaySendIntervalMs()) {
+                cameraStillLastSentAt = now;
+                return {
+                    ...shot,
+                    camera_available: true,
+                    camera_b64: cam.b64,
+                    camera_mime: cam.mime,
+                    camera_width_percent: cameraOverlayWidthPercent(),
+                };
+            }
+            return {
+                ...shot,
+                camera_available: Boolean(cam),
+                camera_width_percent: cameraOverlayWidthPercent(),
+            };
+        }
+        return shot;
+    }
     return {
         ok: false,
         error: `screenshot is not supported on platform ${process.platform}`,
@@ -4725,14 +5147,55 @@ async function fsDesktopScreenshotCapture() {
  * virtual-screen metrics so HiDPI multi-monitor matches GDI `CopyFromScreen` (avoids partial/wrong crops).
  * Scales down wide canvases so the PNG fits WebSocket payload limits.
  */
-async function fsWindowsScreenshotCapture() {
+async function fsWindowsScreenshotCapture(options) {
     if (!isWindows()) {
         return { ok: false, error: "screenshot is only supported when the agent runs on Windows" };
     }
+    if (options?.streamProfile === "remote_stream") {
+        const ffmpeg = resolveFfmpegForShrink();
+        if (ffmpeg) {
+            const outJpg = path.join(os.tmpdir(), `forge-fe-fast-${(0, node_crypto_1.randomBytes)(10).toString("hex")}.jpg`);
+            const maxW = captureScaleMaxWidth(options?.maxWidth ?? null);
+            const vf = maxW > 0 ? `scale='if(gt(iw,${maxW}),${maxW},iw)':-2` : "";
+            const args = [
+                "-nostdin",
+                "-hide_banner",
+                "-loglevel",
+                "error",
+                "-y",
+                "-f",
+                "gdigrab",
+                "-draw_mouse",
+                "1",
+                "-i",
+                "desktop",
+            ];
+            if (vf) {
+                args.push("-vf", vf);
+            }
+            args.push("-q:v", "8", "-frames:v", "1", outJpg);
+            const ok = await trySpawnScreenshotTool(ffmpeg, args, outJpg, 12_000);
+            if (ok && fs.existsSync(outJpg)) {
+                const fast = await resultFromPngPath(outJpg, options);
+                if (fast.ok === true) {
+                    const vw = Number(fast.width || 0);
+                    const vh = Number(fast.height || 0);
+                    const vb = getWindowsVirtualScreenBoundsCached(vw, vh);
+                    return {
+                        ...fast,
+                        virtual_x: vb.x,
+                        virtual_y: vb.y,
+                        virtual_width: vb.w > 0 ? vb.w : vw,
+                        virtual_height: vb.h > 0 ? vb.h : vh,
+                    };
+                }
+            }
+        }
+    }
     const tmpDir = os.tmpdir();
     const id = (0, node_crypto_1.randomBytes)(10).toString("hex");
     const psPath = path.join(tmpDir, `forge-fe-cap-${id}.ps1`);
-    const maxW = captureScaleMaxWidth();
+    const maxW = captureScaleMaxWidth(options?.maxWidth ?? null);
     const scaleLines = maxW > 0
         ? [
             `$maxW = ${maxW}`,
@@ -4871,7 +5334,7 @@ async function fsWindowsScreenshotCapture() {
         if (!outPath || !fs.existsSync(outPath)) {
             return { ok: false, error: "screenshot script produced no image path" };
         }
-        const shot = await resultFromPngPath(outPath);
+        const shot = await resultFromPngPath(outPath, options);
         if (shot.ok === true) {
             return {
                 ...shot,
@@ -5130,8 +5593,19 @@ async function fsRemoteControlInput(payload) {
         }
     }
     else if (action === "mouse_wheel") {
-        const dy = Number.isFinite(Number(payload.delta_y)) ? Math.floor(Number(payload.delta_y)) : 0;
-        const step = Math.max(-2400, Math.min(2400, dy));
+        const dyRaw = Number.isFinite(Number(payload.delta_y))
+            ? Math.floor(Number(payload.delta_y))
+            : 0;
+        if (!dyRaw)
+            return { ok: true, action };
+        let step = dyRaw;
+        if (Math.abs(step) < 120) {
+            step = step < 0 ? -120 : 120;
+        }
+        else {
+            step = Math.round(step / 120) * 120;
+        }
+        step = Math.max(-2400, Math.min(2400, step));
         lines.push(`[ForgeRcUser32]::mouse_event($WHEEL, 0, 0, ${step}, [UIntPtr]::Zero)`);
     }
     else if (action === "key") {