getobsrv 0.11.0 → 0.13.0

package/README.md

@@ -90,6 +90,24 @@ sit in half a window, and for agent captures. The native pane stays loaded while
 hidden, so the URL bar, back/forward and link clicks keep working exactly as
 they do side by side.
 
+### Tabs
+
+The strip above the URL bar holds several independent sessions at once. A tab is
+its own URL, its own screen preset and panel profile, its own view mode and pan,
+and its own page state — so the same page on a 1366×768 laptop and on a budget
+Android sit in two tabs and you flip between them without either one reloading.
+
+`Cmd+T` opens a tab, `Cmd+W` closes one, `Cmd+1`–`Cmd+8` select by position and
+`Cmd+9` selects the last. Closing the last tab leaves a fresh blank one rather
+than closing the window. Tabs come back on relaunch — their URLs, their screens
+and which one was in front.
+
+Every tab is two Chromium renderers (a native pane and an offscreen 1x surface),
+so the count is capped: 12 by default, settable from 2 to 32 in Settings. At the
+cap the new-tab button dims and says why. Background tabs stay loaded and keep
+their scroll position, but stop rasterising until you return to them — the cost
+of a background tab is memory, not GPU.
+
 ## Agent & CI use
 
 The same rendering pipeline runs headless — no window, JSON on stdout, humans
@@ -144,6 +162,15 @@ navigates unless you pass `url`, so the scroll survives the shutter. A live
 `navigated` field says which happened — and navigating is a fresh load, which
 starts at the top of the page.
 
+**Tabs and the agent.** `obsrv_drive` and a live `obsrv_snap` act on the tab
+that is in front, resolved per command rather than fixed when the drive starts —
+a command that quietly succeeded on a tab you could not see would not surface
+until the drive ended. Both report `tabId` and `tabIndex`, so an agent that
+cares can compare them across calls and notice you switched tabs under it. While
+Agent control is on, the driven tab carries a neutral rule on its leading edge
+that brightens for ~3 s on each command, so it is visible which session is being
+driven. An agent cannot open, close or switch tabs; that stays yours.
+
 A headless `snap` returns `settled: true` when the page went paint-quiet and
 every pixel painted. `settled: false` is still a usable capture, not a
 failure — a page that kept animating, or one whose repaint never completed,
@@ -220,3 +247,10 @@ belongs to an unrelated package.
   hides its scroller in a shadow root has no escape hatch.
 - Frame delivery has no renderer-side backpressure mailbox (see plan header); at 30 fps
   with dirty rects it has not been needed.
+- Tabs are a first cut. They cannot be reordered, dragged out into another window, or
+  reopened after closing (no `Cmd+Shift+T`), and there is no tab overflow menu — a strip
+  longer than the window scrolls. An agent can only reach the tab in front: there is no
+  way to name another tab in `obsrv_drive`, and no way for an agent to open, close or
+  switch tabs at all. The URL bar's visited-URL suggestions are one window-wide list
+  rather than one per tab (back/forward *are* per tab), and a restored tab comes back at
+  the top of its page — the scroll position is not persisted.

package/out/cli/args.js

@@ -30,6 +30,18 @@ Shared flags:
 ${presets}
   --width <px> --height <px> [--dsf <factor>] [--diagonal <inches>]
                        Custom CSS viewport instead of --preset (dsf defaults to 1).
+  --orientation <o>    portrait | landscape (default ${presets_1.DEFAULT_ORIENTATION}). This names the
+                       preset's *stored* orientation, not the shape you get:
+                         portrait  = the preset exactly as the table above lists it
+                         landscape = that rotated a quarter turn (width and height swap)
+                       Every mobile preset is stored portrait, so for those the two
+                       readings agree. The laptop and desktop presets are stored
+                       landscape-natural, so --orientation landscape turns them into a
+                       portrait screen — which is how you render a 1080p monitor stood on
+                       end (1080p-24 becomes 1080x1920). Applies to custom --width/--height
+                       dims too. The diagonal, raster density and physical size never
+                       change: it is the same panel turned sideways. Each render's JSON
+                       and log line name the resulting shape.
   --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 ${exports.DEFAULT_TIMEOUT_MS}).
@@ -55,7 +67,7 @@ warning naming what was missing. Only a render that painted nothing errors.`;
 /** Flags that take no value. */
 const BOOLEAN_FLAGS = new Set(['full-page', 'json']);
 /** Flags that consume the next token. */
-const VALUE_FLAGS = new Set(['preset', 'profile', 'out', 'out-dir', 'wait', 'timeout', 'matrix', 'width', 'height', 'dsf', 'diagonal']);
+const VALUE_FLAGS = new Set(['preset', 'profile', 'orientation', 'out', 'out-dir', 'wait', 'timeout', 'matrix', 'width', 'height', 'dsf', 'diagonal']);
 const SNAP_ONLY = new Set(['out', 'full-page', 'matrix']);
 const DIFF_ONLY = new Set(['out-dir', 'json']);
 function collect(command, argv) {
@@ -131,9 +143,30 @@ function presetSpec(id) {
         cssHeight: preset.height,
         deviceScaleFactor: preset.deviceScaleFactor,
         diagonalInches: preset.diagonalInches,
+        orientation: presets_1.DEFAULT_ORIENTATION,
     };
 }
+function resolveOrientation(flags) {
+    const raw = flags.get('orientation');
+    if (raw === undefined)
+        return presets_1.DEFAULT_ORIENTATION;
+    if (!(0, presets_1.isOrientation)(raw))
+        throw new ArgError(`--orientation: expected portrait or landscape, got "${String(raw)}"`);
+    return raw;
+}
+/**
+ * Rotation swaps the CSS axes and nothing else — the diagonal and the raster
+ * density are orientation-independent, so the render is the same screen turned
+ * sideways rather than a different one. Applied here, before the diff bounds
+ * are checked, so those check the viewport that will actually be rendered.
+ */
+function orientSpec(spec, orientation) {
+    if (orientation !== 'landscape')
+        return { ...spec, orientation };
+    return { ...spec, orientation, cssWidth: spec.cssHeight, cssHeight: spec.cssWidth };
+}
 function resolveSpecs(flags) {
+    const orientation = resolveOrientation(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');
@@ -153,17 +186,25 @@ function resolveSpecs(flags) {
             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 spec = {
+            presetId: 'custom',
+            cssWidth,
+            cssHeight,
+            deviceScaleFactor,
+            diagonalInches: diagonal,
+            orientation: presets_1.DEFAULT_ORIENTATION,
+        };
+        return { specs: [orientSpec(spec, orientation)], 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 };
+        return { specs: ids.map(id => orientSpec(presetSpec(id), orientation)), matrix: true };
     }
     const id = typeof flags.get('preset') === 'string' ? flags.get('preset') : exports.DEFAULT_PRESET;
-    return { specs: [presetSpec(id)], matrix: false };
+    return { specs: [orientSpec(presetSpec(id), orientation)], matrix: false };
 }
 function resolveProfile(flags) {
     const raw = flags.get('profile');
@@ -201,8 +242,14 @@ function parseArgs(argv) {
     }
     const referenceMax = (0, calibration_1.maxCssViewport)(2);
     if (spec.cssWidth > referenceMax || spec.cssHeight > referenceMax) {
+        // Named as rendered, not as stored: the dims here are post-rotation, and
+        // attributing them to the bare preset id would print "1440p-27 is
+        // 1440×2560" — a shape that id never has. The bound itself is per-axis
+        // symmetric, so rotation can never sneak a too-large viewport past it;
+        // this is the message telling the truth about which one it measured.
+        const as = spec.orientation === 'landscape' ? ' rotated a quarter turn' : '';
         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}. ` +
+            `(4096 device px at 2x) — "${spec.presetId}"${as} 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;

package/out/main/cli.js

@@ -3,7 +3,7 @@ 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-nbfc-Fe6.js");
+const targetSource = require("./targetSource-DuRYHUo8.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);
@@ -61,6 +61,18 @@ Shared flags:
 ${presets}
   --width <px> --height <px> [--dsf <factor>] [--diagonal <inches>]
                        Custom CSS viewport instead of --preset (dsf defaults to 1).
+  --orientation <o>    portrait | landscape (default ${targetSource.DEFAULT_ORIENTATION}). This names the
+                       preset's *stored* orientation, not the shape you get:
+                         portrait  = the preset exactly as the table above lists it
+                         landscape = that rotated a quarter turn (width and height swap)
+                       Every mobile preset is stored portrait, so for those the two
+                       readings agree. The laptop and desktop presets are stored
+                       landscape-natural, so --orientation landscape turns them into a
+                       portrait screen — which is how you render a 1080p monitor stood on
+                       end (1080p-24 becomes 1080x1920). Applies to custom --width/--height
+                       dims too. The diagonal, raster density and physical size never
+                       change: it is the same panel turned sideways. Each render's JSON
+                       and log line name the resulting shape.
   --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}).
@@ -84,7 +96,7 @@ painted. False is a rescued capture, not a failure: a page that kept animating
 warning naming what was missing. Only a render that painted nothing errors.`;
 }
 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 VALUE_FLAGS = /* @__PURE__ */ new Set(["preset", "profile", "orientation", "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) {
@@ -148,10 +160,22 @@ function presetSpec(id) {
     cssWidth: preset.width,
     cssHeight: preset.height,
     deviceScaleFactor: preset.deviceScaleFactor,
-    diagonalInches: preset.diagonalInches
+    diagonalInches: preset.diagonalInches,
+    orientation: targetSource.DEFAULT_ORIENTATION
   };
 }
+function resolveOrientation(flags) {
+  const raw = flags.get("orientation");
+  if (raw === void 0) return targetSource.DEFAULT_ORIENTATION;
+  if (!targetSource.isOrientation(raw)) throw new ArgError(`--orientation: expected portrait or landscape, got "${String(raw)}"`);
+  return raw;
+}
+function orientSpec(spec, orientation) {
+  if (orientation !== "landscape") return { ...spec, orientation };
+  return { ...spec, orientation, cssWidth: spec.cssHeight, cssHeight: spec.cssWidth };
+}
 function resolveSpecs(flags) {
+  const orientation = resolveOrientation(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");
@@ -168,16 +192,24 @@ function resolveSpecs(flags) {
       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 spec = {
+      presetId: "custom",
+      cssWidth,
+      cssHeight,
+      deviceScaleFactor,
+      diagonalInches: diagonal,
+      orientation: targetSource.DEFAULT_ORIENTATION
+    };
+    return { specs: [orientSpec(spec, orientation)], 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 };
+    return { specs: ids.map((id2) => orientSpec(presetSpec(id2), orientation)), matrix: true };
   }
   const id = typeof flags.get("preset") === "string" ? flags.get("preset") : DEFAULT_PRESET;
-  return { specs: [presetSpec(id)], matrix: false };
+  return { specs: [orientSpec(presetSpec(id), orientation)], matrix: false };
 }
 function resolveProfile(flags) {
   const raw = flags.get("profile");
@@ -215,8 +247,9 @@ ${usage()}`);
   }
   const referenceMax = targetSource.maxCssViewport(2);
   if (spec.cssWidth > referenceMax || spec.cssHeight > referenceMax) {
+    const as = spec.orientation === "landscape" ? " rotated a quarter turn" : "";
     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.`
+      `diff renders a 2x reference, so the CSS viewport must fit ${referenceMax}px per axis (4096 device px at 2x) — "${spec.presetId}"${as} 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;
@@ -559,8 +592,9 @@ async function runSnap(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));
+    const shape = targetSource.screenShape(r.cssWidth, r.cssHeight);
     human(
-      `snap ${cmd.url} → ${out} (${r.frame.width}×${r.frame.height} device px, preset ${spec.presetId}, profile ${profile.id})`
+      `snap ${cmd.url} → ${out} (${r.frame.width}×${r.frame.height} device px, ${r.cssWidth}×${r.cssHeight} CSS ${shape}, preset ${spec.presetId}, profile ${profile.id})`
     );
     results.push({
       out,
@@ -607,7 +641,7 @@ async function runDiff(cmd) {
   }
   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)${settled ? "" : " — UNSETTLED, deltas are not rendering evidence"}`
+    `diff ${cmd.url} @ ${cmd.spec.presetId} (${cmd.spec.cssWidth}×${cmd.spec.cssHeight} CSS ${targetSource.screenShape(cmd.spec.cssWidth, cmd.spec.cssHeight)}, 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)${settled ? "" : " — UNSETTLED, deltas are not rendering evidence"}`
   );
   await machine({
     url: cmd.url,