obsidian-integration-testing 15.0.0 → 17.0.0

package/dist/lib/esm/launched-device-selection.d.mts

@@ -0,0 +1,112 @@
+/**
+ * @file
+ *
+ * Pure selection of the device an emulator this run just launched produced.
+ *
+ * The wait used to take the first online device that was not listed before the
+ * launch. The "before" snapshot lists online devices only, so a handset that was
+ * `unauthorized`, `offline` or unplugged at that moment — and came online during
+ * the boot, which a USB reconnect or accepting the debugging prompt is enough
+ * for — looked new, and was adopted as the emulator:
+ *
+ * ```text
+ * AVD "obsidian_test" not found on any existing device, starting a new emulator...
+ * Waiting for a new device to appear in ADB ...
+ * Device 3C15BN001Y900000 appeared in ADB, waiting for boot to complete...
+ * Emulator "obsidian_test" started, device 3C15BN001Y900000 is connected (owned emulator PIDs: [])
+ * ```
+ *
+ * The suite then ran on the phone, and the emulator really launched was owned by
+ * nobody. So a new device is the launched emulator only when it is an emulator
+ * **and** it says it is serving the launched AVD — which also keeps a second
+ * emulator another project started concurrently from being adopted.
+ *
+ * Kept separate from the integration-only `transport-factory` so the decision is
+ * unit-testable; the factory does the `adb` round-trips.
+ */
+/**
+ * One new emulator device, with what it answered when asked for its AVD name.
+ */
+export interface LaunchedDeviceCandidate {
+    /**
+     * The device UDID, e.g. `emulator-5554`.
+     */
+    readonly deviceId: string;
+    /**
+     * The AVD the device reported, or `undefined` when it did not answer.
+     */
+    readonly probedAvdName: string | undefined;
+}
+/**
+ * The new devices a poll found, split by whether they can be the launched emulator.
+ */
+export interface NewDeviceSplit {
+    /**
+     * New emulator devices, to be asked which AVD they serve.
+     */
+    readonly emulatorDeviceIds: string[];
+    /**
+     * New devices that are not emulators (a handset, a TCP-attached device) and are never adopted.
+     */
+    readonly nonEmulatorDeviceIds: string[];
+}
+/**
+ * Parameters for {@link resolveLaunchedDevice}.
+ */
+export interface ResolveLaunchedDeviceParams {
+    /**
+     * The AVD this run launched.
+     */
+    readonly avdName: string;
+    /**
+     * The new emulator devices, with their probe answers.
+     */
+    readonly candidates: readonly LaunchedDeviceCandidate[];
+}
+/**
+ * What the probe answers say about the launched emulator's device.
+ */
+export interface ResolveLaunchedDeviceResult {
+    /**
+     * The device serving the launched AVD, or `undefined` when none does yet.
+     */
+    readonly deviceId: string | undefined;
+    /**
+     * Devices that answered with a different AVD: another emulator, never this run's.
+     */
+    readonly otherAvdDeviceIds: string[];
+    /**
+     * Devices that did not answer yet, to be asked again on the next poll.
+     */
+    readonly unansweredDeviceIds: string[];
+}
+/**
+ * Parameters for {@link splitNewDevices}.
+ */
+export interface SplitNewDevicesParams {
+    /**
+     * The devices online now.
+     */
+    readonly connectedDeviceIds: readonly string[];
+    /**
+     * The devices online before the launch.
+     */
+    readonly deviceIdsBefore: readonly string[];
+}
+/**
+ * Picks the new emulator device that serves the launched AVD.
+ *
+ * Silence is not a match: a device that did not answer is asked again, never adopted
+ * on the strength of being new.
+ *
+ * @param params - The launched AVD and the probed candidates.
+ * @returns The matching device, plus the ones ruled out and the ones still unknown.
+ */
+export declare function resolveLaunchedDevice(params: ResolveLaunchedDeviceParams): ResolveLaunchedDeviceResult;
+/**
+ * Splits the devices that were not online before the launch into emulators and everything else.
+ *
+ * @param params - The devices online now and before the launch.
+ * @returns The new devices, split.
+ */
+export declare function splitNewDevices(params: SplitNewDevicesParams): NewDeviceSplit;

package/dist/lib/esm/launched-device-selection.mjs

@@ -0,0 +1,21 @@
+import { checkIsEmulatorDeviceId } from "./avd-probe-verdict.mjs";
+function resolveLaunchedDevice(params) {
+  const match = params.candidates.find((candidate) => candidate.probedAvdName === params.avdName);
+  return {
+    deviceId: match?.deviceId,
+    otherAvdDeviceIds: params.candidates.filter((candidate) => candidate.probedAvdName !== void 0 && candidate.probedAvdName !== params.avdName).map((candidate) => candidate.deviceId),
+    unansweredDeviceIds: params.candidates.filter((candidate) => candidate.probedAvdName === void 0).map((candidate) => candidate.deviceId)
+  };
+}
+function splitNewDevices(params) {
+  const newDeviceIds = params.connectedDeviceIds.filter((deviceId) => !params.deviceIdsBefore.includes(deviceId));
+  return {
+    emulatorDeviceIds: newDeviceIds.filter((deviceId) => checkIsEmulatorDeviceId(deviceId)),
+    nonEmulatorDeviceIds: newDeviceIds.filter((deviceId) => !checkIsEmulatorDeviceId(deviceId))
+  };
+}
+export {
+  resolveLaunchedDevice,
+  splitNewDevices
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/library.mjs

@@ -1,4 +1,4 @@
-const LIBRARY_VERSION = false ? "dev" : "15.0.0";
+const LIBRARY_VERSION = false ? "dev" : "17.0.0";
 export {
   LIBRARY_VERSION
 };

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": []
}
