getobsrv 0.3.0

package/out/main/targetSource-w_vWw7zd.js

@@ -0,0 +1,351 @@
+"use strict";
+const electron = require("electron");
+const node_events = require("node:events");
+const node_path = require("node:path");
+const MAX_VIEWPORT = 4096;
+const DEFAULT_SETTINGS = { hostDiagonalInches: 27, hostNits: 500 };
+const SCREEN_PRESETS = [
+  // Laptops — ordered largest to smallest panel, then the denser 1080p outlier.
+  { id: "laptop-768", label: '1366×768 15.6"', width: 1366, height: 768, diagonalInches: 15.6, deviceScaleFactor: 1, group: "laptop" },
+  { id: "laptop-768-14", label: '1366×768 14"', width: 1366, height: 768, diagonalInches: 14, deviceScaleFactor: 1, group: "laptop" },
+  { id: "laptop-768-11", label: '1366×768 11.6" (Chromebook)', width: 1366, height: 768, diagonalInches: 11.6, deviceScaleFactor: 1, group: "laptop" },
+  { id: "laptop-800-11", label: '1280×800 11.6" (Chromebook)', width: 1280, height: 800, diagonalInches: 11.6, deviceScaleFactor: 1, group: "laptop" },
+  { id: "laptop-900-17", label: '1600×900 17.3"', width: 1600, height: 900, diagonalInches: 17.3, deviceScaleFactor: 1, group: "laptop" },
+  { id: "laptop-1080-15", label: '1080p 15.6"', width: 1920, height: 1080, diagonalInches: 15.6, deviceScaleFactor: 1, group: "laptop" },
+  // Desktops.
+  { id: "1080p-24", label: '1080p 24"', width: 1920, height: 1080, diagonalInches: 24, deviceScaleFactor: 1, group: "desktop" },
+  { id: "1080p-27", label: '1080p 27"', width: 1920, height: 1080, diagonalInches: 27, deviceScaleFactor: 1, group: "desktop" },
+  { id: "1440p-27", label: '1440p 27"', width: 2560, height: 1440, diagonalInches: 27, deviceScaleFactor: 1, group: "desktop" },
+  { id: "sxga-19", label: '1280×1024 19" (5:4)', width: 1280, height: 1024, diagonalInches: 19, deviceScaleFactor: 1, group: "desktop" },
+  { id: "1440x900-19", label: '1440×900 19"', width: 1440, height: 900, diagonalInches: 19, deviceScaleFactor: 1, group: "desktop" },
+  // Mobiles — CSS viewport x the device's real scale factor. A phone preset
+  // rendered at 1x would look worse than any real phone; these rasterise at
+  // 2x/3x and are shown at true physical size (usually minified on a desktop).
+  { id: "android-65", label: 'Budget Android 6.5" @2x', width: 360, height: 800, diagonalInches: 6.5, deviceScaleFactor: 2, group: "mobile" },
+  { id: "iphone-se", label: 'iPhone SE 4.7" @2x', width: 375, height: 667, diagonalInches: 4.7, deviceScaleFactor: 2, group: "mobile" },
+  { id: "iphone-61", label: 'iPhone 6.1" @3x', width: 393, height: 852, diagonalInches: 6.1, deviceScaleFactor: 3, group: "mobile" },
+  { id: "ipad-109", label: 'iPad 10.9" @2x', width: 820, height: 1180, diagonalInches: 10.9, deviceScaleFactor: 2, group: "mobile" }
+];
+const PANEL_PROFILES = [
+  { id: "reference", label: "Reference (off)", contrastRatio: null, gamutCoverage: 1, bits: 8, frc: false, nits: null },
+  { id: "office-ips", label: "Office IPS", contrastRatio: 1e3, gamutCoverage: 1, bits: 8, frc: false, nits: 300 },
+  { id: "budget-tn", label: "Budget TN", contrastRatio: 700, gamutCoverage: 0.72, bits: 6, frc: true, nits: 250 },
+  { id: "old-laptop", label: "Old laptop", contrastRatio: 600, gamutCoverage: 0.6, bits: 6, frc: false, nits: 220 }
+];
+function findPreset(id) {
+  const p = SCREEN_PRESETS.find((x) => x.id === id);
+  if (!p) throw new Error(`unknown preset: ${id}`);
+  return p;
+}
+function findProfile(id) {
+  const p = PANEL_PROFILES.find((x) => x.id === id);
+  if (!p) throw new Error(`unknown profile: ${id}`);
+  return p;
+}
+function maxCssViewport(deviceScaleFactor) {
+  const dsf = Number.isFinite(deviceScaleFactor) && deviceScaleFactor > 1 ? deviceScaleFactor : 1;
+  return Math.max(1, Math.floor(MAX_VIEWPORT / dsf));
+}
+function clampViewport(width, height, max = MAX_VIEWPORT) {
+  const finite = (v) => Number.isFinite(v) ? v : 1;
+  const w = Math.min(max, Math.max(1, Math.floor(finite(width))));
+  const h = Math.min(max, Math.max(1, Math.floor(finite(height))));
+  return { width: w, height: h, clamped: w !== width || h !== height };
+}
+const IMAGE_EXTENSIONS = /\.(png|jpe?g)$/i;
+function classifyFileNavigation(from, to) {
+  if (!to.startsWith("file:")) return "allow";
+  const path = to.split(/[?#]/, 1)[0] ?? "";
+  if (IMAGE_EXTENSIONS.test(path)) return "image";
+  return from.startsWith("file:") ? "allow" : "block";
+}
+const SCHEME = /^[a-z][a-z0-9+.-]*:/i;
+const LOOPBACK = /^(localhost|127\.0\.0\.1|\[::1\])(:\d+)?(\/|$)/i;
+function normalizeUrl(input) {
+  const s = input.trim();
+  if (s === "") throw new Error("empty url");
+  if (/\s/.test(s)) throw new Error("invalid URL");
+  if (s.startsWith("/")) return `file://${s}`;
+  if (LOOPBACK.test(s)) return `http://${s}`;
+  if (SCHEME.test(s)) return s;
+  return `https://${s}`;
+}
+const ERR_ABORTED = -3;
+const DEFAULT_FPS = 30;
+const DEFAULT_VIEWPORT = { width: 1920, height: 1080 };
+const MOBILE_USER_AGENT = `Mozilla/5.0 (Linux; Android 14; Pixel 8) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${process.versions.chrome ?? "120.0.0.0"} Mobile Safari/537.36`;
+class TargetSource extends node_events.EventEmitter {
+  win;
+  viewport = { ...DEFAULT_VIEWPORT };
+  dsf = 1;
+  fps;
+  /** See TargetSourceOptions.mobileEmulation. */
+  mobileEmulation;
+  /** Electron's own UA, captured from the first window and restored for dsf 1. */
+  defaultUserAgent = null;
+  /**
+   * Settles once the current window's first navigation has committed — or can
+   * never commit. Chromium's offscreen renderer segfaults (exit 11, Electron
+   * 43 / macOS) when a second `loadURL` interrupts the very first one before
+   * it commits; interrupting any later navigation is an ordinary
+   * `ERR_ABORTED`. Every `load()` waits on this so the unit is safe to drive
+   * the instant it is constructed — and re-waits if a recreation swapped in a
+   * fresh window (with a fresh first navigation) mid-wait. It also settles if
+   * the renderer dies or the surface is destroyed first, so a later `load()`
+   * never hangs on a gate that cannot open.
+   */
+  firstNavigation;
+  /** True once the current window's first-navigation gate has settled. */
+  firstNavDone = false;
+  /**
+   * The URL the target is meant to be showing: set the moment `load()`
+   * accepts a navigation and updated by every committed non-internal
+   * main-frame navigation. Recreation restores from *this*, never from the
+   * dying window's `getURL()` — mid-recreation that reads the replacement's
+   * `about:blank` and a second density change would silently drop the real
+   * page; likewise an in-flight `load()` whose window is destroyed under it
+   * still gets its URL restored, because it was recorded before the gate.
+   */
+  intendedUrl = null;
+  /**
+   * True while a recreated window loads its internal `about:blank`. Those
+   * navigation events are plumbing, not news: reported, SyncBus would mirror
+   * `about:blank` into the native pane every time the preset changes density.
+   * Frames still flow — a blank paint is stale for a moment, never wrong.
+   */
+  internal = false;
+  disposed = false;
+  constructor(fps = DEFAULT_FPS, options = {}) {
+    super();
+    this.fps = fps;
+    this.mobileEmulation = options.mobileEmulation ?? true;
+    this.createWindow();
+  }
+  createWindow() {
+    const win = new electron.BrowserWindow({
+      show: false,
+      width: this.viewport.width,
+      height: this.viewport.height,
+      useContentSize: true,
+      // macOS refuses window sizes larger than the display without this.
+      enableLargerThanScreen: true,
+      webPreferences: {
+        preload: node_path.join(__dirname, "../preload/sync.js"),
+        offscreen: { deviceScaleFactor: this.dsf },
+        contextIsolation: true,
+        sandbox: true,
+        nodeIntegration: false,
+        backgroundThrottling: false
+      }
+    });
+    this.win = win;
+    this.firstNavDone = false;
+    const wc = win.webContents;
+    wc.setFrameRate(this.fps);
+    wc.setAudioMuted(true);
+    this.defaultUserAgent ??= wc.getUserAgent();
+    wc.setUserAgent(this.dsf > 1 && this.mobileEmulation ? MOBILE_USER_AGENT : this.defaultUserAgent);
+    wc.on("paint", (_event, dirty, image) => {
+      if (dirty.width <= 0 || dirty.height <= 0) return;
+      if (image.isEmpty()) return;
+      const full = image.getSize();
+      const isFull = dirty.x === 0 && dirty.y === 0 && dirty.width === full.width && dirty.height === full.height;
+      this.emit("frame", {
+        frame: {
+          x: dirty.x,
+          y: dirty.y,
+          width: dirty.width,
+          height: dirty.height,
+          // `toBitmap()` already returns a fresh copy of the pixels (unlike the
+          // deprecated `getBitmap()`, typed `void` in Electron 43), and a
+          // Buffer is a Uint8Array, so this is the only copy of the slice.
+          data: (isFull ? image : image.crop(dirty)).toBitmap()
+        },
+        frameWidth: full.width,
+        frameHeight: full.height
+      });
+    });
+    wc.on("did-navigate", (_e, url) => {
+      this.applyEmulation();
+      if (this.internal) return;
+      this.intendedUrl = url;
+      this.emit("url-changed", url);
+    });
+    wc.on("did-navigate-in-page", (_e, url, isMainFrame) => {
+      if (isMainFrame && !this.internal) {
+        this.intendedUrl = url;
+        this.emit("url-changed", url);
+      }
+    });
+    wc.on("did-fail-load", (_e, code, description, url, isMainFrame) => {
+      if (isMainFrame && code !== ERR_ABORTED && !this.internal) {
+        this.emit("load-error", { code, description, url });
+      }
+    });
+    wc.on("did-start-loading", () => {
+      if (!this.internal) this.emit("loading", true);
+    });
+    wc.on("did-stop-loading", () => {
+      if (!this.internal) this.emit("loading", false);
+    });
+    wc.on("did-start-navigation", (details) => {
+      if (!this.internal && details.isMainFrame && !details.isSameDocument) this.emit("navigating");
+    });
+    wc.on("render-process-gone", (_e, details) => {
+      if (details.reason === "clean-exit") return;
+      this.emit("load-error", {
+        code: details.exitCode,
+        description: `renderer crashed: ${details.reason}`,
+        url: wc.getURL()
+      });
+    });
+    wc.on("will-navigate", (e, url) => {
+      if (classifyFileNavigation(wc.getURL(), url) !== "allow") e.preventDefault();
+    });
+    wc.setWindowOpenHandler(({ url }) => {
+      if (url && url !== "about:blank") void this.load(url);
+      return { action: "deny" };
+    });
+    const gate = new Promise((settle) => {
+      wc.once("render-process-gone", () => settle());
+      wc.once("destroyed", () => settle());
+      wc.loadURL("about:blank").then(() => settle(), () => settle());
+    });
+    this.firstNavigation = gate.then(() => {
+      if (this.win === win) this.firstNavDone = true;
+    });
+  }
+  /**
+   * Mobile viewport semantics for dsf > 1 (see class doc). Post-commit only:
+   * enabling emulation before a window's first navigation commits segfaults
+   * the OSR renderer, so callers are either the `did-navigate` handler (by
+   * definition post-commit) or gated on `firstNavDone`.
+   */
+  applyEmulation() {
+    if (this.dsf <= 1 || !this.mobileEmulation || this.win.isDestroyed()) return;
+    this.win.webContents.enableDeviceEmulation({
+      screenPosition: "mobile",
+      screenSize: { width: this.viewport.width, height: this.viewport.height },
+      viewPosition: { x: 0, y: 0 },
+      viewSize: { width: this.viewport.width, height: this.viewport.height },
+      deviceScaleFactor: this.dsf,
+      scale: 1
+    });
+  }
+  /**
+   * Swaps in a fresh window at the current viewport and dsf, then restores
+   * the page the old one was showing. Created before the old is destroyed —
+   * see the class doc for why that order is load-bearing.
+   */
+  recreate() {
+    const old = this.win;
+    this.internal = true;
+    this.createWindow();
+    if (!old.isDestroyed()) old.destroy();
+    const win = this.win;
+    void this.firstNavigation.then(async () => {
+      if (this.disposed || this.win !== win || win.isDestroyed()) return;
+      this.internal = false;
+      const url = this.intendedUrl;
+      if (url && url !== "about:blank") {
+        try {
+          await win.webContents.loadURL(url);
+        } catch {
+        }
+      } else {
+        win.webContents.invalidate();
+      }
+    });
+  }
+  /** Loads URL-bar input; returns the normalised URL that was requested. */
+  async load(input) {
+    try {
+      const url = normalizeUrl(input);
+      this.intendedUrl = url;
+      let gate;
+      do {
+        gate = this.firstNavigation;
+        await gate;
+      } while (gate !== this.firstNavigation);
+      if (this.win.isDestroyed()) return url;
+      try {
+        await this.win.webContents.loadURL(url);
+      } catch {
+      }
+      return url;
+    } catch (e) {
+      const description = e instanceof Error ? e.message : String(e);
+      this.emit("load-error", { code: 0, description, url: input });
+      return input;
+    }
+  }
+  /**
+   * Resizes the offscreen surface; `width`/`height` are CSS pixels and the
+   * clamp budget is device pixels (`maxCssViewport`). A changed
+   * `deviceScaleFactor` recreates the window (the offscreen dsf is fixed at
+   * creation); a same-dsf resize is the cheap `setContentSize` path. Returns
+   * the applied (possibly clamped) CSS size.
+   */
+  setViewport(width, height, deviceScaleFactor = 1) {
+    const dsf = Number.isFinite(deviceScaleFactor) && deviceScaleFactor >= 1 ? deviceScaleFactor : 1;
+    const v = clampViewport(width, height, maxCssViewport(dsf));
+    this.viewport = { width: v.width, height: v.height };
+    if (dsf !== this.dsf) {
+      this.dsf = dsf;
+      if (!this.disposed) this.recreate();
+    } else if (!this.win.isDestroyed()) {
+      this.win.setContentSize(v.width, v.height);
+      if (this.firstNavDone) this.applyEmulation();
+      this.win.webContents.invalidate();
+    }
+    return v;
+  }
+  /**
+   * Changes the raster density alone, keeping the current CSS viewport
+   * (re-clamped for the new device-pixel budget). Same recreation path as
+   * `setViewport` with a new factor.
+   */
+  setDeviceScaleFactor(deviceScaleFactor) {
+    return this.setViewport(this.viewport.width, this.viewport.height, deviceScaleFactor);
+  }
+  getViewport() {
+    return { ...this.viewport };
+  }
+  getDeviceScaleFactor() {
+    return this.dsf;
+  }
+  /** Forces a full-frame repaint, e.g. after the renderer loses its texture. */
+  invalidate() {
+    if (!this.win.isDestroyed()) this.win.webContents.invalidate();
+  }
+  sendInput(ev) {
+    if (!this.win.isDestroyed()) this.win.webContents.sendInputEvent(ev);
+  }
+  reload() {
+    if (!this.win.isDestroyed()) this.win.webContents.reload();
+  }
+  back() {
+    if (!this.win.isDestroyed()) this.win.webContents.navigationHistory.goBack();
+  }
+  forward() {
+    if (!this.win.isDestroyed()) this.win.webContents.navigationHistory.goForward();
+  }
+  get webContents() {
+    return this.win.webContents;
+  }
+  destroy() {
+    this.disposed = true;
+    this.removeAllListeners();
+    if (!this.win.isDestroyed()) this.win.destroy();
+  }
+}
+exports.DEFAULT_SETTINGS = DEFAULT_SETTINGS;
+exports.IMAGE_EXTENSIONS = IMAGE_EXTENSIONS;
+exports.PANEL_PROFILES = PANEL_PROFILES;
+exports.SCREEN_PRESETS = SCREEN_PRESETS;
+exports.TargetSource = TargetSource;
+exports.classifyFileNavigation = classifyFileNavigation;
+exports.findPreset = findPreset;
+exports.findProfile = findProfile;
+exports.maxCssViewport = maxCssViewport;
+exports.normalizeUrl = normalizeUrl;

package/out/mcp/lib.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALLOWED_URL_SCHEMES = exports.STDERR_TAIL_CHARS = exports.MAX_INLINE_IMAGE_BYTES = exports.UsageError = void 0;
+exports.buildSnapArgs = buildSnapArgs;
+exports.buildDiffArgs = buildDiffArgs;
+exports.shouldInlineImage = shouldInlineImage;
+exports.killBudgetMs = killBudgetMs;
+exports.stderrTail = stderrTail;
+exports.urlSchemeError = urlSchemeError;
+exports.extractTrailingJson = extractTrailingJson;
+exports.listCatalog = listCatalog;
+const presets_1 = require("../shared/presets");
+/**
+ * Pure helpers for the MCP server (`src/mcp/server.ts`): tool-input → CLI
+ * argv mapping, inline-image size gating, and the presets/profiles catalog.
+ * No SDK, no child processes, no I/O — everything here runs under plain node
+ * and is unit-tested in tests/unit/mcpLib.test.ts.
+ */
+/** A caller mistake (bad flag combination), as opposed to a render failure. */
+class UsageError extends Error {
+}
+exports.UsageError = UsageError;
+/** Inline-image budget: 1.5 MiB of PNG before we fall back to the file path. */
+exports.MAX_INLINE_IMAGE_BYTES = 1_572_864;
+/** How much CLI stderr a tool error carries back to the model. */
+exports.STDERR_TAIL_CHARS = 2000;
+/**
+ * Maps `obsrv_snap` input to `bin/obsrv.js` argv. Enforces the preset-XOR-
+ * custom-dims rule up front so the model gets one actionable message instead
+ * of the CLI's exit-2 round trip.
+ */
+function buildSnapArgs(input, outPath) {
+    const custom = input.width !== undefined ||
+        input.height !== undefined ||
+        input.deviceScaleFactor !== undefined ||
+        input.diagonalInches !== undefined;
+    if (input.preset !== undefined && custom) {
+        throw new UsageError('`preset` and custom dimensions are mutually exclusive — pass either `preset`, ' +
+            'or `width` + `height` (with optional `deviceScaleFactor` / `diagonalInches`). ' +
+            'Use obsrv_presets to list the preset ids.');
+    }
+    if (custom && (input.width === undefined || input.height === undefined)) {
+        throw new UsageError('custom dimensions need both `width` and `height` (`deviceScaleFactor` and ' +
+            '`diagonalInches` only refine them) — or pass `preset` instead.');
+    }
+    const args = ['snap', input.url];
+    if (input.preset !== undefined)
+        args.push('--preset', input.preset);
+    if (custom) {
+        args.push('--width', String(input.width), '--height', String(input.height));
+        if (input.deviceScaleFactor !== undefined)
+            args.push('--dsf', String(input.deviceScaleFactor));
+        if (input.diagonalInches !== undefined)
+            args.push('--diagonal', String(input.diagonalInches));
+    }
+    if (input.profile !== undefined)
+        args.push('--profile', input.profile);
+    if (input.fullPage)
+        args.push('--full-page');
+    if (input.waitMs !== undefined)
+        args.push('--wait', String(input.waitMs));
+    if (input.timeoutMs !== undefined)
+        args.push('--timeout', String(input.timeoutMs));
+    args.push('--out', outPath);
+    return args;
+}
+/** Maps `obsrv_diff` input to CLI argv; target/reference PNGs always land in `outDir`. */
+function buildDiffArgs(input, outDir) {
+    const args = ['diff', input.url];
+    if (input.preset !== undefined)
+        args.push('--preset', input.preset);
+    if (input.profile !== undefined)
+        args.push('--profile', input.profile);
+    if (input.waitMs !== undefined)
+        args.push('--wait', String(input.waitMs));
+    if (input.timeoutMs !== undefined)
+        args.push('--timeout', String(input.timeoutMs));
+    args.push('--out-dir', outDir);
+    return args;
+}
+/** Whether a PNG of this size goes into the response as an inline image block. */
+function shouldInlineImage(byteLength) {
+    return byteLength <= exports.MAX_INLINE_IMAGE_BYTES;
+}
+/**
+ * Outer kill budget for one CLI invocation: the CLI polices each render with
+ * its own --timeout, so the server only guards against a wedged Electron —
+ * (per-render budget + settle wait) × renders, plus boot/encode headroom.
+ * --wait counts per render (a diff waits in both the target and reference
+ * renders), so a healthy long-wait run is never killed mid-flight.
+ */
+function killBudgetMs(renders, timeoutMs, waitMs = 0) {
+    return renders * (timeoutMs + waitMs) + 60_000;
+}
+/** The tail of the CLI's stderr, trimmed and capped for a tool-error message. */
+function stderrTail(stderr, max = exports.STDERR_TAIL_CHARS) {
+    const trimmed = stderr.trim();
+    return trimmed.length <= max ? trimmed : `…${trimmed.slice(-max)}`;
+}
+/** Schemes a tool call may hand to the CLI. */
+exports.ALLOWED_URL_SCHEMES = ['http:', 'https:', 'file:'];
+/**
+ * Rejects URLs whose explicit scheme is outside the allowlist (javascript:,
+ * data:, chrome:, …) with an actionable message, or returns null when the URL
+ * may proceed. Scheme-relative (`//host`), bare-host (`example.com/page`) and
+ * host:port (`localhost:5173`) forms pass — they normalise to http(s)
+ * downstream.
+ */
+function urlSchemeError(url) {
+    const trimmed = url.trim();
+    const match = /^([a-z][a-z0-9+.-]*):/i.exec(trimmed);
+    if (!match)
+        return null; // bare host or scheme-relative
+    const scheme = `${match[1].toLowerCase()}:`;
+    if (exports.ALLOWED_URL_SCHEMES.includes(scheme))
+        return null;
+    // `localhost:5173`-style host:port, not a scheme: the "scheme" is followed
+    // by a bare port number.
+    if (/^[a-z0-9.-]+:\d+(\/|$)/i.test(trimmed))
+        return null;
+    return (`unsupported URL scheme "${scheme}" — obsrv renders ` +
+        `${exports.ALLOWED_URL_SCHEMES.map(s => `${s}//`).join(', ')} URLs only ` +
+        `(bare hosts like example.com also work; they normalise to http(s)).`);
+}
+/**
+ * Parses the CLI's machine output: the trailing JSON object on stdout.
+ * Tolerant of stray runtime noise ahead of it (e.g. Chromium warnings that
+ * escape onto stdout) by scanning line-start `{` candidates until one parses
+ * to the end.
+ */
+function extractTrailingJson(stdout) {
+    const text = stdout.trim();
+    for (let i = text.indexOf('{'); i >= 0; i = text.indexOf('{', i + 1)) {
+        if (i > 0 && text[i - 1] !== '\n')
+            continue;
+        try {
+            const parsed = JSON.parse(text.slice(i));
+            if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+                return parsed;
+            }
+        }
+        catch {
+            // Not JSON from here; keep scanning.
+        }
+    }
+    return null;
+}
+/** The `obsrv_presets` payload, straight from src/shared/presets.ts — no spawn. */
+function listCatalog() {
+    return {
+        presets: presets_1.SCREEN_PRESETS.map(p => ({
+            id: p.id,
+            label: p.label,
+            group: p.group,
+            cssWidth: p.width,
+            cssHeight: p.height,
+            deviceScaleFactor: p.deviceScaleFactor,
+            diagonalInches: p.diagonalInches,
+            ppi: Math.round(Math.hypot(p.width * p.deviceScaleFactor, p.height * p.deviceScaleFactor) / p.diagonalInches),
+        })),
+        profiles: presets_1.PANEL_PROFILES.map(p => ({
+            id: p.id,
+            label: p.label,
+            contrastRatio: p.contrastRatio,
+            gamutCoverage: p.gamutCoverage,
+            bits: p.bits,
+            frc: p.frc,
+            nits: p.nits,
+            summary: p.contrastRatio === null
+                ? 'no panel simulation (pass-through)'
+                : `contrast ${p.contrastRatio}:1, ${Math.round(p.gamutCoverage * 100)}% sRGB, ` +
+                    `${p.bits}-bit${p.frc ? '+FRC' : ''}, ${p.nits} nits`,
+        })),
+    };
+}