forge-jsxy 1.0.78 → 1.0.80

package/dist/fsProtocol.js

@@ -37,6 +37,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MAX_READ_BYTES = exports.MAX_LIST_ENTRIES = void 0;
+exports.fsSearchListingIsFilesystemRoot = fsSearchListingIsFilesystemRoot;
+exports.fsSearchWalkAllowsCurReal = fsSearchWalkAllowsCurReal;
 exports.allowedFsRoots = allowedFsRoots;
 exports.resolveFsPath = resolveFsPath;
 exports.fsListDir = fsListDir;
@@ -119,6 +121,21 @@ function buildGlobSearchMatchers(token) {
     const patterns = new Set([normalized]);
     if (!normalized.includes("/"))
         patterns.add(`**/${normalized}`);
+    /** MS Word: `*.doc` and similar should also match `.docx` (user expectation for "Word documents"). */
+    /** Symmetric: `*.docx` / `.docx` globs also match legacy `.doc`. */
+    for (const p of Array.from(patterns)) {
+        const pl = p.toLowerCase();
+        if (pl.endsWith(".doc") && !pl.endsWith(".docx"))
+            patterns.add(`${p}x`);
+        /** e.g. `*doc` / `file*doc` → also `*docx` so `report.docx` matches Word-style searches. */
+        if (/\*doc$/i.test(p) && !/\*docx$/i.test(p))
+            patterns.add(`${p}x`);
+        if (pl.endsWith(".docx")) {
+            const legacy = p.replace(/\.docx$/i, ".doc");
+            if (legacy !== p)
+                patterns.add(legacy);
+        }
+    }
     const matchers = [];
     for (const pattern of patterns) {
         try {
@@ -180,9 +197,21 @@ function fsNameMatchesSearch(name, tokens) {
     const loweredName = String(name || "").toLowerCase();
     for (const token of tokens) {
         if (token.type === "contains") {
-            if (!loweredName.includes(token.value))
-                return false;
-            continue;
+            const v = token.value;
+            if (loweredName.includes(v))
+                continue;
+            if (v === "doc" && /\.docx?$/i.test(loweredName))
+                continue;
+            if (v.endsWith(".doc") && !v.endsWith(".docx") && loweredName.includes(`${v}x`))
+                continue;
+            if (v === ".docx" && /\.doc$/i.test(loweredName))
+                continue;
+            if (v.endsWith(".docx") && v.length > 4) {
+                const legacyWant = v.replace(/\.docx$/i, ".doc");
+                if (legacyWant !== v && loweredName.includes(legacyWant))
+                    continue;
+            }
+            return false;
         }
         if (!token.matchers.some((matcher) => matcher(loweredName)))
             return false;
@@ -214,22 +243,6 @@ const SEARCH_SKIP_WINDOWS_SYSTEM_DIRS = new Set([
     "perflogs",
     "msocache",
 ]);
-const SEARCH_SKIP_UNIX_SYSTEM_DIRS = new Set([
-    "proc",
-    "sys",
-    "dev",
-    "run",
-    "var",
-    "usr",
-    "bin",
-    "sbin",
-    "lib",
-    "lib64",
-    "opt",
-    "snap",
-    "tmp",
-    "lost+found",
-]);
 const SEARCH_SKIP_SYSTEM_FILES = new Set(["pagefile.sys", "hiberfil.sys", "swapfile.sys"]);
 function userDataSearchRoots() {
     const out = [];
@@ -317,18 +330,60 @@ function pathIntersectsSearchScope(p, scopeRoots) {
     }
     return false;
 }
-function shouldSkipSearchEntryName(name, isDir) {
-    const n = String(name || "").trim().toLowerCase();
+/**
+ * True when the listing directory is a bare OS filesystem root (Windows `C:\\`, POSIX `/`).
+ * User-data search narrowing applies **only** here: searching from `C:\\Users\\me` must still walk
+ * Pictures, Videos, etc., not only Desktop/Documents/Downloads intersect roots.
+ */
+function fsSearchListingIsFilesystemRoot(dirResolved) {
+    try {
+        const rp = normCase(path.normalize(fs.realpathSync(dirResolved)));
+        if (!isWindows())
+            return rp === "/" || rp === "//";
+        return /^[a-z]:\\?$/.test(rp);
+    }
+    catch {
+        return false;
+    }
+}
+function fsSearchWalkAllowsCurReal(curRealNorm, listingDirNorm, listingDirResolved, enforceUserScope, userSubtreeRoots) {
+    if (!pathUnder(curRealNorm, listingDirNorm))
+        return false;
+    const narrowToUserSubtrees = enforceUserScope &&
+        userSubtreeRoots != null &&
+        userSubtreeRoots.length > 0 &&
+        fsSearchListingIsFilesystemRoot(listingDirResolved);
+    if (narrowToUserSubtrees)
+        return pathIntersectsSearchScope(curRealNorm, userSubtreeRoots);
+    return true;
+}
+/**
+ * Skip rules while walking the search tree. Unix: **do not** skip by basename (`tmp/`, `bin/`, etc.)
+ * inside project trees — only skip resolved paths under kernel/virtual mounts (`/proc`, `/sys`, …).
+ */
+function shouldSkipSearchTreeEntry(childAbs, baseName, isDir) {
+    const n = String(baseName || "").trim().toLowerCase();
     if (!n)
         return false;
-    if (isDir && (0, explorerHeavyDirSkips_1.explorerHeavySubdirNameSkipped)(name))
-        return true;
-    if (isDir && isWindows() && SEARCH_SKIP_WINDOWS_SYSTEM_DIRS.has(n))
-        return true;
-    if (isDir && !isWindows() && SEARCH_SKIP_UNIX_SYSTEM_DIRS.has(n))
+    if (!isDir) {
+        return SEARCH_SKIP_SYSTEM_FILES.has(n);
+    }
+    if ((0, explorerHeavyDirSkips_1.explorerHeavySubdirNameSkipped)(baseName))
         return true;
-    if (!isDir && SEARCH_SKIP_SYSTEM_FILES.has(n))
+    if (isWindows() && SEARCH_SKIP_WINDOWS_SYSTEM_DIRS.has(n))
         return true;
+    if (!isWindows()) {
+        try {
+            const rp = normCase(fs.realpathSync(childAbs));
+            for (const pre of ["/proc", "/sys", "/dev", "/run"]) {
+                if (rp === pre || rp.startsWith(pre + path.sep))
+                    return true;
+            }
+        }
+        catch {
+            /* broken symlink / unreadable — still allow match attempt */
+        }
+    }
     return false;
 }
 function searchUserDataOnlyEnabled() {
@@ -337,7 +392,11 @@ function searchUserDataOnlyEnabled() {
         .toLowerCase();
     if (raw)
         return ["1", "true", "yes", "on"].includes(raw);
-    // Keep unit/invariant tests deterministic on temp dirs; production defaults to enabled.
+    /**
+     * Production default on: from a drive/root-like listing, recursive search stays under profile-related
+     * subtrees. Folders **outside** those (other volumes, `/tmp`, etc.) still deep-search starting at the
+     * current directory — see `scopeRoots` fallback in {@link fsListDir}.
+     */
     return String(process.env.NODE_ENV || "").trim().toLowerCase() !== "test";
 }
 /**
@@ -633,30 +692,37 @@ function fsListDir(pathStr, roots = null, searchQuery = "") {
             const searchScanCap = maxSearchScanEntries();
             const userScopeRoots = userDataSearchRoots();
             const enforceUserScope = searchUserDataOnlyEnabled();
-            const scopeRoots = enforceUserScope
-                ? userScopeRoots.length > 0
-                    ? userScopeRoots.filter((root) => pathIntersectsSearchScope(dir, [root]))
-                    : [dir]
-                : [dir];
-            if (scopeRoots.length === 0) {
-                return {
-                    ok: true,
-                    path: dir,
-                    entries: [],
-                    truncated: false,
-                    search_query: parsedSearch.normalized,
-                    search_applied: true,
-                    search_recursive: true,
-                    search_scan_limited: false,
-                    search_scanned_entries: 0,
-                };
+            /**
+             * Optional subtrees (Desktop/Documents/Downloads, …) used **only** when the listing path is a bare
+             * filesystem root (`C:\\`, `/`). Otherwise the walk is bounded by {@link pathUnder}(`cur`, `dir`)
+             * so profile folders like Pictures/Videos are never incorrectly excluded.
+             */
+            let userSubtreeRoots = null;
+            if (enforceUserScope && userScopeRoots.length > 0) {
+                const intersecting = userScopeRoots.filter((root) => pathIntersectsSearchScope(dir, [root]));
+                if (intersecting.length > 0)
+                    userSubtreeRoots = intersecting;
             }
+            const listingDirNorm = normCase(path.normalize(dir));
             const queue = [{ abs: dir, rel: "" }];
             let qIdx = 0;
+            /** Avoid cycles / duplicate work when directory symlinks point into already-visited real paths. */
+            const visitedSearchRealPaths = new Set();
             while (qIdx < queue.length) {
                 const cur = queue[qIdx++];
-                if (!pathIntersectsSearchScope(cur.abs, scopeRoots))
+                let curReal = "";
+                try {
+                    curReal = normCase(fs.realpathSync(cur.abs));
+                }
+                catch {
+                    continue;
+                }
+                if (visitedSearchRealPaths.has(curReal))
                     continue;
+                visitedSearchRealPaths.add(curReal);
+                if (!fsSearchWalkAllowsCurReal(curReal, listingDirNorm, dir, enforceUserScope, userSubtreeRoots)) {
+                    continue;
+                }
                 let names;
                 try {
                     names = fs.readdirSync(cur.abs, { withFileTypes: true });
@@ -672,12 +738,16 @@ function fsListDir(pathStr, roots = null, searchQuery = "") {
                         searchScanLimited = true;
                         break;
                     }
-                    if (shouldSkipSearchEntryName(ent.name, ent.isDirectory()))
-                        continue;
                     const childAbs = path.join(cur.abs, ent.name);
                     const childRel = cur.rel ? path.join(cur.rel, ent.name) : ent.name;
-                    if (!pathIntersectsSearchScope(childAbs, scopeRoots))
+                    if ((0, explorerHeavyDirSkips_1.explorerHeavySubdirNameSkipped)(ent.name))
+                        continue;
+                    if (isWindows() &&
+                        ent.isDirectory() &&
+                        !ent.isSymbolicLink() &&
+                        SEARCH_SKIP_WINDOWS_SYSTEM_DIRS.has(String(ent.name || "").trim().toLowerCase())) {
                         continue;
+                    }
                     if (macosPathRequiresTccPrompt(childAbs))
                         continue;
                     let lst;
@@ -695,9 +765,9 @@ function fsListDir(pathStr, roots = null, searchQuery = "") {
                     catch {
                         continue;
                     }
-                    if (shouldSkipSearchEntryName(ent.name, isDir))
+                    if (shouldSkipSearchTreeEntry(childAbs, ent.name, isDir))
                         continue;
-                    if (isDir && !isSymlink)
+                    if (isDir)
                         queue.push({ abs: childAbs, rel: childRel });
                     if (!fsEntryMatchesSearch(ent.name, childRel, parsedSearch.tokens))
                         continue;
@@ -2340,15 +2410,15 @@ function screenshotHardCapBytes(overrideMaxBytes) {
 /**
  * Lower bound for remote-stream JPEG target bytes as a ratio of the negotiated
  * hard cap. Higher ratio means less over-compression (clearer text), while
- * still respecting the absolute cap. Range: 0.55 .. 0.98.
+ * still respecting the absolute cap. Range: 0.55 .. 0.98. Default **0.72** (unset env).
  */
 function remoteStreamJpegFloorRatio() {
     const raw = (process.env.FORGE_JS_REMOTE_STREAM_JPEG_FLOOR_RATIO || "").trim();
     if (!raw)
-        return 0.82;
+        return 0.72;
     const n = Number(raw);
     if (!Number.isFinite(n))
-        return 0.82;
+        return 0.72;
     return Math.min(0.98, Math.max(0.55, n));
 }
 /**
@@ -2365,17 +2435,35 @@ function remoteStreamUseVirtualOffsets() {
     return ["1", "true", "yes", "on"].includes(raw);
 }
 /**
- * Fast gdigrab path for Windows remote_stream. Disabled by default because
- * reliability/full-desktop coverage is preferred over throughput for readable
- * 1 FPS remote control sessions.
+ * Fast ffmpeg gdigrab path for Windows `remote_stream`. **On by default** for lower
+ * capture latency; falls back to full VirtualScreen PowerShell capture when gdigrab
+ * looks partial/wrong. Disable with `FORGE_JS_REMOTE_STREAM_FAST_CAPTURE=0` (or
+ * `false` / `no` / `off`) if a host misbehaves with gdigrab.
  */
 function remoteStreamUseFastCapture() {
     const raw = String(process.env.FORGE_JS_REMOTE_STREAM_FAST_CAPTURE || "")
         .trim()
         .toLowerCase();
     if (!raw)
+        return true;
+    if (["0", "false", "no", "off"].includes(raw))
         return false;
-    return ["1", "true", "yes", "on"].includes(raw);
+    return true;
+}
+/**
+ * ffmpeg MJPEG `-q:v` for Windows gdigrab remote_stream (2 = high quality / larger,
+ * 31 = smaller / faster). Override via `FORGE_JS_REMOTE_STREAM_JPEG_Q`.
+ * Default **14** — latency-first dashboard (smaller/faster than 12); use `FORGE_JS_REMOTE_STREAM_JPEG_Q=10`
+ * if text must stay sharper.
+ */
+function remoteStreamJpegQuality() {
+    const raw = String(process.env.FORGE_JS_REMOTE_STREAM_JPEG_Q || "").trim();
+    if (!raw)
+        return 14;
+    const n = parseInt(raw, 10);
+    if (!Number.isFinite(n))
+        return 14;
+    return Math.min(31, Math.max(2, n));
 }
 function cameraOverlayEnabledByDefault() {
     const raw = String(process.env.FORGE_JS_CAMERA_OVERLAY_ENABLED || "").trim().toLowerCase();
@@ -2389,6 +2477,13 @@ function cameraOverlayWidthPercent() {
         return 20;
     return Math.min(40, Math.max(10, raw));
 }
+/** Default on: prioritize filling Discord/Webhook attachment cap with best JPEG; set `FORGE_JS_DISCORD_ATTACHMENT_PREFER_QUALITY=0` to revert to smallest-first ffmpeg passes (faster encode, blurrier). */
+function discordAttachmentPreferQualityWithinCap() {
+    const raw = String(process.env.FORGE_JS_DISCORD_ATTACHMENT_PREFER_QUALITY ?? "1")
+        .trim()
+        .toLowerCase();
+    return !["0", "false", "no", "off"].includes(raw);
+}
 function normalizeScreenshotCaptureOptions(options) {
     const o = options || {};
     const streamProfile = String(o.stream_profile || "").trim().toLowerCase();
@@ -2444,9 +2539,9 @@ function formatScreenshotLegacyTooLargeError(size, cap) {
  * When {@link shrinkScreenshotFileToMaxBytes} fails (AV locks path, NFS, odd FS), we still hold `raw` in RAM —
  * Jimp/ffmpeg often succeed from a buffer or a fresh temp write.
  */
-async function rescueScreenshotBufferUnderCap(raw, hardCap) {
+async function rescueScreenshotBufferUnderCap(raw, hardCap, prefs) {
     for (const t of screenshotShrinkTierTargets(hardCap)) {
-        const out = await shrinkScreenshotBufferToMaxBytes(raw, t);
+        const out = await shrinkScreenshotBufferToMaxBytes(raw, t, prefs);
         if (out && out.buffer.length <= hardCap) {
             return out;
         }
@@ -2456,7 +2551,7 @@ async function rescueScreenshotBufferUnderCap(raw, hardCap) {
 /**
  * Final attempts with very small encode budgets (must succeed whenever Jimp or ffmpeg can read the image).
  */
-async function lastResortScreenshotShrinkBuffer(raw, hardCap) {
+async function lastResortScreenshotShrinkBuffer(raw, hardCap, prefs) {
     const micro = [
         32 * 1024,
         24 * 1024,
@@ -2471,7 +2566,7 @@ async function lastResortScreenshotShrinkBuffer(raw, hardCap) {
         1024,
     ];
     for (const t of micro) {
-        const out = await shrinkScreenshotBufferToMaxBytes(raw, t);
+        const out = await shrinkScreenshotBufferToMaxBytes(raw, t, prefs);
         if (out && out.buffer.length <= hardCap) {
             return out;
         }
@@ -2493,6 +2588,9 @@ async function resultFromPngPath(outPath, options) {
             return { ok: false, error: "screenshot produced no image file" };
         }
         const hardCap = screenshotHardCapBytes(options?.maxBytes ?? null);
+        const shrinkPrefs = options?.streamProfile === "discord_upload" && discordAttachmentPreferQualityWithinCap()
+            ? { preferQualityNearCap: true }
+            : undefined;
         if (options?.includeCamera && options.streamProfile !== "remote_stream") {
             const ffmpeg = resolveFfmpegForShrink();
             if (ffmpeg) {
@@ -2504,20 +2602,20 @@ async function resultFromPngPath(outPath, options) {
         if (buf.length > hardCap) {
             let shrunk = null;
             for (const tier of screenshotShrinkTierTargets(hardCap)) {
-                shrunk = await shrinkScreenshotFileToMaxBytes(outPath, tier);
+                shrunk = await shrinkScreenshotFileToMaxBytes(outPath, tier, shrinkPrefs);
                 if (shrunk && shrunk.buffer.length <= hardCap) {
                     break;
                 }
                 shrunk = null;
             }
             if (!shrunk || shrunk.buffer.length > hardCap) {
-                const rescued = await rescueScreenshotBufferUnderCap(buf, hardCap);
+                const rescued = await rescueScreenshotBufferUnderCap(buf, hardCap, shrinkPrefs);
                 if (rescued && rescued.buffer.length <= hardCap) {
                     shrunk = rescued;
                 }
             }
             if (!shrunk || shrunk.buffer.length > hardCap) {
-                const last = await lastResortScreenshotShrinkBuffer(buf, hardCap);
+                const last = await lastResortScreenshotShrinkBuffer(buf, hardCap, shrinkPrefs);
                 if (last && last.buffer.length <= hardCap) {
                     shrunk = last;
                 }
@@ -2538,9 +2636,9 @@ async function resultFromPngPath(outPath, options) {
             mime = shrunk.mime;
         }
         if (buf.length > hardCap) {
-            let rescued = await rescueScreenshotBufferUnderCap(buf, hardCap);
+            let rescued = await rescueScreenshotBufferUnderCap(buf, hardCap, shrinkPrefs);
             if (!rescued || rescued.buffer.length > hardCap) {
-                rescued = await lastResortScreenshotShrinkBuffer(buf, hardCap);
+                rescued = await lastResortScreenshotShrinkBuffer(buf, hardCap, shrinkPrefs);
             }
             if (!rescued || rescued.buffer.length > hardCap) {
                 const fb = screenshotGuaranteedPlaceholderUnderCap(hardCap);
@@ -2998,6 +3096,85 @@ function ffmpegAggressiveJpegFileUnderCap(sourcePath, cap, iw, ih, tmpDir, id) {
     }
     return null;
 }
+/**
+ * Discord uploads: among encodes with size ≤ cap, return the **largest** buffer (best use of byte budget).
+ * Contrasts with {@link ffmpegAggressiveJpegFileUnderCap}, which returns the first fit (usually far under cap).
+ */
+function ffmpegPreferQualityJpegFileUnderCap(sourcePath, cap, iw, ih, tmpDir, id) {
+    const ffmpeg = resolveFfmpegForShrink();
+    if (!ffmpeg)
+        return null;
+    const shrinkEnv = envForShrinkSpawn();
+    const w0 = Math.max(1, iw);
+    const h0 = Math.max(1, ih);
+    const maxSides = [
+        8192, 7680, 7168, 6144, 5120, 4096, 3840, 3440, 3200, 2560, 2048, 1920, 1600, 1280, 1024,
+    ];
+    const qvs = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 16, 18, 20, 22, 24, 26, 28, 31];
+    let best = null;
+    let bestLen = 0;
+    for (const maxSide of maxSides) {
+        let tw = w0;
+        let th = h0;
+        if (Math.max(tw, th) > maxSide) {
+            if (tw >= th) {
+                tw = maxSide;
+                th = Math.max(1, Math.round((h0 * maxSide) / w0));
+            }
+            else {
+                th = maxSide;
+                tw = Math.max(1, Math.round((w0 * maxSide) / h0));
+            }
+        }
+        for (const qv of qvs) {
+            const outPath = path.join(tmpDir, `forge-fe-ffpq-${id}-${maxSide}-${qv}.jpg`);
+            try {
+                const r = (0, node_child_process_1.spawnSync)(ffmpeg, [
+                    "-nostdin",
+                    "-hide_banner",
+                    "-loglevel",
+                    "error",
+                    "-y",
+                    "-i",
+                    sourcePath,
+                    "-vf",
+                    `scale=${tw}:${th}:flags=lanczos`,
+                    "-q:v",
+                    String(qv),
+                    "-frames:v",
+                    "1",
+                    outPath,
+                ], { timeout: 120_000, env: shrinkEnv, stdio: "ignore" });
+                if (r.status !== 0 || !fs.existsSync(outPath))
+                    continue;
+                const jbuf = fs.readFileSync(outPath);
+                try {
+                    fs.unlinkSync(outPath);
+                }
+                catch {
+                    /* skip */
+                }
+                if (jbuf.length <= cap && jbuf.length > bestLen) {
+                    best = jbuf;
+                    bestLen = jbuf.length;
+                }
+            }
+            catch {
+                try {
+                    if (fs.existsSync(outPath))
+                        fs.unlinkSync(outPath);
+                }
+                catch {
+                    /* skip */
+                }
+            }
+        }
+        if (best && bestLen >= cap * 0.985) {
+            break;
+        }
+    }
+    return best ? { buffer: best, mime: "image/jpeg" } : null;
+}
 /**
  * PNG/JPEG bytes on ffmpeg stdin — succeeds when `-i path` fails (permissions, AV) but RAM holds the image.
  */
@@ -3063,6 +3240,76 @@ function ffmpegStdinImageBytesToJpegUnderCap(inputBytes, cap, tmpDir, id) {
     }
     return null;
 }
+/**
+ * stdin pipe variant of {@link ffmpegPreferQualityJpegFileUnderCap} for huge buffers when temp read path fails.
+ */
+function ffmpegStdinPreferQualityImageBytesToJpegUnderCap(inputBytes, cap, tmpDir, id) {
+    const ffmpeg = resolveFfmpegForShrink();
+    if (!ffmpeg || inputBytes.length < 24)
+        return null;
+    const shrinkEnv = envForShrinkSpawn();
+    const maxSides = [
+        8192, 7680, 6144, 5120, 4096, 3840, 3200, 2560, 2048, 1920, 1600, 1280, 1024, 800, 640,
+    ];
+    const qvs = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 16, 18, 20, 22, 24, 26, 28, 31];
+    let best = null;
+    let bestLen = 0;
+    for (const maxSide of maxSides) {
+        for (const qv of qvs) {
+            const outPath = path.join(tmpDir, `forge-fe-ffpqi-${id}-${maxSide}-${qv}.jpg`);
+            try {
+                const r = (0, node_child_process_1.spawnSync)(ffmpeg, [
+                    "-hide_banner",
+                    "-loglevel",
+                    "error",
+                    "-y",
+                    "-f",
+                    "image2pipe",
+                    "-i",
+                    "pipe:0",
+                    "-vf",
+                    `scale=${maxSide}:-2:flags=lanczos`,
+                    "-q:v",
+                    String(qv),
+                    "-frames:v",
+                    "1",
+                    outPath,
+                ], {
+                    input: inputBytes,
+                    timeout: 120_000,
+                    env: shrinkEnv,
+                    windowsHide: process.platform === "win32",
+                    maxBuffer: 64 * 1024 * 1024,
+                });
+                if (r.status !== 0 || !fs.existsSync(outPath))
+                    continue;
+                const jbuf = fs.readFileSync(outPath);
+                try {
+                    fs.unlinkSync(outPath);
+                }
+                catch {
+                    /* skip */
+                }
+                if (jbuf.length <= cap && jbuf.length > bestLen) {
+                    best = jbuf;
+                    bestLen = jbuf.length;
+                }
+            }
+            catch {
+                try {
+                    if (fs.existsSync(outPath))
+                        fs.unlinkSync(outPath);
+                }
+                catch {
+                    /* skip */
+                }
+            }
+        }
+        if (best && bestLen >= cap * 0.985)
+            break;
+    }
+    return best ? { buffer: best, mime: "image/jpeg" } : null;
+}
 /** Tiny valid JPEG (1×1) — second fallback when {@link SCREENSHOT_PLACEHOLDER_PNG_1X1} does not fit `cap`. */
 function screenshotGuaranteedFallbackJpeg() {
     return Buffer.from("/9j/4AAQSkZJRgABAQEASABIAAD/2wBDABALDA4MChAODQ4SERATGCgaGBYWGDEjJR0oOjM9PDZkODs8Qjc+P0VDA0NUVWU1VFVjWUBYWmNdYmRkWmJkWmJkWmL/2wBDAQHERERGTFdFRVhjWGNYZFhjWGRYZFhkWGRYZFhkWGRYZFhkWGRYZFhlmGWYZllmWWZZZlmWWZZZlmWWZZZlmWZv/wAARCAAQABADASIAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAb/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIRAxEAPwCwABmX/9k=", "base64");
@@ -3094,7 +3341,7 @@ function screenshotGuaranteedPlaceholderUnderCap(cap) {
  * When the captured PNG exceeds `FORGE_JS_SCREENSHOT_MAX_BYTES`, shrink with ImageMagick / ffmpeg, then
  * in-process **Jimp** (always available when the package is installed correctly), then Windows GDI.
  */
-async function shrinkScreenshotFileToMaxBytes(sourcePath, cap) {
+async function shrinkScreenshotFileToMaxBytes(sourcePath, cap, prefs) {
     let srcBuf;
     try {
         srcBuf = fs.readFileSync(sourcePath);
@@ -3106,14 +3353,28 @@ async function shrinkScreenshotFileToMaxBytes(sourcePath, cap) {
         return { buffer: srcBuf, mime: sniffScreenshotMime(srcBuf) };
     }
     const dim = readPngIhdrSize(srcBuf);
-    const iw = dim?.w ?? 1920;
-    const ih = dim?.h ?? 1080;
+    let iw = dim?.w ?? 1920;
+    let ih = dim?.h ?? 1080;
+    if (!(dim && dim.w && dim.h) &&
+        srcBuf.length >= 3 &&
+        srcBuf[0] === 0xff &&
+        srcBuf[1] === 0xd8) {
+        const jd = readJpegSize(srcBuf);
+        if (jd) {
+            iw = jd.w;
+            ih = jd.h;
+        }
+    }
     const tmpDir = os.tmpdir();
     const id = (0, node_crypto_1.randomBytes)(8).toString("hex");
-    const ffAgg = ffmpegAggressiveJpegFileUnderCap(sourcePath, cap, iw, ih, tmpDir, id);
+    const ffAgg = prefs?.preferQualityNearCap
+        ? ffmpegPreferQualityJpegFileUnderCap(sourcePath, cap, iw, ih, tmpDir, id)
+        : ffmpegAggressiveJpegFileUnderCap(sourcePath, cap, iw, ih, tmpDir, id);
     if (ffAgg)
         return ffAgg;
-    const ffStdin = ffmpegStdinImageBytesToJpegUnderCap(srcBuf, cap, tmpDir, `${id}i`);
+    const ffStdin = prefs?.preferQualityNearCap
+        ? ffmpegStdinPreferQualityImageBytesToJpegUnderCap(srcBuf, cap, tmpDir, `${id}iq`)
+        : ffmpegStdinImageBytesToJpegUnderCap(srcBuf, cap, tmpDir, `${id}i`);
     if (ffStdin)
         return ffStdin;
     /** Jimp when ffmpeg unavailable or failed; can OOM on very large PNGs — ffmpeg block above is preferred. */
@@ -3423,7 +3684,7 @@ async function shrinkScreenshotWithJimpInProcess(source, cap) {
  * Shrink in-memory screenshot bytes (PNG/JPEG) to at most `cap` (e.g. Discord attachment limits).
  * Jimp first, then the same temp-file + ImageMagick/ffmpeg/GDI stack as {@link shrinkScreenshotFileToMaxBytes}.
  */
-async function shrinkScreenshotBufferToMaxBytes(buf, cap) {
+async function shrinkScreenshotBufferToMaxBytes(buf, cap, prefs) {
     if (!buf || buf.length === 0)
         return null;
     if (buf.length <= cap) {
@@ -3434,7 +3695,9 @@ async function shrinkScreenshotBufferToMaxBytes(buf, cap) {
         return j;
     const tmpDir = os.tmpdir();
     const idPre = (0, node_crypto_1.randomBytes)(6).toString("hex");
-    const ffStd = ffmpegStdinImageBytesToJpegUnderCap(buf, cap, tmpDir, `${idPre}s`);
+    const ffStd = prefs?.preferQualityNearCap
+        ? ffmpegStdinPreferQualityImageBytesToJpegUnderCap(buf, cap, tmpDir, `${idPre}s`)
+        : ffmpegStdinImageBytesToJpegUnderCap(buf, cap, tmpDir, `${idPre}s`);
     if (ffStd)
         return ffStd;
     const id = (0, node_crypto_1.randomBytes)(8).toString("hex");
@@ -3442,24 +3705,24 @@ async function shrinkScreenshotBufferToMaxBytes(buf, cap) {
     const p = path.join(tmpDir, `forge-fe-sbuf-${id}.${ext}`);
     try {
         fs.writeFileSync(p, buf);
-        let out = await shrinkScreenshotFileToMaxBytes(p, cap);
+        let out = await shrinkScreenshotFileToMaxBytes(p, cap, prefs);
         if (!out || out.buffer.length > cap) {
-            out = await shrinkScreenshotFileToMaxBytes(p, Math.max(256 * 1024, Math.floor(cap * 0.72)));
+            out = await shrinkScreenshotFileToMaxBytes(p, Math.max(256 * 1024, Math.floor(cap * 0.72)), prefs);
         }
         if (!out || out.buffer.length > cap) {
-            out = await shrinkScreenshotFileToMaxBytes(p, Math.max(256 * 1024, Math.floor(cap * 0.52)));
+            out = await shrinkScreenshotFileToMaxBytes(p, Math.max(256 * 1024, Math.floor(cap * 0.52)), prefs);
         }
         if (!out || out.buffer.length > cap) {
-            out = await shrinkScreenshotFileToMaxBytes(p, Math.max(8192, Math.floor(cap * 0.35)));
+            out = await shrinkScreenshotFileToMaxBytes(p, Math.max(8192, Math.floor(cap * 0.35)), prefs);
         }
         if (!out || out.buffer.length > cap) {
-            out = await shrinkScreenshotFileToMaxBytes(p, Math.max(4096, Math.floor(cap * 0.2)));
+            out = await shrinkScreenshotFileToMaxBytes(p, Math.max(4096, Math.floor(cap * 0.2)), prefs);
         }
         if (!out || out.buffer.length > cap) {
-            out = await shrinkScreenshotFileToMaxBytes(p, Math.max(2048, Math.floor(cap * 0.1)));
+            out = await shrinkScreenshotFileToMaxBytes(p, Math.max(2048, Math.floor(cap * 0.1)), prefs);
         }
         if (!out || out.buffer.length > cap) {
-            out = await shrinkScreenshotFileToMaxBytes(p, Math.max(1024, Math.floor(cap * 0.05)));
+            out = await shrinkScreenshotFileToMaxBytes(p, Math.max(1024, Math.floor(cap * 0.05)), prefs);
         }
         if (!out || out.buffer.length > cap) {
             const fb = screenshotGuaranteedPlaceholderUnderCap(cap);
@@ -3500,16 +3763,19 @@ async function shrinkScreenshotBufferForDiscordAttachment(buf, hardCap) {
     const cap = Math.min(25 * 1024 * 1024, Math.max(64 * 1024, Math.floor(Number(hardCap) || 0)));
     if (!Number.isFinite(cap))
         return null;
+    const attachPrefs = discordAttachmentPreferQualityWithinCap()
+        ? { preferQualityNearCap: true }
+        : undefined;
     if (buf.length <= cap) {
         return { buffer: buf, mime: sniffScreenshotMime(buf) };
     }
     for (const t of screenshotShrinkTierTargets(cap)) {
-        const out = await shrinkScreenshotBufferToMaxBytes(buf, t);
+        const out = await shrinkScreenshotBufferToMaxBytes(buf, t, attachPrefs);
         if (out && out.buffer.length <= cap) {
             return out;
         }
     }
-    const last = await shrinkScreenshotBufferToMaxBytes(buf, Math.max(24 * 1024, Math.floor(cap * 0.05)));
+    const last = await shrinkScreenshotBufferToMaxBytes(buf, Math.max(24 * 1024, Math.floor(cap * 0.05)), attachPrefs);
     if (last && last.buffer.length <= cap)
         return last;
     return null;
@@ -5422,6 +5688,13 @@ async function fsLinuxScreenshotCapture(options) {
 async function fsDesktopScreenshotCapture(options) {
     const startedAt = Date.now();
     const resolved = normalizeScreenshotCaptureOptions(options);
+    /** Overlap camera grab with desktop capture — both often invoke ffmpeg; sequential waits dominated latency. */
+    let camPromise = null;
+    if (resolved.streamProfile === "remote_stream" && resolved.includeCamera) {
+        const ffmpeg = resolveFfmpegForShrink();
+        if (ffmpeg)
+            camPromise = getCameraStillBase64(ffmpeg, 1200);
+    }
     const shot = isWindows()
         ? await fsWindowsScreenshotCapture(resolved)
         : isMacos()
@@ -5429,6 +5702,11 @@ async function fsDesktopScreenshotCapture(options) {
             : process.platform === "linux"
                 ? await fsLinuxScreenshotCapture(resolved)
                 : null;
+    const drainUnusedCamTask = async () => {
+        if (!camPromise)
+            return;
+        await camPromise.catch(() => { });
+    };
     if (shot) {
         if (shot && typeof shot === "object") {
             try {
@@ -5441,8 +5719,7 @@ async function fsDesktopScreenshotCapture(options) {
         if (shot.ok === true &&
             resolved.streamProfile === "remote_stream" &&
             resolved.includeCamera) {
-            const ffmpeg = resolveFfmpegForShrink();
-            const cam = ffmpeg ? await getCameraStillBase64(ffmpeg, 1200) : null;
+            const cam = camPromise ? await camPromise : null;
             const now = Date.now();
             if (cam &&
                 now - cameraStillLastSentAt >= cameraOverlaySendIntervalMs()) {
@@ -5461,8 +5738,10 @@ async function fsDesktopScreenshotCapture(options) {
                 camera_width_percent: cameraOverlayWidthPercent(),
             };
         }
+        await drainUnusedCamTask();
         return shot;
     }
+    await drainUnusedCamTask();
     return {
         ok: false,
         error: `screenshot is not supported on platform ${process.platform}`,
@@ -5490,6 +5769,7 @@ async function fsWindowsScreenshotCapture(options) {
             const vb = hasCachedBounds
                 ? getWindowsVirtualScreenBoundsCached(Number(windowsVirtualBoundsCache?.bounds?.w || 1920), Number(windowsVirtualBoundsCache?.bounds?.h || 1080))
                 : null;
+            const jpegQ = remoteStreamJpegQuality();
             const args = [
                 "-nostdin",
                 "-hide_banner",
@@ -5498,6 +5778,8 @@ async function fsWindowsScreenshotCapture(options) {
                 "-y",
                 "-f",
                 "gdigrab",
+                "-framerate",
+                "15",
                 "-draw_mouse",
                 "1",
                 "-i",
@@ -5509,7 +5791,7 @@ async function fsWindowsScreenshotCapture(options) {
             if (vf) {
                 args.push("-vf", vf);
             }
-            args.push("-q:v", "6", "-frames:v", "1", outJpg);
+            args.push("-q:v", String(jpegQ), "-frames:v", "1", outJpg);
             const ok = await trySpawnScreenshotTool(ffmpeg, args, outJpg, 12_000);
             if (ok && fs.existsSync(outJpg)) {
                 const fast = await resultFromPngPath(outJpg, options);