obsidian-integration-testing 15.0.0 → 17.0.0

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


package/dist/lib/cjs/port-owner-query-verdict.d.cts

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

package/dist/lib/cjs/resolve-emulator-device-id.cjs

@@ -23,7 +23,9 @@ __export(resolve_emulator_device_id_exports, {
 module.exports = __toCommonJS(resolve_emulator_device_id_exports);
 var import_adb_device_list = require("./adb-device-list.cjs");
 var import_adb = require("./adb.cjs");
+var import_avd_name_channel = require("./avd-name-channel.cjs");
 var import_emulator_device_id = require("./emulator-device-id.cjs");
+var import_emulator_reclaim = require("./emulator-reclaim.cjs");
 const EMULATOR_DEVICE_ID_PREFIX = "emulator-";
 async function resolveEmulatorDeviceId(params) {
   const candidates = await listEmulatorDeviceCandidates();
@@ -41,14 +43,35 @@ async function listEmulatorDeviceCandidates() {
   const deviceIds = (0, import_adb_device_list.listOnlineDeviceIds)(devicesOutput).filter((deviceId) => deviceId.startsWith(EMULATOR_DEVICE_ID_PREFIX));
   const candidates = [];
   for (const deviceId of deviceIds) {
-    const output = await (0, import_adb.runAdbText)({ commandArguments: ["emu", "avd", "name"], deviceId });
-    const avdName = output.split("\n", 1)[0]?.trim() ?? "";
-    candidates.push({ avdName, deviceId });
+    candidates.push({ avdName: await probeAvdName(deviceId), deviceId });
   }
   return candidates;
 }
+async function probeAvdName(deviceId) {
+  let channel = import_avd_name_channel.FIRST_AVD_NAME_CHANNEL;
+  while (channel !== void 0) {
+    let didChannelRespond = true;
+    let reportedAvdName = "";
+    try {
+      reportedAvdName = (0, import_avd_name_channel.parseAvdNameAnswer)(
+        await (0, import_adb.runAdbText)({
+          commandArguments: (0, import_avd_name_channel.buildAvdNameChannelCommand)(channel),
+          deviceId,
+          timeoutInMilliseconds: import_emulator_reclaim.ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS
+        })
+      );
+    } catch {
+      didChannelRespond = false;
+    }
+    if (reportedAvdName.length > 0) {
+      return reportedAvdName;
+    }
+    channel = (0, import_avd_name_channel.resolveNextAvdNameChannel)({ channel, didChannelRespond });
+  }
+  return "";
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   resolveEmulatorDeviceId
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/resolve-emulator-device-id.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Asks the running emulators which AVD each was started from, and resolves one\n * by name through {@link ./emulator-device-id.ts}'s selection.\n *\n * Every function here shells out, so the whole module is integration-time code\n * \u2014 which is exactly why the selection it delegates to lives in its own module\n * and stays unit-tested.\n */\n\n/* v8 ignore start -- Integration-time code (shells out to a real device) covered by integration tests, not unit tests. */\n\nimport type { AvdNameChannel } from './avd-name-channel.cjs';\nimport type { EmulatorDeviceCandidate } from './emulator-device-id.cjs';\n\nimport { listOnlineDeviceIds } from './adb-device-list.cjs';\nimport {\n  runAdbText,\n  runAdbTextWithoutDevice\n} from './adb.cjs';\nimport {\n  buildAvdNameChannelCommand,\n  FIRST_AVD_NAME_CHANNEL,\n  parseAvdNameAnswer,\n  resolveNextAvdNameChannel\n} from './avd-name-channel.cjs';\nimport { selectEmulatorDeviceId } from './emulator-device-id.cjs';\nimport { ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS } from './emulator-reclaim.cjs';\n\n/**\n * Parameters for {@link resolveEmulatorDeviceId}.\n */\nexport interface ResolveEmulatorDeviceIdParams {\n  /**\n   * The AVD name to match, e.g. `obsidian_screenshots`.\n   */\n  readonly avdName: string;\n}\n\n/**\n * The prefix `adb devices` gives an emulator, as opposed to a physically attached device.\n */\nconst EMULATOR_DEVICE_ID_PREFIX = 'emulator-';\n\n/**\n * Finds the running emulator whose AVD is the named one.\n *\n * @param params - The AVD to match.\n * @returns A {@link Promise} that resolves to the device UDID to address it by.\n * @throws Error if no running emulator was started from that AVD. The message lists what IS running, since\n *   \"the wrong emulator is up\" and \"no emulator is up\" need different answers.\n */\nexport async function resolveEmulatorDeviceId(params: ResolveEmulatorDeviceIdParams): Promise<string> {\n  const candidates = await listEmulatorDeviceCandidates();\n  const deviceId = selectEmulatorDeviceId({ avdName: params.avdName, candidates });\n\n  if (!deviceId) {\n    const listed = candidates.map((candidate) => `${candidate.deviceId} (${candidate.avdName})`).join(', ') || 'none';\n    throw new Error(\n      `resolveEmulatorDeviceId: no running emulator for AVD \"${params.avdName}\". Running emulators: ${listed}. `\n        + 'Start it, or run this project once to have the harness start it.'\n    );\n  }\n\n  return deviceId;\n}\n\n/**\n * Asks every online emulator which AVD it was started from.\n *\n * **A device that will not identify itself is listed with an empty name, not\n * thrown over.** It is somebody else's wedged emulator far more often than it is\n * this caller's, and failing the whole lookup over it is precisely the\n * machine-wide interlock `avd-name-channel.ts` exists to undo \u2014 the wanted\n * emulator, sitting right beside it and answering perfectly, is still found.\n *\n * @returns A {@link Promise} that resolves to one entry per running emulator.\n */\nasync function listEmulatorDeviceCandidates(): Promise<EmulatorDeviceCandidate[]> {\n  const devicesOutput = await runAdbTextWithoutDevice(['devices']);\n  const deviceIds = listOnlineDeviceIds(devicesOutput).filter((deviceId) => deviceId.startsWith(EMULATOR_DEVICE_ID_PREFIX));\n\n  const candidates: EmulatorDeviceCandidate[] = [];\n  for (const deviceId of deviceIds) {\n    candidates.push({ avdName: await probeAvdName(deviceId), deviceId });\n  }\n\n  return candidates;\n}\n\n/**\n * Asks one emulator which AVD it was started from, over each channel in turn.\n *\n * The guest property comes first because it travels `adbd` \u2014 the channel this\n * lookup needs anyway \u2014 while the console is a separate port that wedges on its\n * own; see `avd-name-channel.ts`. Every call is bounded, so one unresponsive\n * device costs a timeout rather than the whole lookup.\n *\n * @param deviceId - The emulator to ask.\n * @returns A {@link Promise} that resolves to the AVD name, or `''` when no channel identified it.\n */\nasync function probeAvdName(deviceId: string): Promise<string> {\n  let channel: AvdNameChannel | undefined = FIRST_AVD_NAME_CHANNEL;\n\n  while (channel !== undefined) {\n    let didChannelRespond = true;\n    let reportedAvdName = '';\n\n    try {\n      reportedAvdName = parseAvdNameAnswer(\n        await runAdbText({\n          commandArguments: buildAvdNameChannelCommand(channel),\n          deviceId,\n          timeoutInMilliseconds: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS\n        })\n      );\n    } catch {\n      didChannelRespond = false;\n    }\n\n    if (reportedAvdName.length > 0) {\n      return reportedAvdName;\n    }\n\n    channel = resolveNextAvdNameChannel({ channel, didChannelRespond });\n  }\n\n  return '';\n}\n\n/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBA,6BAAoC;AACpC,iBAGO;AACP,8BAKO;AACP,gCAAuC;AACvC,8BAAyD;AAezD,MAAM,4BAA4B;AAUlC,eAAsB,wBAAwB,QAAwD;AACpG,QAAM,aAAa,MAAM,6BAA6B;AACtD,QAAM,eAAW,kDAAuB,EAAE,SAAS,OAAO,SAAS,WAAW,CAAC;AAE/E,MAAI,CAAC,UAAU;AACb,UAAM,SAAS,WAAW,IAAI,CAAC,cAAc,GAAG,UAAU,QAAQ,KAAK,UAAU,OAAO,GAAG,EAAE,KAAK,IAAI,KAAK;AAC3G,UAAM,IAAI;AAAA,MACR,yDAAyD,OAAO,OAAO,yBAAyB,MAAM;AAAA,IAExG;AAAA,EACF;AAEA,SAAO;AACT;AAaA,eAAe,+BAAmE;AAChF,QAAM,gBAAgB,UAAM,oCAAwB,CAAC,SAAS,CAAC;AAC/D,QAAM,gBAAY,4CAAoB,aAAa,EAAE,OAAO,CAAC,aAAa,SAAS,WAAW,yBAAyB,CAAC;AAExH,QAAM,aAAwC,CAAC;AAC/C,aAAW,YAAY,WAAW;AAChC,eAAW,KAAK,EAAE,SAAS,MAAM,aAAa,QAAQ,GAAG,SAAS,CAAC;AAAA,EACrE;AAEA,SAAO;AACT;AAaA,eAAe,aAAa,UAAmC;AAC7D,MAAI,UAAsC;AAE1C,SAAO,YAAY,QAAW;AAC5B,QAAI,oBAAoB;AACxB,QAAI,kBAAkB;AAEtB,QAAI;AACF,4BAAkB;AAAA,QAChB,UAAM,uBAAW;AAAA,UACf,sBAAkB,oDAA2B,OAAO;AAAA,UACpD;AAAA,UACA,uBAAuB;AAAA,QACzB,CAAC;AAAA,MACH;AAAA,IACF,QAAQ;AACN,0BAAoB;AAAA,IACtB;AAEA,QAAI,gBAAgB,SAAS,GAAG;AAC9B,aAAO;AAAA,IACT;AAEA,kBAAU,mDAA0B,EAAE,SAAS,kBAAkB,CAAC;AAAA,EACpE;AAEA,SAAO;AACT;",
  "names": []
}


package/dist/lib/cjs/sharp-loader.cjs

@@ -47,4 +47,4 @@ async function importSharp(caller) {
 0 && (module.exports = {
   importSharp
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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