imgtune 0.1.0 → 0.3.0

package/dist/browser.js

@@ -14,11 +14,11 @@ export function mapLaunchError(err) {
     return /Executable doesn['’]t exist/.test(text) ? new ChromiumMissingError() : err;
 }
 /**
- * Chromium flags for measuring. `--disable-software-rasterizer` stops Chrome from starting SwiftShader. Its worker
- * threads get a CPU set of their own from Chrome, which can fall outside the CPUs the CLI was started on.
- * Measurements (layout, rendered sizes, transferred bytes, image decoding) do not depend on the rasterizer.
+ * Chromium flags for measuring. `--disable-gpu` keeps the GPU process out. The software rasterizer (SwiftShader) is left
+ * on: with `--disable-software-rasterizer` WebGL is off, and a page with a 3D viewer never requests its model (a census
+ * site made 5 model requests with the default flags and none without). Only WebGL pages pay the extra CPU for it.
  */
-export const CHROMIUM_ARGS = ["--disable-gpu", "--disable-software-rasterizer"];
+export const CHROMIUM_ARGS = ["--disable-gpu"];
 /** The headless Chromium every measuring command uses. */
 export async function launchChromium() {
     try {

package/dist/candidates.js

@@ -13,6 +13,31 @@ export function rightCandidate(candidates, needed) {
     const sorted = [...candidates].sort((a, b) => a.width - b.width);
     return sorted.find((c) => c.width >= needed) ?? sorted[sorted.length - 1];
 }
+/** The device-pixel step a plain image's variant widths are rounded up to. */
+export const SRCSET_WIDTH_STEP = 10;
+/** A plain image gets at most this many variant widths, one file each. */
+export const SRCSET_MAX_WIDTHS = 3;
+/** The widths of a srcset as printed: "190w, 270w, 380w". */
+export function srcsetWidthLabel(widths) {
+    return widths.map((w) => `${w}w`).join(", ");
+}
+/**
+ * The widths the variants of a plain image (no srcset today) need: each device-pixel need rounded up to SRCSET_WIDTH_STEP
+ * and capped at the file's own width. More than SRCSET_MAX_WIDTHS are merged by joining the closest pair and keeping the
+ * larger, so every need is still covered by a file at least as wide. Sorted ascending; empty when no need is known.
+ */
+export function srcsetWidthsOf(needs, naturalWidth) {
+    const cap = naturalWidth !== undefined && naturalWidth > 0 ? naturalWidth : Infinity;
+    const widths = [...new Set(needs.filter((n) => n > 0).map((n) => Math.min(Math.ceil(n / SRCSET_WIDTH_STEP) * SRCSET_WIDTH_STEP, cap)))].sort((a, b) => a - b);
+    while (widths.length > SRCSET_MAX_WIDTHS) {
+        let at = 0;
+        for (let i = 1; i < widths.length - 1; i++)
+            if (widths[i + 1] - widths[i] < widths[at + 1] - widths[at])
+                at = i;
+        widths.splice(at, 1);
+    }
+    return widths;
+}
 /** The served file is undersized: its pixels are below 0.9 x need, and a larger candidate exists. */
 export function isUndersized(servedWidth, needed, largest) {
     return servedWidth < UNDERSIZED_RATIO * needed && servedWidth < largest;

package/dist/check-report.js

@@ -1,12 +1,14 @@
 // The Markdown report of `imgtune check`: a pure builder over the survey results, the deep results, the route grouping and
 // the deep selection. No browser, no files. The audit mode extends it with source-aware sections; the sections below keep
 // their order so the two stay comparable. Page-derived text goes through mdText and mdCode (see text.ts).
-import { hintsOf } from "./hints.js";
+import { groupSrcsetOf, hiddenPagesLine, hiddenVideoSummaryLine, hintsOf, videoRowOf, videoSavingOf, videoTotalsLine } from "./hints.js";
+import { srcsetWidthLabel } from "./candidates.js";
 import { lcpLinesOf } from "./lcp.js";
 import { planQualityCap, qualitiesLine } from "./qualities-cap.js";
 import { hasFix } from "./images.js";
 import { APPROX_MARK, siteNumbers } from "./remote.js";
-import { errorLine, mdCode, mdText } from "./text.js";
+import { errorLine, mdCode, mdText, safeText } from "./text.js";
+import { resourceTotalsLine } from "./resources/report.js";
 /** How many fixes, heavy pages, sharpness images and survey route types the report lists in full. */
 export const REPORT_FIXES = 15;
 export const REPORT_SHARPNESS = 15;
@@ -66,6 +68,7 @@ export function fixGroupsOf(deep, qualities) {
         const pages = [...new Set(group.hints.map((h) => h.page))];
         const saved = group.hints.reduce((sum, h) => sum + h.bytes.saved, 0) / 1024;
         const sizes = group.hints.reduce((sum, h) => sum + (h.bytes.sizes ?? 0), 0) / 1024;
+        const resize = group.hints.reduce((sum, h) => sum + (h.bytes.resize ?? 0), 0) / 1024;
         const sharp = group.hints.reduce((sum, h) => sum + h.bytes.addedForSharpness, 0) / 1024;
         const targets = group.hints.map((h) => h.quality?.target).filter((t) => t !== undefined);
         const quality = group.hints.find((h) => h.quality !== undefined)?.quality;
@@ -82,6 +85,7 @@ export function fixGroupsOf(deep, qualities) {
             current,
             proposed,
             basis: first.sizes.basis,
+            srcset: groupSrcsetOf(group),
             format: best !== undefined && best !== first.format?.current ? best : undefined,
             ...(quality !== undefined
                 ? {
@@ -99,7 +103,8 @@ export function fixGroupsOf(deep, qualities) {
             savedKBSum: saved,
             savedKBPerPage: perPage(saved),
             sizesKBPerPage: perPage(sizes),
-            qualityKBPerPage: perPage(saved - sizes),
+            resizeKBPerPage: perPage(resize),
+            qualityKBPerPage: perPage(saved - sizes - resize),
             sharpnessKBPerPage: perPage(sharp),
         });
     }
@@ -108,7 +113,11 @@ export function fixGroupsOf(deep, qualities) {
 /** The line of one fix: where, the sizes and quality change, the saving per view and its pages. */
 function fixLines(fix, rank) {
     const where = fix.located ? mdCode(fix.where) : `${mdCode(fix.where)} (not located)`;
-    const sizes = fix.current === fix.proposed ? "sizes unchanged" : `sizes ${mdCode(fix.current)} -> ${mdCode(fix.proposed)}${fix.basis ? ` (${mdText(fix.basis)})` : ""}`;
+    const sizes = fix.srcset !== undefined
+        ? `no srcset -> serve ${srcsetWidthLabel(fix.srcset.widths)} + srcset/sizes`
+        : fix.current === fix.proposed
+            ? "sizes unchanged"
+            : `sizes ${mdCode(fix.current)} -> ${mdCode(fix.proposed)}${fix.basis ? ` (${mdText(fix.basis)})` : ""}`;
     const quality = fix.quality === undefined
         ? "quality -"
         : fix.quality.target === undefined
@@ -116,7 +125,8 @@ function fixLines(fix, rank) {
             : fix.quality.void
                 ? `quality ${fix.quality.current} -> ${fix.quality.target} (snapped: void, counted as 0)`
                 : `quality ${fix.quality.current} -> ${fix.quality.target}${fix.quality.snapFrom !== undefined ? ` (snapped from ${fix.quality.snapFrom}${fix.quality.allowed ? `, allowed ${fix.quality.allowed.join(",")}` : ""})` : ""}`;
-    const saving = `saves ${kb(fix.savedKBPerPage)} KB/view per page (sizes ${kb(fix.sizesKBPerPage)} + quality ${kb(fix.qualityKBPerPage)})`;
+    const split = fix.resizeKBPerPage > 0 ? `sizes ${kb(fix.sizesKBPerPage)} + resize ${kb(fix.resizeKBPerPage)} + quality ${kb(fix.qualityKBPerPage)}` : `sizes ${kb(fix.sizesKBPerPage)} + quality ${kb(fix.qualityKBPerPage)}`;
+    const saving = `saves ${kb(fix.savedKBPerPage)} KB/view per page (${split})`;
     const source = fix.pattern !== undefined ? `, src ${mdCode(fix.pattern)}` : "";
     const where2 = `${fix.pages.length} page(s), ${fix.images} image(s), loader ${mdText(fix.loader)}${source}`;
     return [
@@ -153,6 +163,13 @@ export function buildCheckReport(input) {
     const notMeasured = (pages) => pages.length - measured(pages).length - count(pages, "broken") - count(pages, "failed");
     out(`survey ${input.urls.surveyed} page(s): ${survey.length} ok, ${count(input.survey, "broken")} broken, ${count(input.survey, "failed")} failed, ${notMeasured(input.survey)} not measured · deep ${input.deep.length} page(s)${retried > 0 ? ` (${retried} retried)` : ""}: ${deepOk.length} ok, ${count(input.deep, "failed")} failed, ${notMeasured(input.deep)} not measured`);
     out(`time: survey ${input.timings.survey.toFixed(1)} s, deep ${input.timings.deep.toFixed(1)} s, total ${(input.timings.survey + input.timings.deep).toFixed(1)} s`, "");
+    // The media phase's note is printed once, at the top (the same note is on each page that has media).
+    const media = [...input.survey, ...input.deep].find((p) => p.mediaNote !== undefined)?.mediaNote;
+    if (media !== undefined)
+        out(mdText(media), "");
+    const vectorNote = input.deep.find((p) => p.vectorNote !== undefined)?.vectorNote;
+    if (vectorNote !== undefined)
+        out(mdText(vectorNote), "");
     if (input.stop !== undefined) {
         out("## Stopped before the deep phase", "", `${mdText(input.stop.reason)}`, `Fix: ${mdText(input.stop.fix)}`, "");
     }
@@ -170,6 +187,9 @@ export function buildCheckReport(input) {
         const exactEst = mean(deepTotals.map((t) => t.exactEstKB));
         const numbers = siteNumbers(deepOk.map((p) => p.page));
         out(`- Deep (${deepOk.length} page(s), viewports ${input.options.deepViewports.map(mdText).join(", ")}): mean image ${kb(numbers.meanImageBytes / 1024)} KB/view.`, `  - exact: ${kb(exact)} KB/view (${pct(numbers.exactPct)})`, `  - exact + est.: ${APPROX_MARK.trim()} ${kb(exactEst)} KB/view (${pct(numbers.exactEstPct)})${approx ? " (some estimates are approximate)" : ""}`, `  - sharpness: +${kb(mean(deepTotals.map((t) => t.sharpnessKB)))} KB/view, a separate number: it is never netted against the saving`);
+        const hiddenLine = hiddenPagesLine(deepOk);
+        if (hiddenLine !== undefined)
+            out(`  - ${mdText(hiddenLine)}`);
         // The LCP image is the one the first paint waits for: its line, per page, before the ranked fixes.
         for (const page of deepOk) {
             for (const line of lcpLinesOf(page, mdCode))
@@ -192,6 +212,34 @@ export function buildCheckReport(input) {
         out(`Merged across the deep pages: one file:line when located, else one image pattern with the same proposed sizes. Ranked by the total saving over the pages. Top ${Math.min(REPORT_FIXES, fixes.length)} of ${fixes.length}.`, "");
         fixes.slice(0, REPORT_FIXES).forEach((fix, i) => out(...fixLines(fix, i + 1), ""));
     }
+    // 3b. Video: the self-hosted <video> files of the deep pages, per view and per play, largest saveable first.
+    const videos = deepOk.flatMap((p) => (p.videos ?? []).map((video) => ({ page: p.url, video })));
+    if (videos.length > 0) {
+        out("## Video", "");
+        out(`${videoTotalsLine(videos.map((v) => v.video))} (${videos.length} video(s) on ${deepOk.filter((p) => (p.videos ?? []).length > 0).length} deep page(s))`, "");
+        const hiddenVideos = hiddenVideoSummaryLine(videos.map((v) => v.video));
+        if (hiddenVideos !== undefined)
+            out(`- ${mdText(hiddenVideos)}`);
+        const ranked = [...videos].sort((a, b) => videoSavingOf(b.video).view - videoSavingOf(a.video).view || a.page.localeCompare(b.page));
+        for (const row of ranked.slice(0, REPORT_FIXES)) {
+            out(`- ${mdCode(videoRowOf(row.video, (text) => JSON.stringify(safeText(text))))} on ${mdCode(pathOf(row.page))}`);
+        }
+        out("");
+    }
+    // 3c. Resources: the deep pages' non-image findings (compression, favicons), largest saving first (see resources/).
+    const resourceRows = deepOk.flatMap((p) => (p.resources ?? []).map((finding) => ({ page: p.url, finding })));
+    if (resourceRows.length > 0) {
+        out("## Resources", "");
+        out(mdText(resourceTotalsLine(resourceRows.map((r) => r.finding)) ?? ""), "");
+        const ranked = [...resourceRows].sort((a, b) => b.finding.savedBytes - a.finding.savedBytes || a.page.localeCompare(b.page));
+        for (const row of ranked.slice(0, REPORT_FIXES)) {
+            const saved = row.finding.savedBytes > 0 ? `, saves ${kb(row.finding.savedBytes / 1024)} KB/view${row.finding.estimate ? " (est.)" : ""}` : "";
+            out(`- ${mdText(row.finding.kind)}: ${mdText(row.finding.title)}${saved} on ${mdCode(pathOf(row.page))}`);
+            if (row.finding.fix[0] !== undefined)
+                out(`  - fix: ${mdText(row.finding.fix[0])}`);
+        }
+        out("");
+    }
     // 4. Heavy but not wasteful.
     out("## Heavy but not wasteful", "");
     const heavyCut = percentile(deepTotals.map((t) => t.kb), 0.75);
@@ -280,6 +328,8 @@ export function buildCheckReport(input) {
         ? `- Route types group URLs by template (locale and device variant stripped), as check does; the route file column names the file(s) each type renders from. Only the heaviest page of each type is deep-scanned; ${input.selection.leftOut.length} type(s) were not (see the table).`
         : `- Route types group URLs by template (locale and device variant stripped). Only the heaviest page of each type is deep-scanned; ${input.selection.leftOut.length} type(s) were not (see the table).`, input.options.qualities !== undefined
         ? `- Quality targets are snapped up to the allowed qualities ${input.options.qualities.join(", ")}; a snapped target's quality saving is void and counts as 0.${input.qualitiesNote !== undefined ? ` (${mdText(input.qualitiesNote)})` : ""}`
-        : "- Quality targets are not snapped (no --qualities given): a target the framework cannot serve is not the saving it looks like.", `- Third-party requests: ${input.options.thirdParty}${input.options.allowHosts ? ` (hosts kept: ${input.options.allowHosts.map(mdText).join(", ")})` : ""}. Blocking can drop images a page loads through its own API on another host.`, `- Pages with images still loading at settle show the images that loaded; the rest are not measured.`, input.options.gpu !== undefined ? `- Quality was scored on the GPU ${input.options.gpu} (with the CPU fallback noted in the page JSON).` : "- Quality was scored on the CPU.", "");
+        : "- Quality targets are not snapped (no --qualities given): a target the framework cannot serve is not the saving it looks like.", `- Third-party requests: ${input.options.thirdParty}${input.options.allowHosts ? ` (hosts kept: ${input.options.allowHosts.map(mdText).join(", ")})` : ""}. Blocking can drop images a page loads through its own API on another host.`, `- Pages with images still loading at settle show the images that loaded; the rest are not measured.`, ...(videos.length > 0
+        ? [`- Video bytes: per view as the page loads them (autoplay: the whole file). The saveable bytes come from 2 s sample encodes: est.`]
+        : []), input.options.gpu !== undefined ? `- Quality was scored on the GPU ${input.options.gpu} (with the CPU fallback noted in the page JSON).` : "- Quality was scored on the CPU.", "");
     return `${lines.join("\n")}\n`;
 }

package/dist/check.js

@@ -7,11 +7,11 @@ import { mkdir, readFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { DEFAULT_VIEWPORTS } from "./config.js";
 import { writeFileAtomic } from "./atomic.js";
-import { parseGpuDevice } from "./gpu.js";
+import { gpuSettingOf, gpuSettingOne } from "./gpu.js";
 import { parseQualities } from "./hints.js";
 import { BROKEN_EXIT, surveyStop } from "./broken.js";
 import { DEFAULT_THIRD_PARTY, parseAllowHosts, thirdPartyFromFlags } from "./third-party.js";
-import { MAX_IDLE_TIMEOUT_MS, MAX_PAGE_CONCURRENCY, parseLimit, parseRange, readStorageState, runScan, scanPlan, } from "./remote.js";
+import { MAX_IDLE_TIMEOUT_MS, MAX_PAGE_CONCURRENCY, MAX_RESOURCE_TIME, MAX_SVG_BUDGET, parseLimit, parseRange, readStorageState, runScan, scanPlan, } from "./remote.js";
 import { restrictRoutes, groupRoutes, parseRouteMap } from "./routes.js";
 import { sampleByPattern, urlsFromSource } from "./urls.js";
 import { deepRetries, selectDeepPages } from "./deep.js";
@@ -36,6 +36,10 @@ export function parseCheckFlags(argv) {
         const arg = argv[i];
         if (arg === "--no-cache")
             args.noCache = true;
+        else if (arg === "--gpu-encode")
+            args.gpuEncode = true;
+        else if (arg === "--no-resources")
+            args.noResources = true;
         else if (arg === "--ignore-robots")
             args.ignoreRobots = true;
         else if (arg === "--block-third-party")
@@ -44,9 +48,9 @@ export function parseCheckFlags(argv) {
         else if (arg === "--allow-third-party")
             continue;
         else if (arg === "--gpu")
-            args.gpu ??= { device: 0 };
+            args.gpu ??= gpuSettingOne(0);
         else if (arg === "--gpu-device") {
-            args.gpu = { device: parseGpuDevice(valueOf(argv, i, arg)) };
+            args.gpu = gpuSettingOf(valueOf(argv, i, arg));
             i++;
         }
         else if (arg === "--urls-from" ||
@@ -57,6 +61,8 @@ export function parseCheckFlags(argv) {
             arg === "--page-concurrency" ||
             arg === "--qualities" ||
             arg === "--idle-timeout" ||
+            arg === "--svg-budget" ||
+            arg === "--resource-time" ||
             arg === "--storage-state" ||
             arg === "--allow-host") {
             const value = valueOf(argv, i, arg);
@@ -77,6 +83,10 @@ export function parseCheckFlags(argv) {
                 args.qualities = parseQualities(value);
             else if (arg === "--idle-timeout")
                 args.idleTimeoutMs = parseRange(arg, value, 0, MAX_IDLE_TIMEOUT_MS);
+            else if (arg === "--svg-budget")
+                args.svgBudget = parseRange(arg, value, 0, MAX_SVG_BUDGET);
+            else if (arg === "--resource-time")
+                args.resourceTime = parseRange(arg, value, 0, MAX_RESOURCE_TIME);
             else if (arg === "--storage-state")
                 args.storageState = value;
             else
@@ -182,6 +192,7 @@ export async function scanCheckPages(input) {
         ignoreRobots: settings.ignoreRobots,
         aggressive: false,
         thirdParty: settings.thirdParty,
+        resources: settings.noResources !== true,
     };
     const base = { urls: [], out: outRoot, aggressive: false, quality: true, thirdParty: settings.thirdParty };
     const surveyPlan = scanPlan({ ...base, survey: true });
@@ -203,6 +214,9 @@ export async function scanCheckPages(input) {
             shellWord(surveyDir),
             ...(settings.thirdParty.block ? ["--block-third-party"] : []),
             ...(settings.noCache ? ["--no-cache"] : []),
+            ...(settings.gpuEncode ? ["--gpu-encode"] : []),
+            ...(settings.noResources ? ["--no-resources"] : []),
+            ...(settings.resourceTime !== undefined ? ["--resource-time", String(settings.resourceTime)] : []),
         ].join(" "),
     });
     log(`survey: ${urls.length} URL(s), ${routes.types.length} route type(s)`);
@@ -236,13 +250,17 @@ export async function scanCheckPages(input) {
             if (page.status === "ok")
                 expected.set(page.url, page.counts.images);
         const flags = [
-            ...(settings.gpu !== undefined ? ["--gpu-device", String(settings.gpu.device)] : []),
+            ...(settings.gpu !== undefined ? ["--gpu-device", settings.gpu.devices.join(",")] : []),
             ...(settings.thirdParty.block ? ["--block-third-party"] : []),
             ...(settings.thirdParty.allowHosts.length > 0 ? ["--allow-host", shellWord(settings.thirdParty.allowHosts.join(","))] : []),
             ...(settings.noCache ? ["--no-cache"] : []),
+            ...(settings.gpuEncode ? ["--gpu-encode"] : []),
+            ...(settings.noResources ? ["--no-resources"] : []),
+            ...(settings.resourceTime !== undefined ? ["--resource-time", String(settings.resourceTime)] : []),
             ...(settings.ignoreRobots ? ["--ignore-robots"] : []),
             ...(settings.pageConcurrency !== undefined ? ["--page-concurrency", String(settings.pageConcurrency)] : []),
             ...(settings.idleTimeoutMs !== undefined ? ["--idle-timeout", String(settings.idleTimeoutMs)] : []),
+            ...(settings.svgBudget !== undefined ? ["--svg-budget", String(settings.svgBudget)] : []),
         ];
         commands.push({ phase: "deep", command: ["imgtune scan", ...deepUrls.map(shellWord), "--out", shellWord(deepDir), ...flags].join(" ") });
         log(`deep: ${deepUrls.length} page(s), full scan`);
@@ -254,6 +272,7 @@ export async function scanCheckPages(input) {
             pageConcurrency: fullPlan.pageConcurrency,
             idleTimeoutMs: fullPlan.idleTimeoutMs,
             gpu: settings.gpu,
+            svgBudget: settings.svgBudget,
             expectImages: (url) => expected.get(url),
         };
         const deepStart = performance.now();
@@ -342,6 +361,8 @@ export async function finishCheck(input) {
             pageConcurrency: settings.pageConcurrency,
             idleTimeoutMs: settings.idleTimeoutMs,
             noCache: settings.noCache,
+            ...(settings.noResources ? { noResources: true } : {}),
+            ...(settings.resourceTime !== undefined ? { resourceTime: settings.resourceTime } : {}),
             ignoreRobots: settings.ignoreRobots,
             storageState: input.storageState,
             thirdParty: settings.thirdParty.block ? "blocked" : "allowed",

package/dist/cli.js

@@ -21,6 +21,12 @@ const progress = (message) => {
 const OPTION_HELP = {
     out: ["--out <dir>", "directory for the JSON files (default: .imgtune/scan)"],
     noCache: ["--no-cache", "do not read or write the result cache in .imgtune/cache (the numbers are computed again)"],
+    noResources: ["--no-resources", "skip the resource phase: no capture of the non-image responses, so none of the resource findings (compression, favicons, fonts, SVG, Lottie, 3D, audio)"],
+    resourceTime: ["--resource-time <s>", "time limit of the heavy resource work (3D, fonts, SVG, audio, lottie re-encodes), in seconds, 0 to 3600 (default 60); items over it are reported as not measured"],
+    gpuEncode: [
+        "--gpu-encode",
+        "EXPERIMENTAL: encode the videos and animated images on the GPU (NVENC, CUDA VMAF); off by default (CPU encodes). Bytes are scaled to a CPU encode (÷1.4)",
+    ],
     root: [
         "--root <dir>",
         "folder project source files are read from (default: the nearest folder above the cwd that holds the file, else the nearest with a package.json or .git)",
@@ -58,6 +64,18 @@ const OPTION_HELP = {
     resume: ["--resume", "reuse the complete pages already in --out that were scanned with the same options"],
     maxPages: ["--max-pages <N>", "stop after N pages (scanned or resumed); run again with --resume to continue"],
     maxImages: ["--max-images <N>", "stop after the page that brings the images counted to N (checked between pages)"],
+    mediaBudget: [
+        "--media-budget <N>",
+        "sample-encode at most N animated images and videos per run, heaviest first, 0 to 1000 (default 20); the rest keep their cheap hints",
+    ],
+    svgBudget: [
+        "--svg-budget <N>",
+        "trace at most N flat images (logos, icons, flat illustrations) to SVG and check them, heaviest first, 0 to 1000 (default 50; 0 traces none)",
+    ],
+    mediaTime: ["--media-time <s>", "time limit of the media encodes, in seconds, 1 to 3600 (default 600)"],
+    videoBar: ["--video-bar <n>", "minimum VMAF of a video or animated encode, 0 to 100 (default 93)"],
+    videoStillBar: ["--video-still-bar <n>", "minimum SSIMULACRA2 of the still-frame guard, 0 to 100 (default 65)"],
+    maxVideoWidths: ["--max-video-widths <n>", "the most widths each video is served at, 1 to 3 (default 2)"],
     maxQualities: [
         "--max-qualities <N>",
         "the most values next.config's images.qualities may list, 1 to 4 (default 2): next/image qualities are clustered, each mapped up",
@@ -95,7 +113,10 @@ const OPTION_HELP = {
         "--gpu",
         "score with the GPU scorer (imgtune-ssimu2-gpu, see the docs); opt-in. Falls back to the CPU with a warning",
     ],
-    gpuDevice: ["--gpu-device <n>", "the GPU to score on, by CUDA index (implies --gpu; default 0; see the GPU notes)"],
+    gpuDevice: [
+        "--gpu-device <n[,n]>",
+        "the GPU to score on, by CUDA index (implies --gpu; default 0; see the GPU notes). A comma list (0,1) gives each GPU its own encode workers with --gpu-encode; the first scores",
+    ],
     locateOnly: [
         "--locate-only",
         "read the source of the flagged images from a dev page (React owner data) or a built page with source maps (prod-sourcemap); not a measurement (needs --from)",
@@ -134,6 +155,9 @@ const SCAN_HELP = commandHelp("imgtune scan <url> [<url> ...] [options]", [
     "out",
     "root",
     "noCache",
+    "noResources",
+    "resourceTime",
+    "gpuEncode",
     "aggressive",
     "viewports",
     "survey",
@@ -146,6 +170,12 @@ const SCAN_HELP = commandHelp("imgtune scan <url> [<url> ...] [options]", [
     "resume",
     "maxPages",
     "maxImages",
+    "mediaBudget",
+    "svgBudget",
+    "mediaTime",
+    "videoBar",
+    "videoStillBar",
+    "maxVideoWidths",
     "maxQualities",
     "pageConcurrency",
     "idleTimeout",
@@ -187,11 +217,15 @@ Options:
   --out <dir>                     the check directory (default ${DEFAULT_CHECK_DIR}/<timestamp>)
   --qualities <list>              the framework's allowed qualities, e.g. 75,85,100: targets are snapped up to them
   --gpu, --gpu-device <n>         score the deep pages with the GPU scorer (see the GPU notes; not the survey)
+  --gpu-encode                    EXPERIMENTAL: encode the deep pages' videos and animated images on the GPU (see scan --help)
   --page-concurrency <N>          pages at once in the deep phase (default 1)
   --idle-timeout <ms>             cap on the network-idle wait in the deep phase (default 10000)
+  --svg-budget <N>                trace at most N flat images of the deep pages to SVG (default 50; 0 traces none)
   --block-third-party             abort the requests to other sites (off by default; can drop images a page loads from its API)
   --allow-host <h1,h2>            with --block-third-party: keep the requests to these hosts
   --no-cache                      do not read or write the result cache
+  --no-resources                  skip the resource phase (compression, favicons, fonts, SVG, Lottie, 3D and audio findings; no capture of the other responses)
+  --resource-time <s>             time limit of the heavy resource work (3D, fonts, SVG, audio, Lottie re-encodes), in seconds, 0 to 3600 (default 60)
   --ignore-robots                 scan pages robots.txt disallows (owned or authorised sites only)
   --storage-state <file>          a logged-in session (holds cookies: never commit it)
   -h, --help                      show this help
@@ -222,11 +256,15 @@ Options:
   --qualities <list>              the allowed qualities (default: images.qualities of next.config, else Next's [75])
   --out <dir>                     the audit directory (default ${DEFAULT_AUDIT_DIR}/<timestamp>)
   --gpu, --gpu-device <n>         score the deep pages with the GPU scorer (see the GPU notes; not the survey)
+  --gpu-encode                    EXPERIMENTAL: encode the deep pages' videos and animated images on the GPU (see scan --help)
   --page-concurrency <N>          pages at once in the deep phase (default 1)
   --idle-timeout <ms>             cap on the network-idle wait in the deep phase (default 10000)
+  --svg-budget <N>                trace at most N flat images of the deep pages to SVG (default 50; 0 traces none)
   --block-third-party             abort the requests to other sites (off by default; can drop images a page loads from its API)
   --allow-host <h1,h2>            with --block-third-party: keep the requests to these hosts
   --no-cache                      do not read or write the result cache
+  --no-resources                  skip the resource phase (compression, favicons, fonts, SVG, Lottie, 3D and audio findings; no capture of the other responses)
+  --resource-time <s>             time limit of the heavy resource work (3D, fonts, SVG, audio, Lottie re-encodes), in seconds, 0 to 3600 (default 60)
   --ignore-robots                 scan pages robots.txt disallows (owned or authorised sites only)
   --storage-state <file>          a logged-in session (holds cookies: never commit it)
   -h, --help                      show this help
@@ -252,9 +290,13 @@ Options:
   --dev <origin>                  locate the deep pages at the same paths on this dev server (a running dev server)
   --qualities <list>              the framework's allowed qualities, e.g. 75,85,100 (passed to hints)
   --gpu, --gpu-device <n>         score the deep pages with the GPU scorer (see the GPU notes; not the survey)
+  --gpu-encode                    EXPERIMENTAL: encode the deep pages' videos and animated images on the GPU (see scan --help)
   --page-concurrency <N>          pages at once in the survey (default 4) and in the deep phase (default 1)
   --idle-timeout <ms>             cap on the network-idle wait (default 3000 in the survey, 10000 in the deep phase)
+  --svg-budget <N>                trace at most N flat images of the deep pages to SVG (default 50; 0 traces none)
   --no-cache                      do not read or write the result cache
+  --no-resources                  skip the resource phase (compression, favicons, fonts, SVG, Lottie, 3D and audio findings; no capture of the other responses)
+  --resource-time <s>             time limit of the heavy resource work (3D, fonts, SVG, audio, Lottie re-encodes), in seconds, 0 to 3600 (default 60)
   --root <dir>                    the source folder for --dev (a monorepo sub-folder)
   --storage-state <file>          a logged-in session (holds cookies: never commit it)
   --ignore-robots                 scan pages robots.txt disallows (owned or authorised sites only)
@@ -298,17 +340,29 @@ against the file itself: 90 (visually lossless) unless --min-score sets another.
 --write names a folder for optimised copies (existing names are never overwritten).
 Evidence is "file-mode". Globs: ** walks folders (node_modules and dot folders are skipped).
 
+Media: an animated GIF, animated WebP or APNG gets the candidates of animated AVIF, animated WebP and AV1 MP4 at --width
+(the file's own width by default), each the lowest-bytes quality that meets the video bars. A video (MP4, MOV, WebM) is
+described; with --reference <original> a candidate is checked against the original: VMAF and the still-frame guard, one
+verdict line "VMAF <v> (bar <b>) still p10 <s> (bar <sb>): pass|fail", exit 0 on pass and 1 on fail. Media is local files
+only. The encodes need ffmpeg on PATH; without it the sizes are still measured.
+
 Options:
-  --width <css px>      the CSS width the image is shown at (the width is then the user's, not the file's)
+  --width <css px>      the CSS width the image is shown at (the width is then the user's, not the file's); for media, the width
+                        compared or searched at (the candidate's own width with --reference)
   --dpr <list>          device pixel ratios for --width (default 1,2)
   --formats <list>      avif, webp, jpeg (default all three)
   --min-score <n>       the SSIMULACRA2 bar, above 0 and at most 100 (default 90)
   --write <dir>         write optimised copies (best format, at the largest needed width) into this folder
-  --format <text|json>  text (default) or JSON
+  --reference <file>    compare one media candidate with this original (local file): the verdict line and the exit code
+  --video-bar <n>       the minimum VMAF of a media encode or check, 0 to 100 (default 93)
+  --video-still-bar <n> the still-frame guard's bar, 0 to 100 (default 65), lowered for a source whose own best encode scores low
+  --format <text|json>  text (default) or JSON (--json is the same)
   --gpu                 score with the GPU scorer (opt-in; falls back to the CPU with a warning)
-  --gpu-device <n>      the GPU to score on, by CUDA index (implies --gpu; default 0). CUDA numbers the GPUs fastest first
+  --gpu-device <n>      the GPU to score on, by CUDA index (implies --gpu; default 0). A comma list is accepted: the first GPU
+                        scores. CUDA numbers the GPUs fastest first
                         unless CUDA_DEVICE_ORDER=PCI_BUS_ID; with CUDA_VISIBLE_DEVICES set, n indexes the devices it lists.
                         The scorer prints the name of the GPU it opened: check it.
+  --gpu-encode          EXPERIMENTAL: encode the videos and animated images on the GPU (NVENC, CUDA VMAF), off by default
   --no-cache            do not read or write the result cache in .imgtune/cache
   -h, --help            show this help
 `;
@@ -338,6 +392,8 @@ Options:
 `;
 const USAGE = `Usage: imgtune <command> [options]
 
+imgtune measures page weight on live pages (images, video, hidden downloads, fonts, compression, 3D, audio, Lottie, SVG) and prints the fix for each.
+
 Commands:
   scan      measure live pages by URL, with no source, config or dev server (writes JSON to --out)
   hints     print a batch of the per-image fix hints of a scan file
@@ -355,6 +411,28 @@ Options:
   --version           print the version
   -h, --help          show this help
 `;
+/** Shell exit codes of a run stopped by a signal: 128 + the signal number. */
+const SIGNAL_EXIT = { SIGINT: 130, SIGTERM: 143 };
+/** The most a first signal waits for the run to clean up (media scratch, ffmpeg children) before the process exits. */
+const CLEANUP_MS = 2000;
+/** Aborted on the first SIGINT or SIGTERM: the media phase and the image command stop, ffmpeg children are killed and their
+ * scratch folders removed (the abort is seen in their `finally` blocks). The process then exits within CLEANUP_MS with the
+ * signal's exit code, so a Ctrl-C or a supervisor's SIGTERM always ends the run. A second signal exits at once.
+ */
+const interrupt = new AbortController();
+let interrupts = 0;
+/** The first signal received, which sets the exit code of an interrupted run. */
+let received;
+for (const signal of ["SIGINT", "SIGTERM"]) {
+    process.on(signal, () => {
+        interrupts++;
+        received ??= signal;
+        if (interrupts > 1)
+            process.exit(SIGNAL_EXIT[signal]);
+        interrupt.abort();
+        setTimeout(() => process.exit(SIGNAL_EXIT[signal]), CLEANUP_MS);
+    });
+}
 async function main() {
     const argv = process.argv.slice(2);
     if (argv.includes("--version")) {
@@ -415,9 +493,9 @@ async function main() {
         return;
     }
     if (argv[0] === "image") {
-        const outcome = await imageCommand(argv.slice(1), process.cwd());
+        const outcome = await imageCommand(argv.slice(1), process.cwd(), undefined, undefined, interrupt.signal);
         process.stdout.write(outcome.output);
-        process.exitCode = outcome.exitCode;
+        process.exitCode = received !== undefined ? SIGNAL_EXIT[received] : outcome.exitCode;
         return;
     }
     if (argv[0] === "hints") {
@@ -455,9 +533,9 @@ async function main() {
         process.exitCode = 2;
         return;
     }
-    const outcome = await scanCommand(argv.slice(1), process.cwd(), progress);
+    const outcome = await scanCommand(argv.slice(1), process.cwd(), progress, interrupt.signal);
     process.stdout.write(outcome.output);
-    process.exitCode = outcome.exitCode;
+    process.exitCode = received !== undefined ? SIGNAL_EXIT[received] : outcome.exitCode;
 }
 main().catch((err) => {
     if (err instanceof ChromiumMissingError) {

package/dist/egress-proxy.js

@@ -38,8 +38,9 @@ function connectionFor(hostname, policy, onRefused) {
     const checked = guardedLookup(policy.resolver, policy.allowPrivate, policy.connectAddress);
     const lookup = ((name, options, callback) => {
         checked(name, options, (err, ...rest) => {
+            // The name a lookup could not resolve: the page may still load it in a browser (see the scan's unresolved hosts).
             if (err)
-                onRefused();
+                onRefused(name);
             callback(err, ...rest);
         });
     });

package/dist/fetch.js

@@ -75,7 +75,7 @@ export function makeFetcher(opts) {
         }
     };
     /** Each hop is checked at connect time (guardedLookup); redirects are followed here, not by the client. */
-    const fetchChecked = async (start, maxBytes, allowPrivate, sameSiteAs, sameOriginAs) => {
+    const fetchChecked = async (start, maxBytes, allowPrivate, sameSiteAs, sameOriginAs, allowHop) => {
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), EXTRA_FETCH_TIMEOUT_MS);
         try {
@@ -99,7 +99,11 @@ export function makeFetcher(opts) {
                     res.resume();
                     if (hop >= MAX_REDIRECTS)
                         return undefined;
-                    current = new URL(location, url).toString();
+                    const next = new URL(location, url).toString();
+                    // A hop the policy refuses is not requested: the fetch ends here, as a failed one does.
+                    if (allowHop !== undefined && !allowHop(next))
+                        return undefined;
+                    current = next;
                     continue;
                 }
                 if (status < 200 || status >= 300) {
@@ -137,14 +141,15 @@ export function makeFetcher(opts) {
         const maxBytes = fetchOpts.maxBytes ?? MAX_IMAGE_BYTES;
         const allowPrivate = fetchOpts.allowPrivate ?? false;
         // The request headers are part of the key: a response can depend on them (the user agent and Accept are fixed per run).
-        const key = JSON.stringify([url, maxBytes, allowPrivate, fetchOpts.sameSiteAs ?? "", fetchOpts.sameOriginAs ?? "", opts.userAgent, IMAGE_ACCEPT]);
+        const hopKey = fetchOpts.allowHop === undefined ? "" : `hop:${fetchOpts.allowHopKey ?? ""}`;
+        const key = JSON.stringify([url, maxBytes, allowPrivate, fetchOpts.sameSiteAs ?? "", fetchOpts.sameOriginAs ?? "", opts.userAgent, IMAGE_ACCEPT, hopKey]);
         const known = memo.get(key);
         if (known) {
             count("fetch memo hits");
             return known;
         }
         count("fetch requests");
-        const fetched = measure("fetch: network", () => withSlot(() => fetchChecked(url, maxBytes, allowPrivate, fetchOpts.sameSiteAs, fetchOpts.sameOriginAs))).catch(() => undefined);
+        const fetched = measure("fetch: network", () => withSlot(() => fetchChecked(url, maxBytes, allowPrivate, fetchOpts.sameSiteAs, fetchOpts.sameOriginAs, fetchOpts.allowHop))).catch(() => undefined);
         const pending = fetched.then((answer) => {
             // Settled: a failure or a no-store body is not kept for the next page (its callers above already have it).
             if (answer === undefined || answer.noStore) {