getobsrv 0.3.0

package/out/main/cli.js

@@ -0,0 +1,600 @@
+"use strict";
+const electron = require("electron");
+const node_fs = require("node:fs");
+const node_os = require("node:os");
+const node_path = require("node:path");
+const targetSource = require("./targetSource-w_vWw7zd.js");
+function boxDownsample(src, factor) {
+  if (!Number.isInteger(factor) || factor < 1) throw new RangeError("factor must be an integer >= 1");
+  const width = Math.floor(src.width / factor);
+  const height = Math.floor(src.height / factor);
+  const data = new Uint8ClampedArray(width * height * 4);
+  const n = factor * factor;
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      let r = 0, g = 0, b = 0, a = 0;
+      for (let dy = 0; dy < factor; dy++) {
+        let i = ((y * factor + dy) * src.width + x * factor) * 4;
+        for (let dx = 0; dx < factor; dx++, i += 4) {
+          r += src.data[i];
+          g += src.data[i + 1];
+          b += src.data[i + 2];
+          a += src.data[i + 3];
+        }
+      }
+      const o = (y * width + x) * 4;
+      data[o] = Math.round(r / n);
+      data[o + 1] = Math.round(g / n);
+      data[o + 2] = Math.round(b / n);
+      data[o + 3] = Math.round(a / n);
+    }
+  }
+  return { width, height, data };
+}
+function rgbaToBgra(src) {
+  const out = new Uint8Array(src.data.length);
+  for (let i = 0; i < src.data.length; i += 4) {
+    out[i] = src.data[i + 2];
+    out[i + 1] = src.data[i + 1];
+    out[i + 2] = src.data[i];
+    out[i + 3] = 255;
+  }
+  return out;
+}
+class ArgError extends Error {
+}
+const DEFAULT_PRESET = "1080p-24";
+const DEFAULT_TIMEOUT_MS = 3e4;
+function usage() {
+  const presets = targetSource.SCREEN_PRESETS.map((p) => `      ${p.id.padEnd(14)} ${p.label}`).join("\n");
+  const profiles = targetSource.PANEL_PROFILES.map((p) => p.id).join(" | ");
+  return `obsrv — see your site the way 1x screens see it (headless CLI)
+
+Usage:
+  obsrv snap <url> [flags]   Render <url> on a target screen; write a PNG, print JSON.
+  obsrv diff <url> [flags]   Render <url> at 1x and against a 2x reference; print JSON metrics.
+
+Shared flags:
+  --preset <id>        Screen preset (default ${DEFAULT_PRESET}):
+${presets}
+  --width <px> --height <px> [--dsf <factor>] [--diagonal <inches>]
+                       Custom CSS viewport instead of --preset (dsf defaults to 1).
+  --profile <id>       Panel profile: ${profiles} (default reference).
+  --wait <ms>          Extra settle time after load (default 0).
+  --timeout <ms>       Per-render budget for load + paint quiescence (default ${DEFAULT_TIMEOUT_MS}).
+
+snap flags:
+  --out <file>         Output PNG (default ./obsrv-<preset>.png). Under --matrix: an
+                       output directory, or a pattern containing {preset}.
+  --full-page          Capture the full page height (device pixels capped at 4096).
+  --matrix <id,id,…>   Render each listed preset in one run.
+
+diff flags:
+  --out-dir <dir>      Also write target.png and reference.png.
+  --json               JSON metrics to stdout (already the default; accepted for clarity).
+
+Repeated flags: the last occurrence wins.
+Machine output (JSON) goes to stdout; everything human goes to stderr.
+Exit code 0 on success — diff findings are informational, never a failure.`;
+}
+const BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["full-page", "json"]);
+const VALUE_FLAGS = /* @__PURE__ */ new Set(["preset", "profile", "out", "out-dir", "wait", "timeout", "matrix", "width", "height", "dsf", "diagonal"]);
+const SNAP_ONLY = /* @__PURE__ */ new Set(["out", "full-page", "matrix"]);
+const DIFF_ONLY = /* @__PURE__ */ new Set(["out-dir", "json"]);
+function collect(command, argv) {
+  let url = null;
+  const flags = /* @__PURE__ */ new Map();
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (token.startsWith("--")) {
+      const name = token.slice(2);
+      if (BOOLEAN_FLAGS.has(name)) {
+        flags.set(name, true);
+      } else if (VALUE_FLAGS.has(name)) {
+        const value = argv[++i];
+        if (value === void 0 || value.startsWith("--")) throw new ArgError(`--${name} requires a value`);
+        flags.set(name, value);
+      } else {
+        throw new ArgError(`unknown flag: --${name}
+
+${usage()}`);
+      }
+    } else if (url === null) {
+      url = token;
+    } else {
+      throw new ArgError(`unexpected argument: ${token}`);
+    }
+  }
+  if (url === null) throw new ArgError(`usage: obsrv ${command} <url> [flags] — run \`obsrv --help\` for the flag list`);
+  const wrongCommand = command === "snap" ? DIFF_ONLY : SNAP_ONLY;
+  for (const name of flags.keys()) {
+    if (wrongCommand.has(name)) {
+      throw new ArgError(`--${name} is a ${command === "snap" ? "diff" : "snap"} flag; \`obsrv ${command}\` does not take it`);
+    }
+  }
+  return { url, flags };
+}
+function integer(flags, name, fallback, min) {
+  const raw = flags.get(name);
+  if (raw === void 0) return fallback;
+  const n = Number(raw);
+  if (!Number.isFinite(n)) throw new ArgError(`--${name}: expected a number, got "${String(raw)}"`);
+  if (!Number.isInteger(n)) throw new ArgError(`--${name}: expected an integer, got "${String(raw)}"`);
+  if (n < min) throw new ArgError(`--${name}: must be >= ${min}`);
+  return n;
+}
+function float(flags, name, fallback, min) {
+  const raw = flags.get(name);
+  if (raw === void 0) return fallback;
+  const n = Number(raw);
+  if (!Number.isFinite(n) || n < min) throw new ArgError(`--${name}: expected a number >= ${min}, got "${String(raw)}"`);
+  return n;
+}
+function presetSpec(id) {
+  let preset;
+  try {
+    preset = targetSource.findPreset(id);
+  } catch {
+    throw new ArgError(`unknown preset: ${id} (valid: ${targetSource.SCREEN_PRESETS.map((p) => p.id).join(", ")})`);
+  }
+  return {
+    presetId: preset.id,
+    cssWidth: preset.width,
+    cssHeight: preset.height,
+    deviceScaleFactor: preset.deviceScaleFactor,
+    diagonalInches: preset.diagonalInches
+  };
+}
+function resolveSpecs(flags) {
+  const custom = ["width", "height", "dsf", "diagonal"].some((f) => flags.has(f));
+  if (custom && flags.has("preset")) throw new ArgError("--preset and --width/--height are mutually exclusive");
+  if (custom && flags.has("matrix")) throw new ArgError("--matrix lists presets; it cannot be combined with custom --width/--height dims");
+  if (flags.has("matrix") && flags.has("preset")) throw new ArgError("--matrix already lists presets; drop --preset");
+  if (custom) {
+    if (!flags.has("width") || !flags.has("height")) {
+      throw new ArgError("custom dims need both --width and --height (with optional --dsf and --diagonal)");
+    }
+    const cssWidth = integer(flags, "width", 0, 1);
+    const cssHeight = integer(flags, "height", 0, 1);
+    const deviceScaleFactor = float(flags, "dsf", 1, 1);
+    const max = targetSource.maxCssViewport(deviceScaleFactor);
+    if (cssWidth > max || cssHeight > max) {
+      throw new ArgError(`viewport exceeds the 4096-device-pixel budget: at dsf ${deviceScaleFactor} the CSS limit is ${max}`);
+    }
+    const diagonal = flags.has("diagonal") ? float(flags, "diagonal", 0, 0.1) : null;
+    return { specs: [{ presetId: "custom", cssWidth, cssHeight, deviceScaleFactor, diagonalInches: diagonal }], matrix: false };
+  }
+  const matrixRaw = flags.get("matrix");
+  if (typeof matrixRaw === "string") {
+    const ids = matrixRaw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+    if (ids.length === 0) throw new ArgError("--matrix: expected a comma-separated list of preset ids");
+    return { specs: ids.map(presetSpec), matrix: true };
+  }
+  const id = typeof flags.get("preset") === "string" ? flags.get("preset") : DEFAULT_PRESET;
+  return { specs: [presetSpec(id)], matrix: false };
+}
+function resolveProfile(flags) {
+  const raw = flags.get("profile");
+  if (raw === void 0) return "reference";
+  try {
+    return targetSource.findProfile(raw).id;
+  } catch {
+    throw new ArgError(`unknown profile: ${String(raw)} (valid: ${targetSource.PANEL_PROFILES.map((p) => p.id).join(", ")})`);
+  }
+}
+function parseArgs(argv) {
+  const [command, ...rest] = argv;
+  if (command === void 0 || command === "help" || command === "--help" || command === "-h") {
+    return { command: "help", text: usage() };
+  }
+  if (command !== "snap" && command !== "diff") {
+    throw new ArgError(`unknown command: ${command}
+
+${usage()}`);
+  }
+  const { url, flags } = collect(command, rest);
+  const { specs, matrix } = resolveSpecs(flags);
+  const profileId = resolveProfile(flags);
+  const waitMs = integer(flags, "wait", 0, 0);
+  const timeoutMs = integer(flags, "timeout", DEFAULT_TIMEOUT_MS, 1);
+  if (command === "snap") {
+    const out = typeof flags.get("out") === "string" ? flags.get("out") : matrix ? "." : `obsrv-${specs[0].presetId}.png`;
+    return { command, url, specs, profileId, out, matrix, fullPage: flags.has("full-page"), waitMs, timeoutMs };
+  }
+  const spec = specs[0];
+  if (spec.deviceScaleFactor !== 1) {
+    throw new ArgError(
+      `diff compares the target against a 2x reference downsampled onto the target's 1x grid, so it only supports 1x targets in v1 — "${spec.presetId}" renders at ${spec.deviceScaleFactor}x. Use a 1x preset (e.g. laptop-768, 1080p-24) or plain \`obsrv snap\` for dense presets.`
+    );
+  }
+  const referenceMax = targetSource.maxCssViewport(2);
+  if (spec.cssWidth > referenceMax || spec.cssHeight > referenceMax) {
+    throw new ArgError(
+      `diff renders a 2x reference, so the CSS viewport must fit ${referenceMax}px per axis (4096 device px at 2x) — "${spec.presetId}" is ${spec.cssWidth}×${spec.cssHeight}. Use \`obsrv snap\` for this preset instead.`
+    );
+  }
+  const outDir = typeof flags.get("out-dir") === "string" ? flags.get("out-dir") : null;
+  return { command, url, spec, profileId, outDir, waitMs, timeoutMs };
+}
+const sleep$1 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const DEFAULT_SETTLE_MS = 400;
+async function captureQuiescent(source, options = {}) {
+  const settleMs = options.settleMs ?? DEFAULT_SETTLE_MS;
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  let width = 0;
+  let height = 0;
+  let buffer = new Uint8Array(0);
+  let covered = false;
+  let mask = null;
+  let uncovered = 0;
+  let lastPaint = Date.now();
+  const onFrame = (m) => {
+    lastPaint = Date.now();
+    if (m.frameWidth !== width || m.frameHeight !== height) {
+      width = m.frameWidth;
+      height = m.frameHeight;
+      buffer = new Uint8Array(width * height * 4);
+      covered = false;
+      mask = new Uint8Array(width * height);
+      uncovered = width * height;
+    }
+    const { x, y, width: w, height: h, data } = m.frame;
+    if (x === 0 && y === 0 && w === width && h === height) {
+      buffer.set(data);
+      covered = true;
+      mask = null;
+      return;
+    }
+    for (let row = 0; row < h; row++) {
+      const src = row * w * 4;
+      buffer.set(data.subarray(src, src + w * 4), ((y + row) * width + x) * 4);
+    }
+    if (!covered && mask) {
+      for (let row = 0; row < h; row++) {
+        let p = (y + row) * width + x;
+        for (let col = 0; col < w; col++, p++) {
+          if (mask[p] === 0) {
+            mask[p] = 1;
+            uncovered--;
+          }
+        }
+      }
+      if (uncovered === 0) {
+        covered = true;
+        mask = null;
+      }
+    }
+  };
+  source.on("frame", onFrame);
+  try {
+    source.invalidate();
+    let settled = true;
+    const deadline = Date.now() + timeoutMs;
+    for (; ; ) {
+      const failed = options.failure?.();
+      if (failed) throw failed;
+      if (covered && Date.now() - lastPaint >= settleMs) break;
+      if (Date.now() >= deadline) {
+        if (!covered) throw new Error(`no full frame painted within ${timeoutMs} ms`);
+        options.onWarn?.(`page kept painting for ${timeoutMs} ms (animation?); capturing the current frame`);
+        settled = false;
+        break;
+      }
+      await sleep$1(Math.min(50, settleMs));
+    }
+    return { width, height, bgra: buffer.slice(), settled };
+  } finally {
+    source.off("frame", onFrame);
+  }
+}
+function bgraToRgba(bgra, width, height) {
+  const data = new Uint8ClampedArray(bgra.length);
+  for (let i = 0; i < bgra.length; i += 4) {
+    data[i] = bgra[i + 2];
+    data[i + 1] = bgra[i + 1];
+    data[i + 2] = bgra[i];
+    data[i + 3] = 255;
+  }
+  return { width, height, data };
+}
+const INK_LUMINANCE = 200;
+const BAND_COUNT = 8;
+const FINDING_THRESHOLD = 5e-3;
+function luminance(r, g, b) {
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+const isInk = (d, i) => luminance(d[i], d[i + 1], d[i + 2]) < INK_LUMINANCE;
+function inkCoverage(img) {
+  let ink = 0;
+  for (let i = 0; i < img.data.length; i += 4) {
+    if (isInk(img.data, i)) ink++;
+  }
+  return ink / (img.width * img.height);
+}
+function inkRows(img) {
+  let rows = 0;
+  for (let y = 0; y < img.height; y++) {
+    for (let x = 0; x < img.width; x++) {
+      if (isInk(img.data, (y * img.width + x) * 4)) {
+        rows++;
+        break;
+      }
+    }
+  }
+  return rows;
+}
+function bandInk(img, y0, y1) {
+  let ink = 0;
+  for (let y = y0; y < y1; y++) {
+    for (let x = 0; x < img.width; x++) {
+      if (isInk(img.data, (y * img.width + x) * 4)) ink++;
+    }
+  }
+  const pixels = (y1 - y0) * img.width;
+  return pixels === 0 ? 0 : ink / pixels;
+}
+const pct = (v) => `${(v * 100).toFixed(2)}%`;
+function diffMetrics(target, reference, referenceDeviceRows) {
+  if (target.width !== reference.width || target.height !== reference.height) {
+    throw new RangeError(
+      `diffMetrics: mismatched dimensions (target ${target.width}x${target.height}, reference ${reference.width}x${reference.height})`
+    );
+  }
+  const targetCoverage = inkCoverage(target);
+  const referenceCoverage = inkCoverage(reference);
+  const targetRows = inkRows(target);
+  const bands = [];
+  const findings = [];
+  for (let i = 0; i < BAND_COUNT; i++) {
+    const y0 = Math.floor(target.height * i / BAND_COUNT);
+    const y1 = Math.floor(target.height * (i + 1) / BAND_COUNT);
+    const targetInk = bandInk(target, y0, y1);
+    const referenceInk = bandInk(reference, y0, y1);
+    const delta = targetInk - referenceInk;
+    bands.push({ y0, y1, targetInk, referenceInk, delta });
+    if (Math.abs(delta) > FINDING_THRESHOLD) {
+      const direction = delta < 0 ? "target loses ink vs the 2x reference (thin strokes weakening or dropping out)" : "target gains ink vs the 2x reference (strokes thickening or darkening)";
+      findings.push(
+        `band ${i} (y ${y0}–${y1}): ink ${pct(targetInk)} vs ${pct(referenceInk)} reference (${delta >= 0 ? "+" : ""}${(delta * 100).toFixed(2)}pp) — ${direction}`
+      );
+    }
+  }
+  return {
+    inkCoverage: { target: targetCoverage, reference: referenceCoverage, delta: targetCoverage - referenceCoverage },
+    rows: {
+      target: targetRows,
+      reference: referenceDeviceRows,
+      ratio: referenceDeviceRows > 0 ? targetRows / referenceDeviceRows : null
+    },
+    bands,
+    findings
+  };
+}
+function profileToParams(p, hostNits) {
+  if (!(hostNits > 0)) throw new RangeError("hostNits must be > 0");
+  return {
+    brightness: p.nits === null ? 1 : p.nits / hostNits,
+    blackFloor: p.contrastRatio === null ? 0 : 1 / p.contrastRatio,
+    gamut: p.gamutCoverage,
+    levels: 2 ** p.bits - 1,
+    dither: p.frc
+  };
+}
+const BAYER4 = [0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5];
+function bayer(x, y) {
+  return BAYER4[(y & 3) * 4 + (x & 3)] / 16;
+}
+const GAMMA = 2.2;
+const toLinear = (v) => Math.pow(v, GAMMA);
+const toEncoded = (v) => Math.pow(v, 1 / GAMMA);
+const clamp01 = (v) => Math.min(1, Math.max(0, v));
+function simulatePixel(rgb, params, x = 0, y = 0) {
+  let c = rgb.map((v) => toLinear(v / 255));
+  c = c.map((v) => params.brightness * (params.blackFloor + (1 - params.blackFloor) * v));
+  const l = 0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2];
+  c = c.map((v) => l + (v - l) * params.gamut);
+  c = c.map((v) => toEncoded(clamp01(v)));
+  const d = params.dither ? bayer(x, y) - 0.5 : 0;
+  c = c.map((v) => Math.floor(v * params.levels + d + 0.5) / params.levels);
+  return c.map((v) => Math.round(clamp01(v) * 255));
+}
+function applyPanelProfile(img, profile, hostNits = targetSource.DEFAULT_SETTINGS.hostNits) {
+  if (profile.id === "reference") return img;
+  const params = profileToParams(profile, hostNits);
+  const out = new Uint8ClampedArray(img.data.length);
+  for (let y = 0; y < img.height; y++) {
+    for (let x = 0; x < img.width; x++) {
+      const i = (y * img.width + x) * 4;
+      const [r, g, b] = simulatePixel([img.data[i], img.data[i + 1], img.data[i + 2]], params, x, y);
+      out[i] = r;
+      out[i + 1] = g;
+      out[i + 2] = b;
+      out[i + 3] = img.data[i + 3];
+    }
+  }
+  return { width: img.width, height: img.height, data: out };
+}
+function cliArgv() {
+  const sep = process.argv.indexOf("--");
+  return sep >= 0 ? process.argv.slice(sep + 1) : process.argv.slice(2);
+}
+const human = (message) => {
+  process.stderr.write(`${message}
+`);
+};
+const machine = (json) => new Promise((done) => {
+  process.stdout.write(`${JSON.stringify(json, null, 2)}
+`, () => done());
+});
+const sleep = (ms) => new Promise((done) => setTimeout(done, ms));
+function encodePng(img) {
+  const bgra = rgbaToBgra(img);
+  const image = electron.nativeImage.createFromBitmap(Buffer.from(bgra.buffer, bgra.byteOffset, bgra.byteLength), {
+    width: img.width,
+    height: img.height
+  });
+  return image.toPNG();
+}
+async function render(url, spec, options) {
+  const target = new targetSource.TargetSource(30, { mobileEmulation: options.mobileEmulation ?? true });
+  try {
+    const failure = { error: null };
+    target.on("load-error", (e) => {
+      failure.error ??= e;
+    });
+    const failed = () => failure.error ? new Error(`render failed: ${failure.error.description} (code ${failure.error.code}) — ${failure.error.url}`) : null;
+    const warnings = [];
+    const warn = (message) => {
+      warnings.push(message);
+      human(message);
+    };
+    const applied = target.setViewport(spec.cssWidth, spec.cssHeight, spec.deviceScaleFactor);
+    let timer;
+    const timeout = new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error(`load did not finish within ${options.timeoutMs} ms: ${url}`)), options.timeoutMs);
+    });
+    try {
+      await Promise.race([target.load(url), timeout]);
+    } finally {
+      clearTimeout(timer);
+    }
+    if (failure.error) {
+      throw new Error(`load failed: ${failure.error.description} (code ${failure.error.code}) — ${failure.error.url}`);
+    }
+    if (options.waitMs > 0) {
+      const until = Date.now() + options.waitMs;
+      while (Date.now() < until) {
+        const err = failed();
+        if (err) throw err;
+        await sleep(Math.min(50, until - Date.now()));
+      }
+    }
+    let cssHeight = applied.height;
+    if (options.fullPage) {
+      const scrollHeight = Math.ceil(
+        await target.webContents.executeJavaScript(
+          "Math.max(document.documentElement.scrollHeight, document.body ? document.body.scrollHeight : 0)"
+        )
+      );
+      if (scrollHeight > cssHeight) {
+        const limit = targetSource.maxCssViewport(spec.deviceScaleFactor);
+        const wanted = Math.min(scrollHeight, limit);
+        if (scrollHeight > limit) {
+          warn(
+            `warning: full page is ${scrollHeight} CSS px tall; clamped to ${wanted} (device pixels are capped at 4096 per axis)`
+          );
+        }
+        target.setViewport(applied.width, wanted, spec.deviceScaleFactor);
+        cssHeight = wanted;
+      }
+    }
+    const frame = await captureQuiescent(target, { timeoutMs: options.timeoutMs, onWarn: warn, failure: failed });
+    return { frame, cssWidth: applied.width, cssHeight, warnings };
+  } finally {
+    target.destroy();
+  }
+}
+function snapOutputPath(cmd, spec) {
+  if (!cmd.matrix) return node_path.resolve(cmd.out);
+  if (cmd.out.includes("{preset}")) return node_path.resolve(cmd.out.replaceAll("{preset}", spec.presetId));
+  return node_path.resolve(cmd.out, `obsrv-${spec.presetId}.png`);
+}
+async function runSnap(cmd) {
+  const profile = targetSource.findProfile(cmd.profileId);
+  const results = [];
+  for (const spec of cmd.specs) {
+    const out = snapOutputPath(cmd, spec);
+    const r = await render(cmd.url, spec, cmd);
+    const img = applyPanelProfile(bgraToRgba(r.frame.bgra, r.frame.width, r.frame.height), profile);
+    node_fs.mkdirSync(node_path.dirname(out), { recursive: true });
+    node_fs.writeFileSync(out, encodePng(img));
+    human(
+      `snap ${cmd.url} → ${out} (${r.frame.width}×${r.frame.height} device px, preset ${spec.presetId}, profile ${profile.id})`
+    );
+    results.push({
+      out,
+      preset: spec.presetId,
+      cssWidth: r.cssWidth,
+      cssHeight: r.cssHeight,
+      deviceScaleFactor: spec.deviceScaleFactor,
+      profile: profile.id,
+      // False means a best-effort capture of a page that never went
+      // paint-quiet (animation); machine consumers can gate on it.
+      settled: r.frame.settled,
+      warnings: r.warnings
+    });
+  }
+  await machine(cmd.matrix ? results : results[0]);
+}
+async function runDiff(cmd) {
+  const profile = targetSource.findProfile(cmd.profileId);
+  const t = await render(cmd.url, cmd.spec, { fullPage: false, waitMs: cmd.waitMs, timeoutMs: cmd.timeoutMs });
+  const target = applyPanelProfile(bgraToRgba(t.frame.bgra, t.frame.width, t.frame.height), profile);
+  const refSpec = { ...cmd.spec, deviceScaleFactor: 2 };
+  const r = await render(cmd.url, refSpec, {
+    fullPage: false,
+    waitMs: cmd.waitMs,
+    timeoutMs: cmd.timeoutMs,
+    mobileEmulation: false
+  });
+  const referenceFull = bgraToRgba(r.frame.bgra, r.frame.width, r.frame.height);
+  const referenceDeviceRows = inkRows(referenceFull);
+  const reference = boxDownsample(referenceFull, 2);
+  const metrics = diffMetrics(target, reference, referenceDeviceRows);
+  let files;
+  if (cmd.outDir) {
+    const dir = node_path.resolve(cmd.outDir);
+    node_fs.mkdirSync(dir, { recursive: true });
+    files = { target: node_path.join(dir, "target.png"), reference: node_path.join(dir, "reference.png") };
+    node_fs.writeFileSync(files.target, encodePng(target));
+    node_fs.writeFileSync(files.reference, encodePng(reference));
+  }
+  const pct2 = (v) => `${(v * 100).toFixed(2)}%`;
+  human(
+    `diff ${cmd.url} @ ${cmd.spec.presetId} (profile ${profile.id}): ink ${pct2(metrics.inkCoverage.target)} vs ${pct2(metrics.inkCoverage.reference)} reference, rows ${metrics.rows.target}/${metrics.rows.reference} (ratio ${metrics.rows.ratio?.toFixed(2) ?? "n/a"}), ${metrics.findings.length} finding(s)`
+  );
+  await machine({
+    url: cmd.url,
+    preset: cmd.spec.presetId,
+    profile: profile.id,
+    ...files ? { files } : {},
+    ...metrics
+  });
+}
+const userData = process.env.OBSRV_CLI_USER_DATA ?? node_fs.mkdtempSync(node_path.join(node_os.tmpdir(), "obsrv-cli-"));
+electron.app.setPath("userData", userData);
+const cleanupUserData = () => {
+  try {
+    node_fs.rmSync(userData, { recursive: true, force: true });
+  } catch {
+  }
+};
+electron.app.on("quit", cleanupUserData);
+electron.app.on("window-all-closed", () => {
+});
+for (const signal of ["SIGINT", "SIGTERM"]) {
+  process.on(signal, () => {
+    cleanupUserData();
+    electron.app.exit(1);
+  });
+}
+void electron.app.whenReady().then(async () => {
+  electron.app.dock?.hide();
+  let code = 0;
+  try {
+    const cmd = parseArgs(cliArgv());
+    if (cmd.command === "help") {
+      await new Promise((done) => process.stdout.write(`${cmd.text}
+`, () => done()));
+    } else if (cmd.command === "snap") {
+      await runSnap(cmd);
+    } else {
+      await runDiff(cmd);
+    }
+  } catch (e) {
+    code = e instanceof ArgError ? 2 : 1;
+    human(`obsrv: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  cleanupUserData();
+  electron.app.exit(code);
+});