obsidian-integration-testing 16.0.0 → 17.0.1

package/dist/lib/cjs/paint-out-status-bar.cjs

@@ -0,0 +1,170 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var paint_out_status_bar_exports = {};
+__export(paint_out_status_bar_exports, {
+  DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS: () => DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS,
+  DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS: () => DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS,
+  buildStatusBarBandFailureMessage: () => buildStatusBarBandFailureMessage,
+  paintOutStatusBar: () => paintOutStatusBar,
+  resolveStatusBarBand: () => resolveStatusBarBand
+});
+module.exports = __toCommonJS(paint_out_status_bar_exports);
+var import_sharp_loader = require("./sharp-loader.cjs");
+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 (0, import_sharp_loader.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
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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.cjs';\n\nimport { importSharp } from './sharp-loader.cjs';\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/cjs/paint-out-status-bar.d.cts

@@ -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/cjs/port-owner-query-verdict.cjs

@@ -0,0 +1,94 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var port_owner_query_verdict_exports = {};
+__export(port_owner_query_verdict_exports, {
+  buildPortOwnerQueryMessage: () => buildPortOwnerQueryMessage,
+  normalizeSyncExecError: () => normalizeSyncExecError,
+  resolvePortOwnerQueryOutcome: () => resolvePortOwnerQueryOutcome
+});
+module.exports = __toCommonJS(port_owner_query_verdict_exports);
+var import_node_buffer = require("node:buffer");
+var import_host_process_query_verdict = require("./host-process-query-verdict.cjs");
+var import_type_guards = require("./type-guards.cjs");
+const LSOF_NOTHING_FOUND_EXIT_CODE = 1;
+function buildPortOwnerQueryMessage(params) {
+  const cost = `after ${(0, import_host_process_query_verdict.formatDuration)(params.elapsedInMilliseconds)}`;
+  const subject = `\`${params.command}\` (asking who listens on port ${String(params.port)})`;
+  const consequence = `Nothing is known about what still holds port ${String(params.port)}, so the escalation has no PID to kill \u2014 this is not the same as nothing holding it.`;
+  switch (params.outcome) {
+    case "answered": {
+      return void 0;
+    }
+    case "crashed": {
+      return `Warning: ${subject} died ${cost} without explaining itself (exit ${(0, import_host_process_query_verdict.formatExitCode)(params.exitCode)}, nothing on stderr). Suspect a crash or an interfering security product, and try the command by hand. ${consequence}`;
+    }
+    case "not-found": {
+      return `Warning: ${subject} could not be run at all ${cost}: the executable was not found on PATH. ${consequence}`;
+    }
+    case "output-overran": {
+      return `Warning: ${subject} produced more output ${cost} than the query's buffer allows, so none of it could be read. Raise the buffer. ${consequence}`;
+    }
+    case "refused": {
+      return `Warning: ${subject} refused the request ${cost} (exit ${(0, import_host_process_query_verdict.formatExitCode)(params.exitCode)}): ${(0, import_host_process_query_verdict.formatRefusal)(params.standardError)} ${consequence}`;
+    }
+    case "timed-out": {
+      return `Warning: ${subject} did not finish within its ${(0, import_host_process_query_verdict.formatDuration)(params.timeoutInMilliseconds)} budget and was killed ${cost}${params.signal === null ? "" : ` (${params.signal})`}. ${consequence}`;
+    }
+    default: {
+      return (0, import_type_guards.assertNever)(params.outcome);
+    }
+  }
+}
+function normalizeSyncExecError(error) {
+  const record = typeof error === "object" && error !== null ? error : {};
+  const code = typeof record["code"] === "string" ? record["code"] : void 0;
+  const status = typeof record["status"] === "number" ? record["status"] : null;
+  const signal = typeof record["signal"] === "string" ? record["signal"] : null;
+  const isKilled = code === "ETIMEDOUT";
+  let errorCode = status;
+  if (code === "ENOBUFS") {
+    errorCode = "ERR_CHILD_PROCESS_STDIO_MAXBUFFER";
+  } else if (code !== void 0 && !isKilled) {
+    errorCode = code;
+  }
+  return {
+    errorCode,
+    exitCode: status,
+    isKilled,
+    signal,
+    standardError: toText(record["stderr"]),
+    standardOutput: toText(record["stdout"])
+  };
+}
+function resolvePortOwnerQueryOutcome(params) {
+  return !params.hasFailed || params.platform !== "win32" && !params.isKilled && params.errorCode === LSOF_NOTHING_FOUND_EXIT_CODE && params.standardError.trim() === "" && params.standardOutput.trim() === "" ? "answered" : (0, import_host_process_query_verdict.resolveHostQueryFailure)(params);
+}
+function toText(stream) {
+  if (typeof stream === "string") {
+    return stream;
+  }
+  return import_node_buffer.Buffer.isBuffer(stream) ? stream.toString("utf-8") : "";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildPortOwnerQueryMessage,
+  normalizeSyncExecError,
+  resolvePortOwnerQueryOutcome
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/port-owner-query-verdict.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure classification of the port-owner query \u2014 `netstat -ano` on Windows,\n * `lsof -ti tcp:<port>` elsewhere \u2014 deciding, from how it ended, whether it\n * **answered** or **failed**, and saying which failure in one line.\n *\n * The query is the only real escalation the Appium teardown has: the PID the\n * harness holds is the `shell: true` wrapper it spawned, so what survives a kill\n * is found by asking who still listens on the port (**L46**). It used to resolve\n * an empty list for every error, which made three different endings one silent\n * value:\n *\n * - `lsof` exiting 1 with nothing on either stream \u2014 which is how it says\n *   nothing holds the port*, a legitimate empty answer;\n * - the budget running out on a contended host;\n * - the child dying.\n *\n * Only the first is an answer. The other two disarm the escalation exactly the\n * way a silently failed process listing disarmed the emulator's\n * (`host-process-query-verdict.ts`), so they are classified by the same rules\n * and reported, not swallowed.\n *\n * **Why a module of its own rather than an option on the process-listing\n * verdict.** The two queries disagree in two places, not one. Zero owners is a\n * legitimate answer here, so `zero-rows` never applies; and `lsof`'s silent exit\n * 1 means *nothing listens*, where for `tasklist` a silent non-zero exit is a\n * crash. The failure branches themselves are delegated to\n * {@link resolveHostQueryFailure}, so there is still one definition of\n * `crashed`, `timed-out` and `refused`.\n */\n\nimport { Buffer } from 'node:buffer';\n\nimport type { HostQueryFailure } from './host-process-query-verdict.cjs';\n\nimport {\n  formatDuration,\n  formatExitCode,\n  formatRefusal,\n  resolveHostQueryFailure\n} from './host-process-query-verdict.cjs';\nimport { assertNever } from './type-guards.cjs';\n\n/**\n * The exit code `lsof` uses for \"found nothing\", which it reports on neither stream.\n */\nconst LSOF_NOTHING_FOUND_EXIT_CODE = 1;\n\n/**\n * Parameters for {@link buildPortOwnerQueryMessage}.\n */\nexport interface BuildPortOwnerQueryMessageParams {\n  /**\n  The command that was run, for the reader to try by hand \u2014 e.g. `netstat -ano`.\n   */\n  readonly command: string;\n\n  /**\n  How long the call took before it ended, in milliseconds.\n   */\n  readonly elapsedInMilliseconds: number;\n\n  /**\n  The child's exit code, when it exited rather than failing to start or being killed.\n   */\n  readonly exitCode: null | number;\n\n  /**\n  The verdict from {@link resolvePortOwnerQueryOutcome}.\n   */\n  readonly outcome: PortOwnerQueryOutcome;\n\n  /**\n  The port whose owners were asked for.\n   */\n  readonly port: number;\n\n  /**\n  The signal the child was killed with, when it was killed.\n   */\n  readonly signal: null | string;\n\n  /**\n  Whatever the child wrote to stderr.\n   */\n  readonly standardError: string;\n\n  /**\n  The budget the call was given, in milliseconds.\n   */\n  readonly timeoutInMilliseconds: number;\n}\n\n/**\n * The fields {@link normalizeSyncExecError} extracts from an `execFileSync` throw.\n */\nexport interface NormalizedSyncExecError {\n  /**\n  The error code in `execFile`'s vocabulary: the numeric exit code, or a string such as `ENOENT` or `ERR_CHILD_PROCESS_STDIO_MAXBUFFER`.\n   */\n  readonly errorCode: null | number | string;\n\n  /**\n  The child's exit code, when it exited.\n   */\n  readonly exitCode: null | number;\n\n  /**\n  Whether the budget expired and the child was killed.\n   */\n  readonly isKilled: boolean;\n\n  /**\n  The signal the child was killed with.\n   */\n  readonly signal: null | string;\n\n  /**\n  Whatever the child wrote to stderr.\n   */\n  readonly standardError: string;\n\n  /**\n  Whatever the child wrote to stdout before it ended.\n   */\n  readonly standardOutput: string;\n}\n\n/**\n * How the port-owner query ended.\n *\n * `answered` covers both a listener found and none found \u2014 the query succeeded\n * either way. The rest are {@link resolveHostQueryFailure}'s failures.\n */\nexport type PortOwnerQueryOutcome = 'answered' | HostQueryFailure;\n\n/**\n * Parameters for {@link resolvePortOwnerQueryOutcome}.\n */\nexport interface ResolvePortOwnerQueryOutcomeParams {\n  /**\n  `execFile`'s `error.code`: the numeric exit code, or a string like `ENOENT` when the child never ran.\n   */\n  readonly errorCode: null | number | string;\n\n  /**\n  Whether `execFile` reported an error at all.\n   */\n  readonly hasFailed: boolean;\n\n  /**\n  `execFile`'s `error.killed`: whether the budget expired and the child was killed.\n   */\n  readonly isKilled: boolean;\n\n  /**\n  The host platform, which decides whether a silent exit 1 is `lsof` saying *nothing listens*.\n   */\n  readonly platform: NodeJS.Platform;\n\n  /**\n  Whatever the child wrote to stderr.\n   */\n  readonly standardError: string;\n\n  /**\n  Whatever the child wrote to stdout.\n   */\n  readonly standardOutput: string;\n}\n\n/**\n * Builds the single line the query logs for an outcome.\n *\n * @param params - The outcome plus the command, the port, the budget and what the child left behind.\n * @returns The warning to log, or `undefined` when the query answered.\n */\nexport function buildPortOwnerQueryMessage(params: BuildPortOwnerQueryMessageParams): string | undefined {\n  const cost = `after ${formatDuration(params.elapsedInMilliseconds)}`;\n  const subject = `\\`${params.command}\\` (asking who listens on port ${String(params.port)})`;\n  const consequence = `Nothing is known about what still holds port ${String(params.port)}, so the escalation has no PID to kill \u2014 this is not the same as nothing holding it.`;\n\n  switch (params.outcome) {\n    case 'answered': {\n      return undefined;\n    }\n    case 'crashed': {\n      return `Warning: ${subject} died ${cost} without explaining itself (exit ${formatExitCode(params.exitCode)}, nothing on stderr). Suspect a crash or an interfering security product, and try the command by hand. ${consequence}`;\n    }\n    case 'not-found': {\n      return `Warning: ${subject} could not be run at all ${cost}: the executable was not found on PATH. ${consequence}`;\n    }\n    case 'output-overran': {\n      return `Warning: ${subject} produced more output ${cost} than the query's buffer allows, so none of it could be read. Raise the buffer. ${consequence}`;\n    }\n    case 'refused': {\n      return `Warning: ${subject} refused the request ${cost} (exit ${formatExitCode(params.exitCode)}): ${formatRefusal(params.standardError)} ${consequence}`;\n    }\n    case 'timed-out': {\n      return `Warning: ${subject} did not finish within its ${formatDuration(params.timeoutInMilliseconds)} budget and was killed ${cost}${params.signal === null ? '' : ` (${params.signal})`}. ${consequence}`;\n    }\n    default: {\n      return assertNever(params.outcome);\n    }\n  }\n}\n\n/**\n * Extracts what an `execFileSync` throw carries, in `execFile`'s vocabulary.\n *\n * The synchronous API reports the same endings with different fields: an\n * expired budget is `code: 'ETIMEDOUT'` rather than `killed: true`, an overrun\n * buffer is `ENOBUFS`, and the exit code is `status` rather than `code`.\n * Normalizing here lets the sync teardown classify with the same verdict as the\n * async one.\n *\n * @param error - Whatever `execFileSync` threw.\n * @returns The normalized fields; an unrecognizable throw reads as a crash with no evidence.\n */\nexport function normalizeSyncExecError(error: unknown): NormalizedSyncExecError {\n  const record = typeof error === 'object' && error !== null ? error as Record<string, unknown> : {};\n  const code = typeof record['code'] === 'string' ? record['code'] : undefined;\n  const status = typeof record['status'] === 'number' ? record['status'] : null;\n  const signal = typeof record['signal'] === 'string' ? record['signal'] : null;\n  const isKilled = code === 'ETIMEDOUT';\n\n  let errorCode: null | number | string = status;\n  if (code === 'ENOBUFS') {\n    errorCode = 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER';\n  } else if (code !== undefined && !isKilled) {\n    errorCode = code;\n  }\n\n  return {\n    errorCode,\n    exitCode: status,\n    isKilled,\n    signal,\n    standardError: toText(record['stderr']),\n    standardOutput: toText(record['stdout'])\n  };\n}\n\n/**\n * Decides how the port-owner query ended.\n *\n * @param params - What `execFile` reported, and the platform it ran on.\n * @returns The outcome.\n */\nexport function resolvePortOwnerQueryOutcome(params: ResolvePortOwnerQueryOutcomeParams): PortOwnerQueryOutcome {\n  return !params.hasFailed || (params.platform !== 'win32'\n      && !params.isKilled\n      && params.errorCode === LSOF_NOTHING_FOUND_EXIT_CODE\n      && params.standardError.trim() === ''\n      && params.standardOutput.trim() === '')\n    ? 'answered'\n    : resolveHostQueryFailure(params);\n}\n\n/**\n * Reads a child's captured stream, whichever form `execFileSync` left it in.\n *\n * @param stream - A string, a `Buffer`, or nothing.\n * @returns The text, or an empty string.\n */\nfunction toText(stream: unknown): string {\n  if (typeof stream === 'string') {\n    return stream;\n  }\n\n  return Buffer.isBuffer(stream) ? stream.toString('utf-8') : '';\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgCA,yBAAuB;AAIvB,wCAKO;AACP,yBAA4B;AAK5B,MAAM,+BAA+B;AAmI9B,SAAS,2BAA2B,QAA8D;AACvG,QAAM,OAAO,aAAS,kDAAe,OAAO,qBAAqB,CAAC;AAClE,QAAM,UAAU,KAAK,OAAO,OAAO,kCAAkC,OAAO,OAAO,IAAI,CAAC;AACxF,QAAM,cAAc,gDAAgD,OAAO,OAAO,IAAI,CAAC;AAEvF,UAAQ,OAAO,SAAS;AAAA,IACtB,KAAK,YAAY;AACf,aAAO;AAAA,IACT;AAAA,IACA,KAAK,WAAW;AACd,aAAO,YAAY,OAAO,SAAS,IAAI,wCAAoC,kDAAe,OAAO,QAAQ,CAAC,0GAA0G,WAAW;AAAA,IACjO;AAAA,IACA,KAAK,aAAa;AAChB,aAAO,YAAY,OAAO,4BAA4B,IAAI,2CAA2C,WAAW;AAAA,IAClH;AAAA,IACA,KAAK,kBAAkB;AACrB,aAAO,YAAY,OAAO,yBAAyB,IAAI,mFAAmF,WAAW;AAAA,IACvJ;AAAA,IACA,KAAK,WAAW;AACd,aAAO,YAAY,OAAO,wBAAwB,IAAI,cAAU,kDAAe,OAAO,QAAQ,CAAC,UAAM,iDAAc,OAAO,aAAa,CAAC,IAAI,WAAW;AAAA,IACzJ;AAAA,IACA,KAAK,aAAa;AAChB,aAAO,YAAY,OAAO,kCAA8B,kDAAe,OAAO,qBAAqB,CAAC,0BAA0B,IAAI,GAAG,OAAO,WAAW,OAAO,KAAK,KAAK,OAAO,MAAM,GAAG,KAAK,WAAW;AAAA,IAC1M;AAAA,IACA,SAAS;AACP,iBAAO,gCAAY,OAAO,OAAO;AAAA,IACnC;AAAA,EACF;AACF;AAcO,SAAS,uBAAuB,OAAyC;AAC9E,QAAM,SAAS,OAAO,UAAU,YAAY,UAAU,OAAO,QAAmC,CAAC;AACjG,QAAM,OAAO,OAAO,OAAO,MAAM,MAAM,WAAW,OAAO,MAAM,IAAI;AACnE,QAAM,SAAS,OAAO,OAAO,QAAQ,MAAM,WAAW,OAAO,QAAQ,IAAI;AACzE,QAAM,SAAS,OAAO,OAAO,QAAQ,MAAM,WAAW,OAAO,QAAQ,IAAI;AACzE,QAAM,WAAW,SAAS;AAE1B,MAAI,YAAoC;AACxC,MAAI,SAAS,WAAW;AACtB,gBAAY;AAAA,EACd,WAAW,SAAS,UAAa,CAAC,UAAU;AAC1C,gBAAY;AAAA,EACd;AAEA,SAAO;AAAA,IACL;AAAA,IACA,UAAU;AAAA,IACV;AAAA,IACA;AAAA,IACA,eAAe,OAAO,OAAO,QAAQ,CAAC;AAAA,IACtC,gBAAgB,OAAO,OAAO,QAAQ,CAAC;AAAA,EACzC;AACF;AAQO,SAAS,6BAA6B,QAAmE;AAC9G,SAAO,CAAC,OAAO,aAAc,OAAO,aAAa,WAC1C,CAAC,OAAO,YACR,OAAO,cAAc,gCACrB,OAAO,cAAc,KAAK,MAAM,MAChC,OAAO,eAAe,KAAK,MAAM,KACpC,iBACA,2DAAwB,MAAM;AACpC;AAQA,SAAS,OAAO,QAAyB;AACvC,MAAI,OAAO,WAAW,UAAU;AAC9B,WAAO;AAAA,EACT;AAEA,SAAO,0BAAO,SAAS,MAAM,IAAI,OAAO,SAAS,OAAO,IAAI;AAC9D;",
  "names": []
}
