obsidian-integration-testing 16.0.0 → 17.0.0

package/dist/lib/esm/paint-out-status-bar.d.mts

@@ -0,0 +1,236 @@
+/**
+ * @file
+ *
+ * Paints the device's status bar out of a captured frame, so a device capture
+ * can be committed.
+ *
+ * A framebuffer carries the status bar, and a status bar carries a wall clock, a
+ * battery that charges while the emulator runs and a radio that comes and goes.
+ * So re-running a capture suite on an unchanged tree rewrites its PNGs with
+ * content nobody can commit, and the churn is invisible until someone diffs two
+ * runs. `device-screenshot`'s header has always said a device capture is not
+ * byte-reproducible; this is what makes one.
+ *
+ * **Pinning the bar was tried first, and is NOT sufficient — that finding is the
+ * reason this helper exists rather than a `withSystemUiDemoMode` one.** SystemUI
+ * demo mode (`sysui_demo_allowed`, plus one `com.android.systemui.demo`
+ * broadcast per area: clock at a fixed `hhmm`, battery full and unplugged,
+ * radios hidden, notification icons off) held the clock at `12:00` and two runs
+ * still disagreed on **1823 full-contrast pixels**, because the bar's leading
+ * group is laid out at a different offset between emulator boots —
+ * intermittently, roughly one boot in four. The Tuner's `icon_blacklist` does
+ * not help either: demo mode draws its own icon layer and ignores it. Measured
+ * on a real AVD across five paired capture runs for `obsidian-link-picker`'s
+ * store frames, which is where this recipe was worked out before it moved here.
+ *
+ * Removing the band rather than pinning it also retires every device setting
+ * that pinning needed, and nothing in a status bar is evidence about a plugin. A
+ * listing frame without one is what a listing frame normally looks like.
+ *
+ * **The band's height is the caller's to measure, and there is deliberately no
+ * default.** A wrong height does not fail loudly by itself — it paints over the
+ * product. What stands between the two is {@link resolveStatusBarBand}: the row
+ * just under the bar's own content must be one flat color all the way across,
+ * which is what an empty band looks like and is also where the fill color is
+ * sampled from. A taller bar, or an Obsidian that draws higher, fails the
+ * capture instead.
+ *
+ * Compositing over a captured frame is not a new liberty: `labelScreenshot`
+ * already draws the caption band across the bottom of the same image.
+ */
+/**
+ * Parameters for {@link buildStatusBarBandFailureMessage}.
+ */
+export interface BuildStatusBarBandFailureMessageParams {
+    /**
+     * How far in from each edge the row was scanned, in pixels.
+     */
+    readonly edgeMarginInPixels: number;
+    /**
+     * The height of the band that was about to be painted, in pixels.
+     */
+    readonly heightInPixels: number;
+    /**
+     * The verdict being reported.
+     */
+    readonly verdict: StatusBarBandVerdict;
+    /**
+     * The frame's width, in pixels.
+     */
+    readonly widthInPixels: number;
+}
+/**
+ * Options for {@link paintOutStatusBar}.
+ */
+export interface PaintOutStatusBarOptions {
+    /**
+     * How far in from each edge the clear-of-chrome check reads.
+     *
+     * @default {@link DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS}
+     */
+    readonly edgeMarginInPixels?: number;
+    /**
+     * How tall the device's status bar is, in framebuffer pixels.
+     *
+     * **Measured, never assumed, and deliberately without a default.** 24dp at a
+     * density of 320 is 48px, and that is one AVD's number rather than a constant
+     * of Android. Measure it on a frame: the bar's own content occupies the top
+     * rows, a few empty rows follow, and the app's top chrome starts at exactly
+     * this offset.
+     */
+    readonly heightInPixels: number;
+    /**
+     * How far above the band's bottom edge the fill color is sampled, in pixels.
+     *
+     * @default {@link DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS}
+     */
+    readonly sampleInsetInPixels?: number;
+}
+/**
+ * Parameters for {@link resolveStatusBarBand}.
+ */
+export interface ResolveStatusBarBandParams {
+    /**
+     * How many bytes each pixel occupies in {@link ResolveStatusBarBandParams.pixels} — 3 for RGB, 4 for RGBA.
+     */
+    readonly channelCount: number;
+    /**
+     * How far in from each edge to start reading, in pixels.
+     *
+     * A device's rounded corners darken a handful of pixels at both ends of every
+     * row in the band, constantly and harmlessly; the check is about what the APP
+     * draws, so it ignores them.
+     *
+     * @default {@link DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS}
+     */
+    readonly edgeMarginInPixels?: number;
+    /**
+     * The height of the band, in pixels — the same number {@link paintOutStatusBar} would paint.
+     */
+    readonly heightInPixels: number;
+    /**
+     * The frame's raw pixels, row-major, as `sharp`'s `raw()` reports them.
+     */
+    readonly pixels: Uint8Array;
+    /**
+     * How far above the band's bottom edge the row is read from, in pixels.
+     *
+     * The bar's own content stops short of the band's bottom edge, so the rows
+     * immediately under it are empty; this picks one of them.
+     *
+     * @default {@link DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS}
+     */
+    readonly sampleInsetInPixels?: number;
+    /**
+     * The frame's width, in pixels.
+     */
+    readonly widthInPixels: number;
+}
+/**
+ * A color read out of a frame, channel by channel.
+ *
+ * This package's own type rather than `sharp`'s, because it is part of the
+ * public surface and `sharp` is an OPTIONAL peer: a consumer that never installs
+ * it still names this. Structurally what `sharp`'s `background` takes, which is
+ * how the fill block is created from one with no conversion in between.
+ */
+export interface StatusBarBandColor {
+    /**
+     * The blue channel, 0-255.
+     */
+    readonly b: number;
+    /**
+     * The green channel, 0-255.
+     */
+    readonly g: number;
+    /**
+     * The red channel, 0-255.
+     */
+    readonly r: number;
+}
+/**
+ * What the row under the status bar's content turned out to hold.
+ *
+ * Verdict-as-data, like the compatibility and teardown checks: the reading and
+ * the throwing are separate, so a caller can ask what a frame looks like without
+ * having to catch an error to find out.
+ */
+export interface StatusBarBandVerdict {
+    /**
+     * The color the band would be filled with — read from the first scanned column of the sample row.
+     */
+    readonly backgroundColor: StatusBarBandColor;
+    /**
+     * How many distinct colors the scanned row holds. One is what an empty band looks like.
+     */
+    readonly distinctColorCount: number;
+    /**
+     * The color at {@link StatusBarBandVerdict.firstDifferentColumnXInPixels}, or `null` when the row is flat.
+     */
+    readonly firstDifferentColor: null | StatusBarBandColor;
+    /**
+     * The first scanned column that differs from {@link StatusBarBandVerdict.backgroundColor}, or `null` when the row is flat.
+     */
+    readonly firstDifferentColumnXInPixels: null | number;
+    /**
+     * Whether the row is one flat color, and so whether the band holds nothing but device chrome.
+     */
+    readonly isClear: boolean;
+    /**
+     * Which row was read, as a distance from the top of the frame in pixels.
+     */
+    readonly sampleRowYInPixels: number;
+}
+/**
+ * How far in from each edge the clear-of-chrome check reads, in pixels.
+ *
+ * Exported because a caller tightening or loosening it wants to say so relative
+ * to this rather than in the abstract.
+ */
+export declare const DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS = 100;
+/**
+ * How far above the band's bottom edge the sample row sits, in pixels.
+ *
+ * Four rows up: far enough to clear the bar's own content, close enough to still
+ * be inside the band on every device this has been measured on.
+ */
+export declare const DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS = 4;
+/**
+ * Builds the message a band that is not clear is refused with.
+ *
+ * Separate from the throwing so it can be asserted on directly: what makes this
+ * failure actionable is the measurement, not the wording around it.
+ *
+ * @param params - The verdict and the geometry it was read with.
+ * @returns The message, ready to throw.
+ */
+export declare function buildStatusBarBandFailureMessage(params: BuildStatusBarBandFailureMessageParams): string;
+/**
+ * Fills the status-bar band with the background behind it, so the frame carries no device chrome.
+ *
+ * The image keeps its dimensions exactly: the band is composited OVER the frame,
+ * never cropped off it, because a store listing expects a specific size and a
+ * cropped frame is a different picture.
+ *
+ * @param bytes - The device framebuffer, as `captureDeviceScreenshot` returned it.
+ * @param options - How tall the band is, and how the check reads it.
+ * @returns A {@link Promise} that resolves to the same frame with the band painted out, as PNG bytes.
+ * @throws Error if `sharp` is not installed, the band is as tall as the frame or taller, or the row under
+ *   the bar's content is not one flat color — see {@link buildStatusBarBandFailureMessage}.
+ */
+export declare function paintOutStatusBar(bytes: Uint8Array, options: PaintOutStatusBarOptions): Promise<Uint8Array>;
+/**
+ * Reads the row under the status bar's content and says whether the band is clear of the app.
+ *
+ * The band's height is a number a caller measured once, and a measured number
+ * can go stale — a taller status bar, or an Obsidian that draws higher, would
+ * have the capture quietly paint over the product. So the row just below the
+ * bar's own content is required to be one flat color all the way across: that
+ * is what an empty band looks like, and it is what the fill color is read from.
+ *
+ * @param params - The frame's raw pixels and the band's geometry.
+ * @returns What the scanned row holds.
+ * @throws Error if the geometry is degenerate — a non-positive dimension, a sample row above the top of
+ *   the frame, a margin that leaves nothing to scan, or a buffer too short to hold the row.
+ */
+export declare function resolveStatusBarBand(params: ResolveStatusBarBandParams): StatusBarBandVerdict;

package/dist/lib/esm/paint-out-status-bar.mjs

@@ -0,0 +1,142 @@
+import { importSharp } from "./sharp-loader.mjs";
+const DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS = 100;
+const DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS = 4;
+const BLUE_CHANNEL_OFFSET = 2;
+const FILL_CHANNEL_COUNT = 3;
+const GREEN_CHANNEL_OFFSET = 1;
+const MINIMUM_SCANNED_COLUMN_COUNT = 2;
+const RED_CHANNEL_OFFSET = 0;
+function buildStatusBarBandFailureMessage(params) {
+  const {
+    edgeMarginInPixels,
+    heightInPixels,
+    verdict,
+    widthInPixels
+  } = params;
+  const lines = [
+    `paintOutStatusBar: the row under the status bar holds more than one color, so a band of ${String(heightInPixels)}px would paint over the app rather than over the device.`,
+    `band=${String(heightInPixels)}px sampleRow=y${String(verdict.sampleRowYInPixels)} scanned x${String(edgeMarginInPixels)}..${String(widthInPixels - edgeMarginInPixels)} of ${String(widthInPixels)}px distinctColors=${String(verdict.distinctColorCount)}`,
+    `sampled ${formatColor(verdict.backgroundColor)}, but x=${String(verdict.firstDifferentColumnXInPixels)} is ${formatColor(verdict.firstDifferentColor)}`,
+    "A taller status bar, or an Obsidian that draws higher, both look like this. Measure the band on a fresh frame and pass the height you measured: enlarging it until the check passes is how a capture paints over the product."
+  ];
+  return lines.join("\n");
+}
+async function paintOutStatusBar(bytes, options) {
+  const { heightInPixels } = options;
+  const edgeMarginInPixels = options.edgeMarginInPixels ?? DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS;
+  const sharp = await importSharp("paintOutStatusBar");
+  const { data, info } = await sharp(bytes).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+  if (heightInPixels >= info.height) {
+    throw new Error(
+      `paintOutStatusBar: a band of ${String(heightInPixels)}px would cover a frame that is only ${String(info.height)}px tall. That is a measurement of some other device, not of this frame.`
+    );
+  }
+  const verdict = resolveStatusBarBand({
+    channelCount: info.channels,
+    edgeMarginInPixels,
+    heightInPixels,
+    pixels: data,
+    ...options.sampleInsetInPixels !== void 0 && { sampleInsetInPixels: options.sampleInsetInPixels },
+    widthInPixels: info.width
+  });
+  if (!verdict.isClear) {
+    throw new Error(buildStatusBarBandFailureMessage({
+      edgeMarginInPixels,
+      heightInPixels,
+      verdict,
+      widthInPixels: info.width
+    }));
+  }
+  const layer = {
+    input: {
+      create: {
+        background: verdict.backgroundColor,
+        channels: FILL_CHANNEL_COUNT,
+        height: heightInPixels,
+        width: info.width
+      }
+    },
+    left: 0,
+    top: 0
+  };
+  const painted = await sharp(bytes).composite([layer]).png().toBuffer();
+  return new Uint8Array(painted);
+}
+function resolveStatusBarBand(params) {
+  const {
+    channelCount,
+    heightInPixels,
+    pixels,
+    widthInPixels
+  } = params;
+  const edgeMarginInPixels = params.edgeMarginInPixels ?? DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS;
+  const sampleInsetInPixels = params.sampleInsetInPixels ?? DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS;
+  assertPositive("widthInPixels", widthInPixels);
+  assertPositive("heightInPixels", heightInPixels);
+  assertPositive("channelCount", channelCount);
+  const sampleRowYInPixels = heightInPixels - sampleInsetInPixels;
+  if (sampleRowYInPixels < 0) {
+    throw new Error(
+      `resolveStatusBarBand: a sample inset of ${String(sampleInsetInPixels)}px puts the sample row above the top of the frame for a band of ${String(heightInPixels)}px.`
+    );
+  }
+  const lastScannedColumnXInPixels = widthInPixels - edgeMarginInPixels;
+  if (lastScannedColumnXInPixels - edgeMarginInPixels < MINIMUM_SCANNED_COLUMN_COUNT) {
+    throw new Error(
+      `resolveStatusBarBand: an edge margin of ${String(edgeMarginInPixels)}px leaves fewer than ${String(MINIMUM_SCANNED_COLUMN_COUNT)} columns of a ${String(widthInPixels)}px frame to scan, which is a check that cannot fail.`
+    );
+  }
+  const rowStartOffset = sampleRowYInPixels * widthInPixels * channelCount;
+  const requiredLength = rowStartOffset + widthInPixels * channelCount;
+  if (pixels.length < requiredLength) {
+    throw new Error(
+      `resolveStatusBarBand: the frame holds ${String(pixels.length)} bytes, too few for row y${String(sampleRowYInPixels)} of a ${String(widthInPixels)}px-wide frame at ${String(channelCount)} channels, which needs ${String(requiredLength)}.`
+    );
+  }
+  const backgroundColor = readColor(pixels, rowStartOffset + edgeMarginInPixels * channelCount);
+  const backgroundKey = formatColor(backgroundColor);
+  const colorKeys = /* @__PURE__ */ new Set();
+  let firstDifferentColor = null;
+  let firstDifferentColumnXInPixels = null;
+  for (let x = edgeMarginInPixels; x < lastScannedColumnXInPixels; x++) {
+    const color = readColor(pixels, rowStartOffset + x * channelCount);
+    const colorKey = formatColor(color);
+    colorKeys.add(colorKey);
+    if (firstDifferentColumnXInPixels !== null || colorKey === backgroundKey) {
+      continue;
+    }
+    firstDifferentColor = color;
+    firstDifferentColumnXInPixels = x;
+  }
+  return {
+    backgroundColor,
+    distinctColorCount: colorKeys.size,
+    firstDifferentColor,
+    firstDifferentColumnXInPixels,
+    isClear: colorKeys.size === 1,
+    sampleRowYInPixels
+  };
+}
+function assertPositive(name, value) {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error(`resolveStatusBarBand: ${name} must be a positive number, got ${String(value)}.`);
+  }
+}
+function formatColor(color) {
+  return color === null ? "(none)" : `rgb(${String(color.r)},${String(color.g)},${String(color.b)})`;
+}
+function readColor(pixels, offset) {
+  return {
+    b: pixels[offset + BLUE_CHANNEL_OFFSET] ?? 0,
+    g: pixels[offset + GREEN_CHANNEL_OFFSET] ?? 0,
+    r: pixels[offset + RED_CHANNEL_OFFSET] ?? 0
+  };
+}
+export {
+  DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS,
+  DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS,
+  buildStatusBarBandFailureMessage,
+  paintOutStatusBar,
+  resolveStatusBarBand
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/paint-out-status-bar.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Paints the device's status bar out of a captured frame, so a device capture\n * can be committed.\n *\n * A framebuffer carries the status bar, and a status bar carries a wall clock, a\n * battery that charges while the emulator runs and a radio that comes and goes.\n * So re-running a capture suite on an unchanged tree rewrites its PNGs with\n * content nobody can commit, and the churn is invisible until someone diffs two\n * runs. `device-screenshot`'s header has always said a device capture is not\n * byte-reproducible; this is what makes one.\n *\n * **Pinning the bar was tried first, and is NOT sufficient \u2014 that finding is the\n * reason this helper exists rather than a `withSystemUiDemoMode` one.** SystemUI\n * demo mode (`sysui_demo_allowed`, plus one `com.android.systemui.demo`\n * broadcast per area: clock at a fixed `hhmm`, battery full and unplugged,\n * radios hidden, notification icons off) held the clock at `12:00` and two runs\n * still disagreed on **1823 full-contrast pixels**, because the bar's leading\n * group is laid out at a different offset between emulator boots \u2014\n * intermittently, roughly one boot in four. The Tuner's `icon_blacklist` does\n * not help either: demo mode draws its own icon layer and ignores it. Measured\n * on a real AVD across five paired capture runs for `obsidian-link-picker`'s\n * store frames, which is where this recipe was worked out before it moved here.\n *\n * Removing the band rather than pinning it also retires every device setting\n * that pinning needed, and nothing in a status bar is evidence about a plugin. A\n * listing frame without one is what a listing frame normally looks like.\n *\n * **The band's height is the caller's to measure, and there is deliberately no\n * default.** A wrong height does not fail loudly by itself \u2014 it paints over the\n * product. What stands between the two is {@link resolveStatusBarBand}: the row\n * just under the bar's own content must be one flat color all the way across,\n * which is what an empty band looks like and is also where the fill color is\n * sampled from. A taller bar, or an Obsidian that draws higher, fails the\n * capture instead.\n *\n * Compositing over a captured frame is not a new liberty: `labelScreenshot`\n * already draws the caption band across the bottom of the same image.\n */\n\nimport type { SharpCompositeLayer } from './sharp-loader.mjs';\n\nimport { importSharp } from './sharp-loader.mjs';\n\n/**\n * Parameters for {@link buildStatusBarBandFailureMessage}.\n */\nexport interface BuildStatusBarBandFailureMessageParams {\n  /**\n   * How far in from each edge the row was scanned, in pixels.\n   */\n  readonly edgeMarginInPixels: number;\n\n  /**\n   * The height of the band that was about to be painted, in pixels.\n   */\n  readonly heightInPixels: number;\n\n  /**\n   * The verdict being reported.\n   */\n  readonly verdict: StatusBarBandVerdict;\n\n  /**\n   * The frame's width, in pixels.\n   */\n  readonly widthInPixels: number;\n}\n\n/**\n * Options for {@link paintOutStatusBar}.\n */\nexport interface PaintOutStatusBarOptions {\n  /**\n   * How far in from each edge the clear-of-chrome check reads.\n   *\n   * @default {@link DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS}\n   */\n  readonly edgeMarginInPixels?: number;\n\n  /**\n   * How tall the device's status bar is, in framebuffer pixels.\n   *\n   * **Measured, never assumed, and deliberately without a default.** 24dp at a\n   * density of 320 is 48px, and that is one AVD's number rather than a constant\n   * of Android. Measure it on a frame: the bar's own content occupies the top\n   * rows, a few empty rows follow, and the app's top chrome starts at exactly\n   * this offset.\n   */\n  readonly heightInPixels: number;\n\n  /**\n   * How far above the band's bottom edge the fill color is sampled, in pixels.\n   *\n   * @default {@link DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS}\n   */\n  readonly sampleInsetInPixels?: number;\n}\n\n/**\n * Parameters for {@link resolveStatusBarBand}.\n */\nexport interface ResolveStatusBarBandParams {\n  /**\n   * How many bytes each pixel occupies in {@link ResolveStatusBarBandParams.pixels} \u2014 3 for RGB, 4 for RGBA.\n   */\n  readonly channelCount: number;\n\n  /**\n   * How far in from each edge to start reading, in pixels.\n   *\n   * A device's rounded corners darken a handful of pixels at both ends of every\n   * row in the band, constantly and harmlessly; the check is about what the APP\n   * draws, so it ignores them.\n   *\n   * @default {@link DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS}\n   */\n  readonly edgeMarginInPixels?: number;\n\n  /**\n   * The height of the band, in pixels \u2014 the same number {@link paintOutStatusBar} would paint.\n   */\n  readonly heightInPixels: number;\n\n  /**\n   * The frame's raw pixels, row-major, as `sharp`'s `raw()` reports them.\n   */\n  readonly pixels: Uint8Array;\n\n  /**\n   * How far above the band's bottom edge the row is read from, in pixels.\n   *\n   * The bar's own content stops short of the band's bottom edge, so the rows\n   * immediately under it are empty; this picks one of them.\n   *\n   * @default {@link DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS}\n   */\n  readonly sampleInsetInPixels?: number;\n\n  /**\n   * The frame's width, in pixels.\n   */\n  readonly widthInPixels: number;\n}\n\n/**\n * A color read out of a frame, channel by channel.\n *\n * This package's own type rather than `sharp`'s, because it is part of the\n * public surface and `sharp` is an OPTIONAL peer: a consumer that never installs\n * it still names this. Structurally what `sharp`'s `background` takes, which is\n * how the fill block is created from one with no conversion in between.\n */\nexport interface StatusBarBandColor {\n  /**\n   * The blue channel, 0-255.\n   */\n  readonly b: number;\n\n  /**\n   * The green channel, 0-255.\n   */\n  readonly g: number;\n\n  /**\n   * The red channel, 0-255.\n   */\n  readonly r: number;\n}\n\n/**\n * What the row under the status bar's content turned out to hold.\n *\n * Verdict-as-data, like the compatibility and teardown checks: the reading and\n * the throwing are separate, so a caller can ask what a frame looks like without\n * having to catch an error to find out.\n */\nexport interface StatusBarBandVerdict {\n  /**\n   * The color the band would be filled with \u2014 read from the first scanned column of the sample row.\n   */\n  readonly backgroundColor: StatusBarBandColor;\n\n  /**\n   * How many distinct colors the scanned row holds. One is what an empty band looks like.\n   */\n  readonly distinctColorCount: number;\n\n  /**\n   * The color at {@link StatusBarBandVerdict.firstDifferentColumnXInPixels}, or `null` when the row is flat.\n   */\n  readonly firstDifferentColor: null | StatusBarBandColor;\n\n  /**\n   * The first scanned column that differs from {@link StatusBarBandVerdict.backgroundColor}, or `null` when the row is flat.\n   */\n  readonly firstDifferentColumnXInPixels: null | number;\n\n  /**\n   * Whether the row is one flat color, and so whether the band holds nothing but device chrome.\n   */\n  readonly isClear: boolean;\n\n  /**\n   * Which row was read, as a distance from the top of the frame in pixels.\n   */\n  readonly sampleRowYInPixels: number;\n}\n\n/**\n * How far in from each edge the clear-of-chrome check reads, in pixels.\n *\n * Exported because a caller tightening or loosening it wants to say so relative\n * to this rather than in the abstract.\n */\nexport const DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS = 100;\n\n/**\n * How far above the band's bottom edge the sample row sits, in pixels.\n *\n * Four rows up: far enough to clear the bar's own content, close enough to still\n * be inside the band on every device this has been measured on.\n */\nexport const DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS = 4;\n\n/**\n * Byte offset of the blue channel within one pixel of a raw frame.\n */\nconst BLUE_CHANNEL_OFFSET = 2;\n\n/**\n * How many channels the fill block is created with \u2014 RGB, with no alpha, because it is opaque by construction.\n */\nconst FILL_CHANNEL_COUNT = 3;\n\n/**\n * Byte offset of the green channel within one pixel of a raw frame.\n */\nconst GREEN_CHANNEL_OFFSET = 1;\n\n/**\n * The fewest columns a meaningful scan can cover.\n *\n * One column is trivially flat, so a margin that leaves fewer than two is a\n * check that cannot fail \u2014 the exact shape this helper exists to avoid.\n */\nconst MINIMUM_SCANNED_COLUMN_COUNT = 2;\n\n/**\n * Byte offset of the red channel within one pixel of a raw frame.\n */\nconst RED_CHANNEL_OFFSET = 0;\n\n/**\n * Builds the message a band that is not clear is refused with.\n *\n * Separate from the throwing so it can be asserted on directly: what makes this\n * failure actionable is the measurement, not the wording around it.\n *\n * @param params - The verdict and the geometry it was read with.\n * @returns The message, ready to throw.\n */\nexport function buildStatusBarBandFailureMessage(params: BuildStatusBarBandFailureMessageParams): string {\n  const {\n    edgeMarginInPixels,\n    heightInPixels,\n    verdict,\n    widthInPixels\n  } = params;\n\n  const lines = [\n    'paintOutStatusBar: the row under the status bar holds more than one color, so a band of '\n    + `${String(heightInPixels)}px would paint over the app rather than over the device.`,\n    `band=${String(heightInPixels)}px sampleRow=y${String(verdict.sampleRowYInPixels)} `\n    + `scanned x${String(edgeMarginInPixels)}..${String(widthInPixels - edgeMarginInPixels)} `\n    + `of ${String(widthInPixels)}px distinctColors=${String(verdict.distinctColorCount)}`,\n    `sampled ${formatColor(verdict.backgroundColor)}, but x=${String(verdict.firstDifferentColumnXInPixels)} `\n    + `is ${formatColor(verdict.firstDifferentColor)}`,\n    'A taller status bar, or an Obsidian that draws higher, both look like this. Measure the band on a fresh '\n    + 'frame and pass the height you measured: enlarging it until the check passes is how a capture paints '\n    + 'over the product.'\n  ];\n\n  return lines.join('\\n');\n}\n\n/**\n * Fills the status-bar band with the background behind it, so the frame carries no device chrome.\n *\n * The image keeps its dimensions exactly: the band is composited OVER the frame,\n * never cropped off it, because a store listing expects a specific size and a\n * cropped frame is a different picture.\n *\n * @param bytes - The device framebuffer, as `captureDeviceScreenshot` returned it.\n * @param options - How tall the band is, and how the check reads it.\n * @returns A {@link Promise} that resolves to the same frame with the band painted out, as PNG bytes.\n * @throws Error if `sharp` is not installed, the band is as tall as the frame or taller, or the row under\n *   the bar's content is not one flat color \u2014 see {@link buildStatusBarBandFailureMessage}.\n */\nexport async function paintOutStatusBar(bytes: Uint8Array, options: PaintOutStatusBarOptions): Promise<Uint8Array> {\n  const { heightInPixels } = options;\n  const edgeMarginInPixels = options.edgeMarginInPixels ?? DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS;\n  const sharp = await importSharp('paintOutStatusBar');\n  const { data, info } = await sharp(bytes)\n    .ensureAlpha()\n    .raw()\n    .toBuffer({ resolveWithObject: true });\n\n  if (heightInPixels >= info.height) {\n    throw new Error(\n      `paintOutStatusBar: a band of ${String(heightInPixels)}px would cover a frame that is only `\n        + `${String(info.height)}px tall. That is a measurement of some other device, not of this frame.`\n    );\n  }\n\n  const verdict = resolveStatusBarBand({\n    channelCount: info.channels,\n    edgeMarginInPixels,\n    heightInPixels,\n    pixels: data,\n    ...(options.sampleInsetInPixels !== undefined && { sampleInsetInPixels: options.sampleInsetInPixels }),\n    widthInPixels: info.width\n  });\n\n  if (!verdict.isClear) {\n    throw new Error(buildStatusBarBandFailureMessage({\n      edgeMarginInPixels,\n      heightInPixels,\n      verdict,\n      widthInPixels: info.width\n    }));\n  }\n\n  const layer: SharpCompositeLayer = {\n    input: {\n      create: {\n        background: verdict.backgroundColor,\n        channels: FILL_CHANNEL_COUNT,\n        height: heightInPixels,\n        width: info.width\n      }\n    },\n    left: 0,\n    top: 0\n  };\n\n  const painted = await sharp(bytes)\n    .composite([layer])\n    .png()\n    .toBuffer();\n\n  return new Uint8Array(painted);\n}\n\n/**\n * Reads the row under the status bar's content and says whether the band is clear of the app.\n *\n * The band's height is a number a caller measured once, and a measured number\n * can go stale \u2014 a taller status bar, or an Obsidian that draws higher, would\n * have the capture quietly paint over the product. So the row just below the\n * bar's own content is required to be one flat color all the way across: that\n * is what an empty band looks like, and it is what the fill color is read from.\n *\n * @param params - The frame's raw pixels and the band's geometry.\n * @returns What the scanned row holds.\n * @throws Error if the geometry is degenerate \u2014 a non-positive dimension, a sample row above the top of\n *   the frame, a margin that leaves nothing to scan, or a buffer too short to hold the row.\n */\nexport function resolveStatusBarBand(params: ResolveStatusBarBandParams): StatusBarBandVerdict {\n  const {\n    channelCount,\n    heightInPixels,\n    pixels,\n    widthInPixels\n  } = params;\n  const edgeMarginInPixels = params.edgeMarginInPixels ?? DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS;\n  const sampleInsetInPixels = params.sampleInsetInPixels ?? DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS;\n\n  assertPositive('widthInPixels', widthInPixels);\n  assertPositive('heightInPixels', heightInPixels);\n  assertPositive('channelCount', channelCount);\n\n  const sampleRowYInPixels = heightInPixels - sampleInsetInPixels;\n\n  if (sampleRowYInPixels < 0) {\n    throw new Error(\n      `resolveStatusBarBand: a sample inset of ${String(sampleInsetInPixels)}px puts the sample row above the top `\n        + `of the frame for a band of ${String(heightInPixels)}px.`\n    );\n  }\n\n  const lastScannedColumnXInPixels = widthInPixels - edgeMarginInPixels;\n\n  if (lastScannedColumnXInPixels - edgeMarginInPixels < MINIMUM_SCANNED_COLUMN_COUNT) {\n    throw new Error(\n      `resolveStatusBarBand: an edge margin of ${String(edgeMarginInPixels)}px leaves fewer than `\n        + `${String(MINIMUM_SCANNED_COLUMN_COUNT)} columns of a ${String(widthInPixels)}px frame to scan, `\n        + 'which is a check that cannot fail.'\n    );\n  }\n\n  const rowStartOffset = sampleRowYInPixels * widthInPixels * channelCount;\n  const requiredLength = rowStartOffset + widthInPixels * channelCount;\n\n  if (pixels.length < requiredLength) {\n    throw new Error(\n      `resolveStatusBarBand: the frame holds ${String(pixels.length)} bytes, too few for row `\n        + `y${String(sampleRowYInPixels)} of a ${String(widthInPixels)}px-wide frame at `\n        + `${String(channelCount)} channels, which needs ${String(requiredLength)}.`\n    );\n  }\n\n  const backgroundColor = readColor(pixels, rowStartOffset + edgeMarginInPixels * channelCount);\n  const backgroundKey = formatColor(backgroundColor);\n  const colorKeys = new Set<string>();\n  let firstDifferentColor: null | StatusBarBandColor = null;\n  let firstDifferentColumnXInPixels: null | number = null;\n\n  for (let x = edgeMarginInPixels; x < lastScannedColumnXInPixels; x++) {\n    const color = readColor(pixels, rowStartOffset + x * channelCount);\n    const colorKey = formatColor(color);\n    colorKeys.add(colorKey);\n\n    if (firstDifferentColumnXInPixels !== null || colorKey === backgroundKey) {\n      continue;\n    }\n\n    firstDifferentColor = color;\n    firstDifferentColumnXInPixels = x;\n  }\n\n  return {\n    backgroundColor,\n    distinctColorCount: colorKeys.size,\n    firstDifferentColor,\n    firstDifferentColumnXInPixels,\n    isClear: colorKeys.size === 1,\n    sampleRowYInPixels\n  };\n}\n\n/**\n * Refuses a dimension that cannot describe a frame.\n *\n * @param name - The parameter being checked, so the message names it.\n * @param value - What was passed.\n * @throws Error if the value is not a positive finite number.\n */\nfunction assertPositive(name: string, value: number): void {\n  if (!Number.isFinite(value) || value <= 0) {\n    throw new Error(`resolveStatusBarBand: ${name} must be a positive number, got ${String(value)}.`);\n  }\n}\n\n/**\n * Renders a color as text, for comparison and for the diagnostic.\n *\n * The same rendering does both jobs on purpose: what a reader is shown is the\n * value the comparison was made on, rather than a re-formatting of it.\n *\n * @param color - The color, or `null` when there was none to report.\n * @returns The color as `rgb(r,g,b)`, or `(none)`.\n */\nfunction formatColor(color: null | StatusBarBandColor): string {\n  return color === null ? '(none)' : `rgb(${String(color.r)},${String(color.g)},${String(color.b)})`;\n}\n\n/**\n * Reads one pixel's color out of a raw frame, ignoring any alpha channel.\n *\n * @param pixels - The frame's raw bytes.\n * @param offset - The byte offset of the pixel.\n * @returns The color at that offset.\n */\nfunction readColor(pixels: Uint8Array, offset: number): StatusBarBandColor {\n  /* v8 ignore start -- The fallbacks are unreachable: every read is inside a row `resolveStatusBarBand` has already proved the buffer long enough to hold. They are here because an index read is typed `number | undefined`, not because a pixel can be missing. */\n  return {\n    b: pixels[offset + BLUE_CHANNEL_OFFSET] ?? 0,\n    g: pixels[offset + GREEN_CHANNEL_OFFSET] ?? 0,\n    r: pixels[offset + RED_CHANNEL_OFFSET] ?? 0\n  };\n  /* v8 ignore stop */\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/port-owner-query-verdict.d.mts

@@ -0,0 +1,161 @@
+/**
+ * @file
+ *
+ * Pure classification of the port-owner query — `netstat -ano` on Windows,
+ * `lsof -ti tcp:<port>` elsewhere — deciding, from how it ended, whether it
+ * **answered** or **failed**, and saying which failure in one line.
+ *
+ * The query is the only real escalation the Appium teardown has: the PID the
+ * harness holds is the `shell: true` wrapper it spawned, so what survives a kill
+ * is found by asking who still listens on the port (**L46**). It used to resolve
+ * an empty list for every error, which made three different endings one silent
+ * value:
+ *
+ * - `lsof` exiting 1 with nothing on either stream — which is how it says
+ *   nothing holds the port*, a legitimate empty answer;
+ * - the budget running out on a contended host;
+ * - the child dying.
+ *
+ * Only the first is an answer. The other two disarm the escalation exactly the
+ * way a silently failed process listing disarmed the emulator's
+ * (`host-process-query-verdict.ts`), so they are classified by the same rules
+ * and reported, not swallowed.
+ *
+ * **Why a module of its own rather than an option on the process-listing
+ * verdict.** The two queries disagree in two places, not one. Zero owners is a
+ * legitimate answer here, so `zero-rows` never applies; and `lsof`'s silent exit
+ * 1 means *nothing listens*, where for `tasklist` a silent non-zero exit is a
+ * crash. The failure branches themselves are delegated to
+ * {@link resolveHostQueryFailure}, so there is still one definition of
+ * `crashed`, `timed-out` and `refused`.
+ */
+import type { HostQueryFailure } from './host-process-query-verdict.mjs';
+/**
+ * Parameters for {@link buildPortOwnerQueryMessage}.
+ */
+export interface BuildPortOwnerQueryMessageParams {
+    /**
+    The command that was run, for the reader to try by hand — e.g. `netstat -ano`.
+     */
+    readonly command: string;
+    /**
+    How long the call took before it ended, in milliseconds.
+     */
+    readonly elapsedInMilliseconds: number;
+    /**
+    The child's exit code, when it exited rather than failing to start or being killed.
+     */
+    readonly exitCode: null | number;
+    /**
+    The verdict from {@link resolvePortOwnerQueryOutcome}.
+     */
+    readonly outcome: PortOwnerQueryOutcome;
+    /**
+    The port whose owners were asked for.
+     */
+    readonly port: number;
+    /**
+    The signal the child was killed with, when it was killed.
+     */
+    readonly signal: null | string;
+    /**
+    Whatever the child wrote to stderr.
+     */
+    readonly standardError: string;
+    /**
+    The budget the call was given, in milliseconds.
+     */
+    readonly timeoutInMilliseconds: number;
+}
+/**
+ * The fields {@link normalizeSyncExecError} extracts from an `execFileSync` throw.
+ */
+export interface NormalizedSyncExecError {
+    /**
+    The error code in `execFile`'s vocabulary: the numeric exit code, or a string such as `ENOENT` or `ERR_CHILD_PROCESS_STDIO_MAXBUFFER`.
+     */
+    readonly errorCode: null | number | string;
+    /**
+    The child's exit code, when it exited.
+     */
+    readonly exitCode: null | number;
+    /**
+    Whether the budget expired and the child was killed.
+     */
+    readonly isKilled: boolean;
+    /**
+    The signal the child was killed with.
+     */
+    readonly signal: null | string;
+    /**
+    Whatever the child wrote to stderr.
+     */
+    readonly standardError: string;
+    /**
+    Whatever the child wrote to stdout before it ended.
+     */
+    readonly standardOutput: string;
+}
+/**
+ * How the port-owner query ended.
+ *
+ * `answered` covers both a listener found and none found — the query succeeded
+ * either way. The rest are {@link resolveHostQueryFailure}'s failures.
+ */
+export type PortOwnerQueryOutcome = 'answered' | HostQueryFailure;
+/**
+ * Parameters for {@link resolvePortOwnerQueryOutcome}.
+ */
+export interface ResolvePortOwnerQueryOutcomeParams {
+    /**
+    `execFile`'s `error.code`: the numeric exit code, or a string like `ENOENT` when the child never ran.
+     */
+    readonly errorCode: null | number | string;
+    /**
+    Whether `execFile` reported an error at all.
+     */
+    readonly hasFailed: boolean;
+    /**
+    `execFile`'s `error.killed`: whether the budget expired and the child was killed.
+     */
+    readonly isKilled: boolean;
+    /**
+    The host platform, which decides whether a silent exit 1 is `lsof` saying *nothing listens*.
+     */
+    readonly platform: NodeJS.Platform;
+    /**
+    Whatever the child wrote to stderr.
+     */
+    readonly standardError: string;
+    /**
+    Whatever the child wrote to stdout.
+     */
+    readonly standardOutput: string;
+}
+/**
+ * Builds the single line the query logs for an outcome.
+ *
+ * @param params - The outcome plus the command, the port, the budget and what the child left behind.
+ * @returns The warning to log, or `undefined` when the query answered.
+ */
+export declare function buildPortOwnerQueryMessage(params: BuildPortOwnerQueryMessageParams): string | undefined;
+/**
+ * Extracts what an `execFileSync` throw carries, in `execFile`'s vocabulary.
+ *
+ * The synchronous API reports the same endings with different fields: an
+ * expired budget is `code: 'ETIMEDOUT'` rather than `killed: true`, an overrun
+ * buffer is `ENOBUFS`, and the exit code is `status` rather than `code`.
+ * Normalizing here lets the sync teardown classify with the same verdict as the
+ * async one.
+ *
+ * @param error - Whatever `execFileSync` threw.
+ * @returns The normalized fields; an unrecognizable throw reads as a crash with no evidence.
+ */
+export declare function normalizeSyncExecError(error: unknown): NormalizedSyncExecError;
+/**
+ * Decides how the port-owner query ended.
+ *
+ * @param params - What `execFile` reported, and the platform it ran on.
+ * @returns The outcome.
+ */
+export declare function resolvePortOwnerQueryOutcome(params: ResolvePortOwnerQueryOutcomeParams): PortOwnerQueryOutcome;