obsidian-integration-testing 16.0.0 → 17.0.0

package/dist/lib/cjs/enable-plugin.d.cts

@@ -49,7 +49,9 @@ export interface EnablePluginResult {
  *
  * Monkey-patches `app.plugins.loadPlugin` to intercept errors before
  * Obsidian's `enablePlugin` try-catch swallows them. The original method
- * is always restored in a `finally` block.
+ * is restored in a `finally` block — but only while the patch this function
+ * installed is still the one in place, so a plugin that patched the same slot
+ * during its own load keeps its patch.
  *
  * Designed to be passed as the `callback` argument to {@link evalInObsidian}.
  *

package/dist/lib/cjs/host-process-query-verdict.cjs

@@ -0,0 +1,103 @@
+"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 host_process_query_verdict_exports = {};
+__export(host_process_query_verdict_exports, {
+  buildHostProcessQueryMessage: () => buildHostProcessQueryMessage,
+  formatDuration: () => formatDuration,
+  formatExitCode: () => formatExitCode,
+  formatRefusal: () => formatRefusal,
+  resolveHostProcessQueryOutcome: () => resolveHostProcessQueryOutcome,
+  resolveHostQueryFailure: () => resolveHostQueryFailure
+});
+module.exports = __toCommonJS(host_process_query_verdict_exports);
+var import_type_guards = require("./type-guards.cjs");
+const NTSTATUS_FAILURE_FLOOR = 3221225472;
+const HEXADECIMAL_RADIX = 16;
+const MILLISECONDS_PER_SECOND = 1e3;
+function buildHostProcessQueryMessage(params) {
+  const cost = `after ${formatDuration(params.elapsedInMilliseconds)}`;
+  const consequence = params.consequence ?? "Teardown falls back to `adb devices` alone and has no PID to escalate to.";
+  switch (params.outcome) {
+    case "crashed": {
+      return `Warning: \`${params.command}\` died ${cost} without explaining itself (exit ${formatExitCode(params.exitCode)}, nothing on stderr, ${String(params.partialRowCount)} process(es) listed) \u2014 it did not refuse the request, since it always explains a refusal on stderr. Suspect a crash or an interfering security product, and try the command by hand. ${consequence}`;
+    }
+    case "listed": {
+      return void 0;
+    }
+    case "not-found": {
+      return `Warning: \`${params.command}\` could not be run at all ${cost}: the executable was not found on PATH. ${consequence}`;
+    }
+    case "output-overran": {
+      return `Warning: \`${params.command}\` produced more output ${cost} than the listing's buffer allows, so none of it could be read. Raise the buffer. ${consequence}`;
+    }
+    case "refused": {
+      return `Warning: \`${params.command}\` refused the request ${cost} (exit ${formatExitCode(params.exitCode)}): ${formatRefusal(params.standardError)} ${consequence}`;
+    }
+    case "timed-out": {
+      return `Warning: \`${params.command}\` did not finish within its ${formatDuration(params.timeoutInMilliseconds)} budget and was killed ${cost}${params.signal === null ? "" : ` (${params.signal})`}, having listed ${String(params.partialRowCount)} process(es) by then \u2014 so it was working, not refusing, and the budget is what ran out. The partial listing is discarded rather than used: the owned set is a *difference* between two listings, and a truncated one on either side would both miss a process this run owns and claim one it does not. ${consequence}`;
+    }
+    case "zero-rows": {
+      return `Warning: \`${params.command}\` exited cleanly ${cost} but its output parsed to no processes and carried no no-match notice \u2014 a whole-host listing cannot be empty on a running host, and a filtered one says so when nothing matches. Treating it as a failed query. ${consequence}`;
+    }
+    default: {
+      return (0, import_type_guards.assertNever)(params.outcome);
+    }
+  }
+}
+function formatDuration(durationInMilliseconds) {
+  return durationInMilliseconds < MILLISECONDS_PER_SECOND ? `${String(durationInMilliseconds)}ms` : `${(durationInMilliseconds / MILLISECONDS_PER_SECOND).toFixed(1)}s`;
+}
+function formatExitCode(exitCode) {
+  if (exitCode === null) {
+    return "unknown";
+  }
+  return exitCode >= NTSTATUS_FAILURE_FLOOR ? `0x${exitCode.toString(HEXADECIMAL_RADIX).toUpperCase()}` : String(exitCode);
+}
+function formatRefusal(standardError) {
+  const refusal = standardError.trim();
+  return refusal.endsWith(".") ? refusal : `${refusal}.`;
+}
+function resolveHostProcessQueryOutcome(params) {
+  if (!params.hasFailed) {
+    return params.rowCount === 0 && !params.hasReportedNoMatch ? "zero-rows" : "listed";
+  }
+  return resolveHostQueryFailure(params);
+}
+function resolveHostQueryFailure(params) {
+  if (params.errorCode === "ENOENT") {
+    return "not-found";
+  }
+  if (params.errorCode === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER") {
+    return "output-overran";
+  }
+  if (params.isKilled) {
+    return "timed-out";
+  }
+  return params.standardError.trim() === "" ? "crashed" : "refused";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildHostProcessQueryMessage,
+  formatDuration,
+  formatExitCode,
+  formatRefusal,
+  resolveHostProcessQueryOutcome,
+  resolveHostQueryFailure
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/host-process-query-verdict.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure classification of the host process listing \u2014 deciding, from how\n * `tasklist` / `ps` ended, *which* way it failed, and saying so in one line.\n *\n * The listing is what names the emulator backend a run owns, and therefore the\n * only PID teardown can escalate to (**L56**). It is best-effort by design: a\n * listing that cannot be produced yields no PIDs rather than failing the run.\n * What it must never be is **unexplained**, and for three weeks it was:\n *\n * ```text\n * Warning: could not list host processes (`tasklist`): Command failed: tasklist /FO CSV /NH\n *\n * Warning: `tasklist` listed no processes.\n * ```\n *\n * Two defects in four lines. The pair is *contradictory* \u2014 the first says the\n * command failed, the second says it ran and found nothing \u2014 and they were\n * emitted together for a single failure, because a failed call resolves `''`\n * and an empty string parses to zero rows. `zero-rows` exists to catch a\n * listing that succeeded and yet returned nothing, which on a real host can\n * only be a failed query; it is not a second opinion on a call that already\n * reported an error.\n *\n * And the surviving diagnostic is `error.message` alone, which for `execFile`\n * is `Command failed: <cmd>\\n<stderr>` \u2014 so the log carried the command back\n * to the reader and threw away everything that identifies the failure:\n * `error.code`, `error.killed`, `error.signal`, and how long the call took.\n * Measured 2026-09-23 on this host, that discarded evidence is decisive:\n *\n * - `tasklist` **always** writes `ERROR: <reason>` to stderr when it objects \u2014\n *   a bad filter, an unreachable host \u2014 and exits 1. So a non-zero exit with\n *   **empty** stderr is not `tasklist` refusing; it is the host killing the\n *   child, and `crashed` says so.\n * - The exact spawn the harness makes succeeds 39 times out of 39 from an idle\n *   Node process (0.6-4.3s, 26 KB, ~530 rows, against a 30s budget and an 8 MB\n *   ceiling). So \"the spawn is wrong\" \u2014 a missing shell, a PATH the child did\n *   not inherit, an undersized buffer \u2014 is ruled out: each has its **own** message\n *   (`spawn tasklist ENOENT`, `stdout maxBuffer length exceeded`), and none of\n *   them is the one observed.\n * - Under an emulator boot the same call inflates to ~9x its idle cost, which\n *   is the contention `HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS` is sized\n *   for and the failure the old line could not distinguish from a crash.\n *\n * This is the same fault `avd-probe-verdict.ts` was written for \u2014 a probe that\n * discarded its error, leaving \"never answered\" indistinguishable from \"the\n * answer is no\" \u2014 and it is fixed the same way: classify, name the\n * consequence, and keep the classification pure so it is unit-testable while\n * the `execFile` glue stays in the integration-only caller.\n */\n\nimport { assertNever } from './type-guards.cjs';\n\n/**\n * The lowest exit code Windows reserves for an `NTSTATUS` failure.\n *\n * A child killed by the OS \u2014 an access violation, a stack overflow \u2014 exits with\n * its `NTSTATUS` as the code, and `0xC0000005` is unreadable in decimal\n * (`3221225477`). Codes at or above this are therefore reported in hex, which\n * is the only form a reader can look up.\n */\nconst NTSTATUS_FAILURE_FLOOR = 0xC0_00_00_00;\n\n/**\n * The base an `NTSTATUS` exit code is rendered in.\n */\nconst HEXADECIMAL_RADIX = 16;\n\n/**\n * Milliseconds in a second, for rendering a duration.\n */\nconst MILLISECONDS_PER_SECOND = 1000;\n\n/**\n * Parameters for {@link buildHostProcessQueryMessage}.\n */\nexport interface BuildHostProcessQueryMessageParams {\n  /**\n  The command that was run, for the reader to try by hand \u2014 e.g. `tasklist /FO CSV /NH`.\n   */\n  readonly command: string;\n\n  /**\n  What the failure costs the caller, closing the line. Defaults to the teardown consequence, which is what the harness's own listing loses; the wedge probe states what *it* loses instead.\n   */\n  readonly consequence?: string | undefined;\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 resolveHostProcessQueryOutcome}.\n   */\n  readonly outcome: HostProcessQueryOutcome;\n\n  /**\n  How many processes the output parsed to \u2014 the *partial* listing on a failure, which is the evidence that the command was working when it died.\n   */\n  readonly partialRowCount: 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 \u2014 quoted for `refused`, and the emptiness that identifies `crashed`.\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 * How the host process listing ended.\n *\n * `listed` is the only success. The rest are distinct failures on purpose: they\n * need different fixes, and the line they used to share named none of them.\n */\nexport type HostProcessQueryOutcome = 'listed' | 'zero-rows' | HostQueryFailure;\n\n/**\n * The ways a host query can fail, shared by every query that classifies its ending.\n */\nexport type HostQueryFailure = 'crashed' | 'not-found' | 'output-overran' | 'refused' | 'timed-out';\n\n/**\n * Parameters for {@link resolveHostProcessQueryOutcome}.\n */\nexport interface ResolveHostProcessQueryOutcomeParams {\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  Whether a **filtered** query affirmatively reported that nothing matched (`checkIsNoMatchReported`) \u2014 the one way an empty answer is an answer.\n   */\n  readonly hasReportedNoMatch: 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  How many processes the output parsed to.\n   */\n  readonly rowCount: number;\n\n  /**\n  Whatever the child wrote to stderr.\n   */\n  readonly standardError: string;\n}\n\n/**\n * Parameters for {@link resolveHostQueryFailure}.\n */\nexport type ResolveHostQueryFailureParams = Pick<ResolveHostProcessQueryOutcomeParams, 'errorCode' | 'isKilled' | 'standardError'>;\n\n/**\n * Builds the single line the listing logs for an outcome.\n *\n * One line, never two: the contradictory pair in this file's header is the\n * defect this replaces. `listed` has nothing to report, so it returns\n * `undefined` rather than a cheerful line on the hot path.\n *\n * @param params - The outcome plus the command, the budget and what the child left behind.\n * @returns The warning to log, or `undefined` when the listing succeeded.\n */\nexport function buildHostProcessQueryMessage(params: BuildHostProcessQueryMessageParams): string | undefined {\n  const cost = `after ${formatDuration(params.elapsedInMilliseconds)}`;\n  const consequence = params.consequence ?? 'Teardown falls back to `adb devices` alone and has no PID to escalate to.';\n\n  switch (params.outcome) {\n    case 'crashed': {\n      return `Warning: \\`${params.command}\\` died ${cost} without explaining itself (exit ${formatExitCode(params.exitCode)}, nothing on stderr, ${String(params.partialRowCount)} process(es) listed) \u2014 it did not refuse the request, since it always explains a refusal on stderr. Suspect a crash or an interfering security product, and try the command by hand. ${consequence}`;\n    }\n    case 'listed': {\n      return undefined;\n    }\n    case 'not-found': {\n      return `Warning: \\`${params.command}\\` could not be run at all ${cost}: the executable was not found on PATH. ${consequence}`;\n    }\n    case 'output-overran': {\n      return `Warning: \\`${params.command}\\` produced more output ${cost} than the listing's buffer allows, so none of it could be read. Raise the buffer. ${consequence}`;\n    }\n    case 'refused': {\n      return `Warning: \\`${params.command}\\` refused the request ${cost} (exit ${formatExitCode(params.exitCode)}): ${formatRefusal(params.standardError)} ${consequence}`;\n    }\n    case 'timed-out': {\n      return `Warning: \\`${params.command}\\` did not finish within its ${formatDuration(params.timeoutInMilliseconds)} budget and was killed ${cost}${params.signal === null ? '' : ` (${params.signal})`}, having listed ${String(params.partialRowCount)} process(es) by then \u2014 so it was working, not refusing, and the budget is what ran out. The partial listing is discarded rather than used: the owned set is a *difference* between two listings, and a truncated one on either side would both miss a process this run owns and claim one it does not. ${consequence}`;\n    }\n    case 'zero-rows': {\n      return `Warning: \\`${params.command}\\` exited cleanly ${cost} but its output parsed to no processes and carried no no-match notice \u2014 a whole-host listing cannot be empty on a running host, and a filtered one says so when nothing matches. Treating it as a failed query. ${consequence}`;\n    }\n    default: {\n      return assertNever(params.outcome);\n    }\n  }\n}\n\n/**\n * Renders a millisecond duration for a log line.\n *\n * @param durationInMilliseconds - The duration.\n * @returns Whole milliseconds under a second, and seconds to one decimal above it.\n */\nexport function formatDuration(durationInMilliseconds: number): string {\n  return durationInMilliseconds < MILLISECONDS_PER_SECOND\n    ? `${String(durationInMilliseconds)}ms`\n    : `${(durationInMilliseconds / MILLISECONDS_PER_SECOND).toFixed(1)}s`;\n}\n\n/**\n * Renders a child's exit code, in the base a reader can look it up in.\n *\n * @param exitCode - The exit code, or `null` when the child was killed before exiting.\n * @returns The code in hex when it is an `NTSTATUS` failure, in decimal otherwise.\n */\nexport function formatExitCode(exitCode: null | number): string {\n  if (exitCode === null) {\n    return 'unknown';\n  }\n\n  return exitCode >= NTSTATUS_FAILURE_FLOOR ? `0x${exitCode.toString(HEXADECIMAL_RADIX).toUpperCase()}` : String(exitCode);\n}\n\n/**\n * Renders what the command said when it refused, as one sentence.\n *\n * `tasklist` ends its own `ERROR: \u2026` with a period and a `\\r\\r\\n`, so quoting it\n * verbatim and adding the sentence break this line needs produced `recognized..`\n * \u2014 the terminator is supplied only when the tool did not supply one.\n *\n * @param standardError - Whatever the child wrote to stderr.\n * @returns The refusal, trimmed, ending in exactly one period.\n */\nexport function formatRefusal(standardError: string): string {\n  const refusal = standardError.trim();\n\n  return refusal.endsWith('.') ? refusal : `${refusal}.`;\n}\n\n/**\n * Decides how the listing ended, from what `execFile` reported.\n *\n * The order of the branches is the order of specificity: the two failures Node\n * names itself (`ENOENT`, the buffer ceiling) are recognized before the ones\n * that have to be inferred from the child's exit, and `crashed` is last\n * because it is defined by the *absence* of an explanation on stderr.\n *\n * @param params - What `execFile` reported, and how many rows the output parsed to.\n * @returns The outcome.\n */\nexport function resolveHostProcessQueryOutcome(params: ResolveHostProcessQueryOutcomeParams): HostProcessQueryOutcome {\n  if (!params.hasFailed) {\n    /*\n     * A host always has processes, so a whole-host listing that parses to nothing is a failed query however it\n     * exited. A filtered one may legitimately match nothing \u2014 but only when it says so; silence is still a failure.\n     */\n    return params.rowCount === 0 && !params.hasReportedNoMatch ? 'zero-rows' : 'listed';\n  }\n\n  return resolveHostQueryFailure(params);\n}\n\n/**\n * Decides which way a host query that **did** fail failed.\n *\n * Split out of {@link resolveHostProcessQueryOutcome} so a sibling query whose\n * success rules differ \u2014 the port-owner query, where zero owners is an answer \u2014\n * can share one definition of each failure without inheriting `listed` and\n * `zero-rows`.\n *\n * @param params - What `execFile` reported for the failed call.\n * @returns The failure outcome.\n */\nexport function resolveHostQueryFailure(params: ResolveHostQueryFailureParams): HostQueryFailure {\n  if (params.errorCode === 'ENOENT') {\n    return 'not-found';\n  }\n\n  if (params.errorCode === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER') {\n    return 'output-overran';\n  }\n\n  if (params.isKilled) {\n    return 'timed-out';\n  }\n\n  // `tasklist` and `ps` both explain a refusal on stderr, so silence means the child never got to object.\n  return params.standardError.trim() === '' ? 'crashed' : 'refused';\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAoDA,yBAA4B;AAU5B,MAAM,yBAAyB;AAK/B,MAAM,oBAAoB;AAK1B,MAAM,0BAA0B;AAmHzB,SAAS,6BAA6B,QAAgE;AAC3G,QAAM,OAAO,SAAS,eAAe,OAAO,qBAAqB,CAAC;AAClE,QAAM,cAAc,OAAO,eAAe;AAE1C,UAAQ,OAAO,SAAS;AAAA,IACtB,KAAK,WAAW;AACd,aAAO,cAAc,OAAO,OAAO,WAAW,IAAI,oCAAoC,eAAe,OAAO,QAAQ,CAAC,wBAAwB,OAAO,OAAO,eAAe,CAAC,6LAAwL,WAAW;AAAA,IAChX;AAAA,IACA,KAAK,UAAU;AACb,aAAO;AAAA,IACT;AAAA,IACA,KAAK,aAAa;AAChB,aAAO,cAAc,OAAO,OAAO,8BAA8B,IAAI,2CAA2C,WAAW;AAAA,IAC7H;AAAA,IACA,KAAK,kBAAkB;AACrB,aAAO,cAAc,OAAO,OAAO,2BAA2B,IAAI,qFAAqF,WAAW;AAAA,IACpK;AAAA,IACA,KAAK,WAAW;AACd,aAAO,cAAc,OAAO,OAAO,0BAA0B,IAAI,UAAU,eAAe,OAAO,QAAQ,CAAC,MAAM,cAAc,OAAO,aAAa,CAAC,IAAI,WAAW;AAAA,IACpK;AAAA,IACA,KAAK,aAAa;AAChB,aAAO,cAAc,OAAO,OAAO,gCAAgC,eAAe,OAAO,qBAAqB,CAAC,0BAA0B,IAAI,GAAG,OAAO,WAAW,OAAO,KAAK,KAAK,OAAO,MAAM,GAAG,mBAAmB,OAAO,OAAO,eAAe,CAAC,+SAA0S,WAAW;AAAA,IAC3iB;AAAA,IACA,KAAK,aAAa;AAChB,aAAO,cAAc,OAAO,OAAO,qBAAqB,IAAI,wNAAmN,WAAW;AAAA,IAC5R;AAAA,IACA,SAAS;AACP,iBAAO,gCAAY,OAAO,OAAO;AAAA,IACnC;AAAA,EACF;AACF;AAQO,SAAS,eAAe,wBAAwC;AACrE,SAAO,yBAAyB,0BAC5B,GAAG,OAAO,sBAAsB,CAAC,OACjC,IAAI,yBAAyB,yBAAyB,QAAQ,CAAC,CAAC;AACtE;AAQO,SAAS,eAAe,UAAiC;AAC9D,MAAI,aAAa,MAAM;AACrB,WAAO;AAAA,EACT;AAEA,SAAO,YAAY,yBAAyB,KAAK,SAAS,SAAS,iBAAiB,EAAE,YAAY,CAAC,KAAK,OAAO,QAAQ;AACzH;AAYO,SAAS,cAAc,eAA+B;AAC3D,QAAM,UAAU,cAAc,KAAK;AAEnC,SAAO,QAAQ,SAAS,GAAG,IAAI,UAAU,GAAG,OAAO;AACrD;AAaO,SAAS,+BAA+B,QAAuE;AACpH,MAAI,CAAC,OAAO,WAAW;AAKrB,WAAO,OAAO,aAAa,KAAK,CAAC,OAAO,qBAAqB,cAAc;AAAA,EAC7E;AAEA,SAAO,wBAAwB,MAAM;AACvC;AAaO,SAAS,wBAAwB,QAAyD;AAC/F,MAAI,OAAO,cAAc,UAAU;AACjC,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,cAAc,qCAAqC;AAC5D,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,UAAU;AACnB,WAAO;AAAA,EACT;AAGA,SAAO,OAAO,cAAc,KAAK,MAAM,KAAK,YAAY;AAC1D;",
  "names": []
}


package/dist/lib/cjs/host-process-query-verdict.d.cts

@@ -0,0 +1,196 @@
+/**
+ * @file
+ *
+ * Pure classification of the host process listing — deciding, from how
+ * `tasklist` / `ps` ended, *which* way it failed, and saying so in one line.
+ *
+ * The listing is what names the emulator backend a run owns, and therefore the
+ * only PID teardown can escalate to (**L56**). It is best-effort by design: a
+ * listing that cannot be produced yields no PIDs rather than failing the run.
+ * What it must never be is **unexplained**, and for three weeks it was:
+ *
+ * ```text
+ * Warning: could not list host processes (`tasklist`): Command failed: tasklist /FO CSV /NH
+ *
+ * Warning: `tasklist` listed no processes.
+ * ```
+ *
+ * Two defects in four lines. The pair is *contradictory* — the first says the
+ * command failed, the second says it ran and found nothing — and they were
+ * emitted together for a single failure, because a failed call resolves `''`
+ * and an empty string parses to zero rows. `zero-rows` exists to catch a
+ * listing that succeeded and yet returned nothing, which on a real host can
+ * only be a failed query; it is not a second opinion on a call that already
+ * reported an error.
+ *
+ * And the surviving diagnostic is `error.message` alone, which for `execFile`
+ * is `Command failed: <cmd>\n<stderr>` — so the log carried the command back
+ * to the reader and threw away everything that identifies the failure:
+ * `error.code`, `error.killed`, `error.signal`, and how long the call took.
+ * Measured 2026-09-23 on this host, that discarded evidence is decisive:
+ *
+ * - `tasklist` **always** writes `ERROR: <reason>` to stderr when it objects —
+ *   a bad filter, an unreachable host — and exits 1. So a non-zero exit with
+ *   **empty** stderr is not `tasklist` refusing; it is the host killing the
+ *   child, and `crashed` says so.
+ * - The exact spawn the harness makes succeeds 39 times out of 39 from an idle
+ *   Node process (0.6-4.3s, 26 KB, ~530 rows, against a 30s budget and an 8 MB
+ *   ceiling). So "the spawn is wrong" — a missing shell, a PATH the child did
+ *   not inherit, an undersized buffer — is ruled out: each has its **own** message
+ *   (`spawn tasklist ENOENT`, `stdout maxBuffer length exceeded`), and none of
+ *   them is the one observed.
+ * - Under an emulator boot the same call inflates to ~9x its idle cost, which
+ *   is the contention `HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS` is sized
+ *   for and the failure the old line could not distinguish from a crash.
+ *
+ * This is the same fault `avd-probe-verdict.ts` was written for — a probe that
+ * discarded its error, leaving "never answered" indistinguishable from "the
+ * answer is no" — and it is fixed the same way: classify, name the
+ * consequence, and keep the classification pure so it is unit-testable while
+ * the `execFile` glue stays in the integration-only caller.
+ */
+/**
+ * Parameters for {@link buildHostProcessQueryMessage}.
+ */
+export interface BuildHostProcessQueryMessageParams {
+    /**
+    The command that was run, for the reader to try by hand — e.g. `tasklist /FO CSV /NH`.
+     */
+    readonly command: string;
+    /**
+    What the failure costs the caller, closing the line. Defaults to the teardown consequence, which is what the harness's own listing loses; the wedge probe states what *it* loses instead.
+     */
+    readonly consequence?: string | undefined;
+    /**
+    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 resolveHostProcessQueryOutcome}.
+     */
+    readonly outcome: HostProcessQueryOutcome;
+    /**
+    How many processes the output parsed to — the *partial* listing on a failure, which is the evidence that the command was working when it died.
+     */
+    readonly partialRowCount: number;
+    /**
+    The signal the child was killed with, when it was killed.
+     */
+    readonly signal: null | string;
+    /**
+    Whatever the child wrote to stderr — quoted for `refused`, and the emptiness that identifies `crashed`.
+     */
+    readonly standardError: string;
+    /**
+    The budget the call was given, in milliseconds.
+     */
+    readonly timeoutInMilliseconds: number;
+}
+/**
+ * How the host process listing ended.
+ *
+ * `listed` is the only success. The rest are distinct failures on purpose: they
+ * need different fixes, and the line they used to share named none of them.
+ */
+export type HostProcessQueryOutcome = 'listed' | 'zero-rows' | HostQueryFailure;
+/**
+ * The ways a host query can fail, shared by every query that classifies its ending.
+ */
+export type HostQueryFailure = 'crashed' | 'not-found' | 'output-overran' | 'refused' | 'timed-out';
+/**
+ * Parameters for {@link resolveHostProcessQueryOutcome}.
+ */
+export interface ResolveHostProcessQueryOutcomeParams {
+    /**
+    `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;
+    /**
+    Whether a **filtered** query affirmatively reported that nothing matched (`checkIsNoMatchReported`) — the one way an empty answer is an answer.
+     */
+    readonly hasReportedNoMatch: boolean;
+    /**
+    `execFile`'s `error.killed`: whether the budget expired and the child was killed.
+     */
+    readonly isKilled: boolean;
+    /**
+    How many processes the output parsed to.
+     */
+    readonly rowCount: number;
+    /**
+    Whatever the child wrote to stderr.
+     */
+    readonly standardError: string;
+}
+/**
+ * Parameters for {@link resolveHostQueryFailure}.
+ */
+export type ResolveHostQueryFailureParams = Pick<ResolveHostProcessQueryOutcomeParams, 'errorCode' | 'isKilled' | 'standardError'>;
+/**
+ * Builds the single line the listing logs for an outcome.
+ *
+ * One line, never two: the contradictory pair in this file's header is the
+ * defect this replaces. `listed` has nothing to report, so it returns
+ * `undefined` rather than a cheerful line on the hot path.
+ *
+ * @param params - The outcome plus the command, the budget and what the child left behind.
+ * @returns The warning to log, or `undefined` when the listing succeeded.
+ */
+export declare function buildHostProcessQueryMessage(params: BuildHostProcessQueryMessageParams): string | undefined;
+/**
+ * Renders a millisecond duration for a log line.
+ *
+ * @param durationInMilliseconds - The duration.
+ * @returns Whole milliseconds under a second, and seconds to one decimal above it.
+ */
+export declare function formatDuration(durationInMilliseconds: number): string;
+/**
+ * Renders a child's exit code, in the base a reader can look it up in.
+ *
+ * @param exitCode - The exit code, or `null` when the child was killed before exiting.
+ * @returns The code in hex when it is an `NTSTATUS` failure, in decimal otherwise.
+ */
+export declare function formatExitCode(exitCode: null | number): string;
+/**
+ * Renders what the command said when it refused, as one sentence.
+ *
+ * `tasklist` ends its own `ERROR: …` with a period and a `\r\r\n`, so quoting it
+ * verbatim and adding the sentence break this line needs produced `recognized..`
+ * — the terminator is supplied only when the tool did not supply one.
+ *
+ * @param standardError - Whatever the child wrote to stderr.
+ * @returns The refusal, trimmed, ending in exactly one period.
+ */
+export declare function formatRefusal(standardError: string): string;
+/**
+ * Decides how the listing ended, from what `execFile` reported.
+ *
+ * The order of the branches is the order of specificity: the two failures Node
+ * names itself (`ENOENT`, the buffer ceiling) are recognized before the ones
+ * that have to be inferred from the child's exit, and `crashed` is last
+ * because it is defined by the *absence* of an explanation on stderr.
+ *
+ * @param params - What `execFile` reported, and how many rows the output parsed to.
+ * @returns The outcome.
+ */
+export declare function resolveHostProcessQueryOutcome(params: ResolveHostProcessQueryOutcomeParams): HostProcessQueryOutcome;
+/**
+ * Decides which way a host query that **did** fail failed.
+ *
+ * Split out of {@link resolveHostProcessQueryOutcome} so a sibling query whose
+ * success rules differ — the port-owner query, where zero owners is an answer —
+ * can share one definition of each failure without inheriting `listed` and
+ * `zero-rows`.
+ *
+ * @param params - What `execFile` reported for the failed call.
+ * @returns The failure outcome.
+ */
+export declare function resolveHostQueryFailure(params: ResolveHostQueryFailureParams): HostQueryFailure;

package/dist/lib/cjs/index.cjs

@@ -27,6 +27,8 @@ __export(index_exports, {
   DEFAULT_EVAL_CAP_IN_MILLISECONDS: () => import_eval_cap.DEFAULT_EVAL_CAP_IN_MILLISECONDS,
   DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS: () => import_soft_keyboard_geometry.DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,
   DEFAULT_OBSIDIAN_VERSION_SPECS: () => import_version_matrix.DEFAULT_OBSIDIAN_VERSION_SPECS,
+  DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS: () => import_paint_out_status_bar.DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS,
+  DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS: () => import_paint_out_status_bar.DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS,
   DesktopCdpTransport: () => import_transport_desktop_cdp.DesktopCdpTransport,
   DesktopOnlyPluginSkipError: () => import_desktop_only_plugin_skip_error.DesktopOnlyPluginSkipError,
   DeviceSettingNamespace: () => import_device_settings_command.DeviceSettingNamespace,
@@ -49,8 +51,10 @@ __export(index_exports, {
   buildDeviceSettingsCommandArguments: () => import_device_settings_command.buildDeviceSettingsCommandArguments,
   buildLabelSvg: () => import_label_screenshot.buildLabelSvg,
   buildSoftKeyboardDiagnosticMessage: () => import_soft_keyboard_geometry.buildSoftKeyboardDiagnosticMessage,
+  buildStatusBarBandFailureMessage: () => import_paint_out_status_bar.buildStatusBarBandFailureMessage,
   captureDeviceScreenshot: () => import_device_screenshot.captureDeviceScreenshot,
   captureObsidianScreenshot: () => import_capture_obsidian_screenshot.captureObsidianScreenshot,
+  checkIsInputMethodShown: () => import_soft_keyboard_geometry.checkIsInputMethodShown,
   checkIsMobileTransport: () => import_transport_options.checkIsMobileTransport,
   checkIsSoftKeyboardUp: () => import_soft_keyboard_geometry.checkIsSoftKeyboardUp,
   computeFitToCanvas: () => import_fit_screenshot.computeFitToCanvas,
@@ -70,6 +74,7 @@ __export(index_exports, {
   labelScreenshot: () => import_label_screenshot.labelScreenshot,
   measureLabelCaption: () => import_label_screenshot.measureLabelCaption,
   openObsidianSettingsTab: () => import_open_obsidian_settings_tab.openObsidianSettingsTab,
+  paintOutStatusBar: () => import_paint_out_status_bar.paintOutStatusBar,
   parseInputMethodState: () => import_soft_keyboard_geometry.parseInputMethodState,
   pollInObsidian: () => import_poll_in_obsidian.pollInObsidian,
   raiseSoftKeyboard: () => import_soft_keyboard.raiseSoftKeyboard,
@@ -85,6 +90,7 @@ __export(index_exports, {
   resolveInstallerCompatibility: () => import_installer_compatibility.resolveInstallerCompatibility,
   resolveMissingInjectedPlugins: () => import_demo_vault_populate.resolveMissingInjectedPlugins,
   resolveSoftKeyboardTapPoints: () => import_soft_keyboard_geometry.resolveSoftKeyboardTapPoints,
+  resolveStatusBarBand: () => import_paint_out_status_bar.resolveStatusBarBand,
   restoreAppConfig: () => import_app_config.restoreAppConfig,
   runAdbBinary: () => import_adb.runAdbBinary,
   runAdbText: () => import_adb.runAdbText,
@@ -137,6 +143,7 @@ var import_obsidian_metadata = require("./obsidian-metadata.cjs");
 var import_obsidian_version = require("./obsidian-version.cjs");
 var import_open_obsidian_settings_tab = require("./open-obsidian-settings-tab.cjs");
 var import_owned_instance_exited_error = require("./owned-instance-exited-error.cjs");
+var import_paint_out_status_bar = require("./paint-out-status-bar.cjs");
 var import_poll_in_obsidian = require("./poll-in-obsidian.cjs");
 var import_renderer_failed_to_initialize_error = require("./renderer-failed-to-initialize-error.cjs");
 var import_resolve_emulator_device_id = require("./resolve-emulator-device-id.cjs");
@@ -163,6 +170,8 @@ var import_version_matrix = require("./version-matrix.cjs");
   DEFAULT_EVAL_CAP_IN_MILLISECONDS,
   DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,
   DEFAULT_OBSIDIAN_VERSION_SPECS,
+  DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS,
+  DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS,
   DesktopCdpTransport,
   DesktopOnlyPluginSkipError,
   DeviceSettingNamespace,
@@ -185,8 +194,10 @@ var import_version_matrix = require("./version-matrix.cjs");
   buildDeviceSettingsCommandArguments,
   buildLabelSvg,
   buildSoftKeyboardDiagnosticMessage,
+  buildStatusBarBandFailureMessage,
   captureDeviceScreenshot,
   captureObsidianScreenshot,
+  checkIsInputMethodShown,
   checkIsMobileTransport,
   checkIsSoftKeyboardUp,
   computeFitToCanvas,
@@ -206,6 +217,7 @@ var import_version_matrix = require("./version-matrix.cjs");
   labelScreenshot,
   measureLabelCaption,
   openObsidianSettingsTab,
+  paintOutStatusBar,
   parseInputMethodState,
   pollInObsidian,
   raiseSoftKeyboard,
@@ -221,6 +233,7 @@ var import_version_matrix = require("./version-matrix.cjs");
   resolveInstallerCompatibility,
   resolveMissingInjectedPlugins,
   resolveSoftKeyboardTapPoints,
+  resolveStatusBarBand,
   restoreAppConfig,
   runAdbBinary,
   runAdbText,
@@ -237,4 +250,4 @@ var import_version_matrix = require("./version-matrix.cjs");
   withSoftKeyboardEnabled,
   writeDeviceSetting
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/index.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains the entry point for the integration testing module.\n */\n\nexport type { RunAdbParams } from './adb.cjs';\nexport {\n  runAdbBinary,\n  runAdbText,\n  runAdbTextWithoutDevice\n} from './adb.cjs';\nexport type {\n  AppConfigRestore,\n  GetAppConfigParams,\n  SetAppConfigParams,\n  WithAppConfigParams\n} from './app-config.cjs';\nexport {\n  getAppConfig,\n  restoreAppConfig,\n  setAppConfig,\n  withAppConfig\n} from './app-config.cjs';\nexport type {\n  AsarFallback,\n  AsarFallbackTier,\n  ResolveAsarFallbackParams\n} from './asar-fallback-detection.cjs';\nexport { resolveAsarFallback } from './asar-fallback-detection.cjs';\nexport type { CaptureObsidianScreenshotOptions } from './capture-obsidian-screenshot.cjs';\nexport { captureObsidianScreenshot } from './capture-obsidian-screenshot.cjs';\nexport type {\n  CaptureScreenshotParams,\n  PngDimensions\n} from './capture-screenshot.cjs';\nexport {\n  buildDeviceMetricsOverride,\n  decodeBase64Png,\n  isPng,\n  readPngDimensions\n} from './capture-screenshot.cjs';\nexport type { CdpCommandTimeoutErrorConstructorParams } from './cdp-command-timeout-error.cjs';\nexport { CdpCommandTimeoutError } from './cdp-command-timeout-error.cjs';\nexport type { ConfigDirectoryFallbackErrorConstructorParams } from './config-directory-fallback-error.cjs';\nexport { ConfigDirectoryFallbackError } from './config-directory-fallback-error.cjs';\nexport {\n  assertValidConfigDirectory,\n  DEFAULT_CONFIG_DIRECTORY\n} from './config-directory.cjs';\nexport type {\n  CdpConnection,\n  ConnectToCdpOptions\n} from './connect-to-cdp.cjs';\nexport { connectToCdp } from './connect-to-cdp.cjs';\nexport type {\n  ContextArguments,\n  ContextOf\n} from './context-id.cjs';\nexport { ContextId } from './context-id.cjs';\nexport type {\n  SetupErrorResolver,\n  TransportOptionsResolver,\n  VaultPathResolver\n} from './context-provider.cjs';\nexport {\n  setSetupErrorResolver,\n  setTransportOptionsResolver,\n  setVaultPathResolver\n} from './context-provider.cjs';\nexport type {\n  BootstrapDemoVaultPluginsParams,\n  BootstrapDemoVaultPluginsResult,\n  BuildDemoVaultPopulateAsyncParams,\n  InstalledPluginInfo\n} from './demo-vault-bootstrap.cjs';\nexport {\n  bootstrapDemoVaultPlugins,\n  buildDemoVaultPopulateAsync\n} from './demo-vault-bootstrap.cjs';\nexport type {\n  BuildDemoVaultPopulateParams,\n  InjectPluginParams,\n  ResolveMissingInjectedPluginsParams\n} from './demo-vault-populate.cjs';\nexport {\n  buildDemoVaultPopulate,\n  resolveMissingInjectedPlugins\n} from './demo-vault-populate.cjs';\nexport type { ReadDemoVaultTreeParams } from './demo-vault-tree.cjs';\nexport { readDemoVaultTree } from './demo-vault-tree.cjs';\nexport { DesktopOnlyPluginSkipError } from './desktop-only-plugin-skip-error.cjs';\nexport type { CaptureDeviceScreenshotParams } from './device-screenshot.cjs';\nexport { captureDeviceScreenshot } from './device-screenshot.cjs';\nexport type {\n  DeviceSettingRestore,\n  DeviceSettingRestoreDelete,\n  DeviceSettingRestoreWrite\n} from './device-setting-restore.cjs';\nexport {\n  DeviceSettingRestoreKind,\n  resolveDeviceSettingRestore\n} from './device-setting-restore.cjs';\nexport type { BuildDeviceSettingsCommandArgumentsParams } from './device-settings-command.cjs';\nexport {\n  buildDeviceSettingsCommandArguments,\n  DeviceSettingNamespace,\n  DeviceSettingVerb\n} from './device-settings-command.cjs';\nexport type {\n  DeviceSettingParams,\n  WithSoftKeyboardEnabledParams,\n  WriteDeviceSettingParams\n} from './device-settings.cjs';\nexport {\n  deleteDeviceSetting,\n  readDeviceSetting,\n  withSoftKeyboardEnabled,\n  writeDeviceSetting\n} from './device-settings.cjs';\nexport type {\n  ElectronCompatibility,\n  ElectronCompatibilityTier,\n  ResolveElectronCompatibilityParams\n} from './electron-compatibility.cjs';\nexport { resolveElectronCompatibility } from './electron-compatibility.cjs';\nexport type {\n  EmulatorDeviceCandidate,\n  SelectEmulatorDeviceIdParams\n} from './emulator-device-id.cjs';\nexport { selectEmulatorDeviceId } from './emulator-device-id.cjs';\nexport type { EvalCapExceededErrorConstructorParams } from './eval-cap-exceeded-error.cjs';\nexport {\n  EvalCapExceededError,\n  isScriptTimeoutError\n} from './eval-cap-exceeded-error.cjs';\nexport { DEFAULT_EVAL_CAP_IN_MILLISECONDS } from './eval-cap.cjs';\nexport type {\n  ClickElementParams,\n  ClickMouseParams,\n  CommonArguments,\n  CreateNoteParams,\n  EvalInObsidianParams,\n  GenericObject,\n  HoverElementParams,\n  Lib,\n  MouseButton,\n  MoveMouseParams,\n  OpenSettingsTabParams,\n  PressKeyParams,\n  TypeIntoEditorParams,\n  UnhoverElementParams,\n  WaitUntilParams\n} from './eval-in-obsidian.cjs';\nexport { evalInObsidian } from './eval-in-obsidian.cjs';\nexport type {\n  ComputeFitToCanvasParams,\n  FitScreenshotToCanvasOptions,\n  FitToCanvasGeometry\n} from './fit-screenshot.cjs';\nexport {\n  computeFitToCanvas,\n  fitScreenshotToCanvas\n} from './fit-screenshot.cjs';\nexport type { HideVaultNameOptions } from './hide-vault-name.cjs';\nexport { hideVaultName } from './hide-vault-name.cjs';\nexport type { IncompatibleInstallerVersionErrorConstructorParams } from './incompatible-installer-version-error.cjs';\nexport { IncompatibleInstallerVersionError } from './incompatible-installer-version-error.cjs';\nexport type {\n  InstallerCompatibility,\n  InstallerCompatibilityTier,\n  ResolveInstallerCompatibilityParams\n} from './installer-compatibility.cjs';\nexport { resolveInstallerCompatibility } from './installer-compatibility.cjs';\nexport type { IntegrationSetupFailedErrorConstructorParams } from './integration-setup-failed-error.cjs';\nexport { IntegrationSetupFailedError } from './integration-setup-failed-error.cjs';\nexport type {\n  ComputeLabelBandParams,\n  LabelBandGeometry,\n  LabelCaptionMeasurement,\n  LabelScreenshotOptions,\n  MeasureLabelCaptionParams\n} from './label-screenshot.cjs';\nexport {\n  buildLabelSvg,\n  computeLabelBand,\n  escapeSvgText,\n  labelScreenshot,\n  measureLabelCaption\n} from './label-screenshot.cjs';\nexport type { LibResolver } from './lib-registry.cjs';\nexport { registerLibResolver } from './lib-registry.cjs';\nexport type {\n  ObsidianRuntimeVersions,\n  ObsidianVersionChangelogUrls,\n  ObsidianVersionDownloads,\n  ObsidianVersionMetadata\n} from './obsidian-metadata.cjs';\nexport { getVersionMetadata } from './obsidian-metadata.cjs';\nexport {\n  CATALYST_LATEST,\n  PUBLIC_LATEST\n} from './obsidian-version.cjs';\nexport type { OpenObsidianSettingsTabParams } from './open-obsidian-settings-tab.cjs';\nexport { openObsidianSettingsTab } from './open-obsidian-settings-tab.cjs';\nexport type { OwnedInstanceExitedErrorConstructorParams } from './owned-instance-exited-error.cjs';\nexport { OwnedInstanceExitedError } from './owned-instance-exited-error.cjs';\nexport type { PollInObsidianParams } from './poll-in-obsidian.cjs';\nexport { pollInObsidian } from './poll-in-obsidian.cjs';\nexport { RendererFailedToInitializeError } from './renderer-failed-to-initialize-error.cjs';\nexport type { ResolveEmulatorDeviceIdParams } from './resolve-emulator-device-id.cjs';\nexport { resolveEmulatorDeviceId } from './resolve-emulator-device-id.cjs';\nexport type { RunObsidianVersionMatrixParams } from './run-version-matrix.cjs';\nexport { runObsidianVersionMatrix } from './run-version-matrix.cjs';\nexport type { SilentAsarFallbackErrorConstructorParams } from './silent-asar-fallback-error.cjs';\nexport { SilentAsarFallbackError } from './silent-asar-fallback-error.cjs';\nexport type {\n  BuildSoftKeyboardDiagnosticMessageParams,\n  CheckIsSoftKeyboardUpParams,\n  ElementRect,\n  ResolveSoftKeyboardTapPointsParams,\n  SoftKeyboardTapPoint,\n  SoftKeyboardViewportSnapshot\n} from './soft-keyboard-geometry.cjs';\nexport {\n  buildSoftKeyboardDiagnosticMessage,\n  checkIsSoftKeyboardUp,\n  DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,\n  parseInputMethodState,\n  resolveSoftKeyboardTapPoints\n} from './soft-keyboard-geometry.cjs';\nexport type {\n  RaiseSoftKeyboardParams,\n  TapDeviceParams\n} from './soft-keyboard.cjs';\nexport {\n  raiseSoftKeyboard,\n  tapDevice\n} from './soft-keyboard.cjs';\nexport type { StaleBuildErrorConstructorParams } from './stale-build-error.cjs';\nexport { StaleBuildError } from './stale-build-error.cjs';\nexport type {\n  PopulateFileContent,\n  PopulateFilesParams,\n  TemporaryVaultConstructorOptions\n} from './temporary-vault.cjs';\nexport { TemporaryVault } from './temporary-vault.cjs';\nexport type {\n  AppiumSessionInfo,\n  AppiumTransportConfig\n} from './transport-appium.cjs';\nexport { AppiumTransport } from './transport-appium.cjs';\nexport type {\n  DesktopCdpTransportConfig,\n  OwnedInstanceAsar,\n  OwnedInstanceConfig,\n  OwnedInstanceEndpoint\n} from './transport-desktop-cdp.cjs';\nexport { DesktopCdpTransport } from './transport-desktop-cdp.cjs';\nexport { createTransportFromOptions } from './transport-factory.cjs';\nexport type {\n  ObsidianAndroidAppiumTransportOptions,\n  ObsidianCdpTransportOptions,\n  ObsidianTransportOptions\n} from './transport-options.cjs';\nexport { checkIsMobileTransport } from './transport-options.cjs';\nexport type {\n  ConsoleCaptureHandle,\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.cjs';\nexport {\n  registerVault,\n  unregisterVault\n} from './vault-registry.cjs';\nexport type { ObsidianVersionMatrixEntry } from './version-matrix.cjs';\nexport { DEFAULT_OBSIDIAN_VERSION_SPECS } from './version-matrix.cjs';\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,iBAIO;AAOP,wBAKO;AAMP,qCAAoC;AAEpC,yCAA0C;AAK1C,gCAKO;AAEP,uCAAuC;AAEvC,6CAA6C;AAC7C,8BAGO;AAKP,4BAA6B;AAK7B,wBAA0B;AAM1B,8BAIO;AAOP,kCAGO;AAMP,iCAGO;AAEP,6BAAkC;AAClC,4CAA2C;AAE3C,+BAAwC;AAMxC,oCAGO;AAEP,qCAIO;AAMP,6BAKO;AAMP,oCAA6C;AAK7C,gCAAuC;AAEvC,qCAGO;AACP,sBAAiD;AAkBjD,8BAA+B;AAM/B,4BAGO;AAEP,6BAA8B;AAE9B,kDAAkD;AAMlD,qCAA8C;AAE9C,4CAA4C;AAQ5C,8BAMO;AAEP,0BAAoC;AAOpC,+BAAmC;AACnC,8BAGO;AAEP,wCAAwC;AAExC,yCAAyC;AAEzC,8BAA+B;AAC/B,iDAAgD;AAEhD,wCAAwC;AAExC,gCAAyC;AAEzC,wCAAwC;AASxC,oCAMO;AAKP,2BAGO;AAEP,+BAAgC;AAMhC,6BAA+B;AAK/B,8BAAgC;AAOhC,mCAAoC;AACpC,+BAA2C;AAM3C,+BAAuC;AAMvC,4BAGO;AAEP,4BAA+C;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/index.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains the entry point for the integration testing module.\n */\n\nexport type { RunAdbParams } from './adb.cjs';\nexport {\n  runAdbBinary,\n  runAdbText,\n  runAdbTextWithoutDevice\n} from './adb.cjs';\nexport type {\n  AppConfigRestore,\n  GetAppConfigParams,\n  SetAppConfigParams,\n  WithAppConfigParams\n} from './app-config.cjs';\nexport {\n  getAppConfig,\n  restoreAppConfig,\n  setAppConfig,\n  withAppConfig\n} from './app-config.cjs';\nexport type {\n  AsarFallback,\n  AsarFallbackTier,\n  ResolveAsarFallbackParams\n} from './asar-fallback-detection.cjs';\nexport { resolveAsarFallback } from './asar-fallback-detection.cjs';\nexport type { CaptureObsidianScreenshotOptions } from './capture-obsidian-screenshot.cjs';\nexport { captureObsidianScreenshot } from './capture-obsidian-screenshot.cjs';\nexport type {\n  CaptureScreenshotParams,\n  PngDimensions\n} from './capture-screenshot.cjs';\nexport {\n  buildDeviceMetricsOverride,\n  decodeBase64Png,\n  isPng,\n  readPngDimensions\n} from './capture-screenshot.cjs';\nexport type { CdpCommandTimeoutErrorConstructorParams } from './cdp-command-timeout-error.cjs';\nexport { CdpCommandTimeoutError } from './cdp-command-timeout-error.cjs';\nexport type { ConfigDirectoryFallbackErrorConstructorParams } from './config-directory-fallback-error.cjs';\nexport { ConfigDirectoryFallbackError } from './config-directory-fallback-error.cjs';\nexport {\n  assertValidConfigDirectory,\n  DEFAULT_CONFIG_DIRECTORY\n} from './config-directory.cjs';\nexport type {\n  CdpConnection,\n  ConnectToCdpOptions\n} from './connect-to-cdp.cjs';\nexport { connectToCdp } from './connect-to-cdp.cjs';\nexport type {\n  ContextArguments,\n  ContextOf\n} from './context-id.cjs';\nexport { ContextId } from './context-id.cjs';\nexport type {\n  SetupErrorResolver,\n  TransportOptionsResolver,\n  VaultPathResolver\n} from './context-provider.cjs';\nexport {\n  setSetupErrorResolver,\n  setTransportOptionsResolver,\n  setVaultPathResolver\n} from './context-provider.cjs';\nexport type {\n  BootstrapDemoVaultPluginsParams,\n  BootstrapDemoVaultPluginsResult,\n  BuildDemoVaultPopulateAsyncParams,\n  InstalledPluginInfo\n} from './demo-vault-bootstrap.cjs';\nexport {\n  bootstrapDemoVaultPlugins,\n  buildDemoVaultPopulateAsync\n} from './demo-vault-bootstrap.cjs';\nexport type {\n  BuildDemoVaultPopulateParams,\n  InjectPluginParams,\n  ResolveMissingInjectedPluginsParams\n} from './demo-vault-populate.cjs';\nexport {\n  buildDemoVaultPopulate,\n  resolveMissingInjectedPlugins\n} from './demo-vault-populate.cjs';\nexport type { ReadDemoVaultTreeParams } from './demo-vault-tree.cjs';\nexport { readDemoVaultTree } from './demo-vault-tree.cjs';\nexport { DesktopOnlyPluginSkipError } from './desktop-only-plugin-skip-error.cjs';\nexport type { CaptureDeviceScreenshotParams } from './device-screenshot.cjs';\nexport { captureDeviceScreenshot } from './device-screenshot.cjs';\nexport type {\n  DeviceSettingRestore,\n  DeviceSettingRestoreDelete,\n  DeviceSettingRestoreWrite\n} from './device-setting-restore.cjs';\nexport {\n  DeviceSettingRestoreKind,\n  resolveDeviceSettingRestore\n} from './device-setting-restore.cjs';\nexport type { BuildDeviceSettingsCommandArgumentsParams } from './device-settings-command.cjs';\nexport {\n  buildDeviceSettingsCommandArguments,\n  DeviceSettingNamespace,\n  DeviceSettingVerb\n} from './device-settings-command.cjs';\nexport type {\n  DeviceSettingParams,\n  WithSoftKeyboardEnabledParams,\n  WriteDeviceSettingParams\n} from './device-settings.cjs';\nexport {\n  deleteDeviceSetting,\n  readDeviceSetting,\n  withSoftKeyboardEnabled,\n  writeDeviceSetting\n} from './device-settings.cjs';\nexport type {\n  ElectronCompatibility,\n  ElectronCompatibilityTier,\n  ResolveElectronCompatibilityParams\n} from './electron-compatibility.cjs';\nexport { resolveElectronCompatibility } from './electron-compatibility.cjs';\nexport type {\n  EmulatorDeviceCandidate,\n  SelectEmulatorDeviceIdParams\n} from './emulator-device-id.cjs';\nexport { selectEmulatorDeviceId } from './emulator-device-id.cjs';\nexport type { EvalCapExceededErrorConstructorParams } from './eval-cap-exceeded-error.cjs';\nexport {\n  EvalCapExceededError,\n  isScriptTimeoutError\n} from './eval-cap-exceeded-error.cjs';\nexport { DEFAULT_EVAL_CAP_IN_MILLISECONDS } from './eval-cap.cjs';\nexport type {\n  ClickElementParams,\n  ClickMouseParams,\n  CommonArguments,\n  CreateNoteParams,\n  EvalInObsidianParams,\n  GenericObject,\n  HoverElementParams,\n  Lib,\n  MouseButton,\n  MoveMouseParams,\n  OpenSettingsTabParams,\n  PressKeyParams,\n  TypeIntoEditorParams,\n  UnhoverElementParams,\n  WaitUntilParams\n} from './eval-in-obsidian.cjs';\nexport { evalInObsidian } from './eval-in-obsidian.cjs';\nexport type {\n  ComputeFitToCanvasParams,\n  FitScreenshotToCanvasOptions,\n  FitToCanvasGeometry\n} from './fit-screenshot.cjs';\nexport {\n  computeFitToCanvas,\n  fitScreenshotToCanvas\n} from './fit-screenshot.cjs';\nexport type { HideVaultNameOptions } from './hide-vault-name.cjs';\nexport { hideVaultName } from './hide-vault-name.cjs';\nexport type { IncompatibleInstallerVersionErrorConstructorParams } from './incompatible-installer-version-error.cjs';\nexport { IncompatibleInstallerVersionError } from './incompatible-installer-version-error.cjs';\nexport type {\n  InstallerCompatibility,\n  InstallerCompatibilityTier,\n  ResolveInstallerCompatibilityParams\n} from './installer-compatibility.cjs';\nexport { resolveInstallerCompatibility } from './installer-compatibility.cjs';\nexport type { IntegrationSetupFailedErrorConstructorParams } from './integration-setup-failed-error.cjs';\nexport { IntegrationSetupFailedError } from './integration-setup-failed-error.cjs';\nexport type {\n  ComputeLabelBandParams,\n  LabelBandGeometry,\n  LabelCaptionMeasurement,\n  LabelScreenshotOptions,\n  MeasureLabelCaptionParams\n} from './label-screenshot.cjs';\nexport {\n  buildLabelSvg,\n  computeLabelBand,\n  escapeSvgText,\n  labelScreenshot,\n  measureLabelCaption\n} from './label-screenshot.cjs';\nexport type { LibResolver } from './lib-registry.cjs';\nexport { registerLibResolver } from './lib-registry.cjs';\nexport type {\n  ObsidianRuntimeVersions,\n  ObsidianVersionChangelogUrls,\n  ObsidianVersionDownloads,\n  ObsidianVersionMetadata\n} from './obsidian-metadata.cjs';\nexport { getVersionMetadata } from './obsidian-metadata.cjs';\nexport {\n  CATALYST_LATEST,\n  PUBLIC_LATEST\n} from './obsidian-version.cjs';\nexport type { OpenObsidianSettingsTabParams } from './open-obsidian-settings-tab.cjs';\nexport { openObsidianSettingsTab } from './open-obsidian-settings-tab.cjs';\nexport type { OwnedInstanceExitedErrorConstructorParams } from './owned-instance-exited-error.cjs';\nexport { OwnedInstanceExitedError } from './owned-instance-exited-error.cjs';\nexport type {\n  BuildStatusBarBandFailureMessageParams,\n  PaintOutStatusBarOptions,\n  ResolveStatusBarBandParams,\n  StatusBarBandColor,\n  StatusBarBandVerdict\n} from './paint-out-status-bar.cjs';\nexport {\n  buildStatusBarBandFailureMessage,\n  DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS,\n  DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS,\n  paintOutStatusBar,\n  resolveStatusBarBand\n} from './paint-out-status-bar.cjs';\nexport type { PollInObsidianParams } from './poll-in-obsidian.cjs';\nexport { pollInObsidian } from './poll-in-obsidian.cjs';\nexport { RendererFailedToInitializeError } from './renderer-failed-to-initialize-error.cjs';\nexport type { ResolveEmulatorDeviceIdParams } from './resolve-emulator-device-id.cjs';\nexport { resolveEmulatorDeviceId } from './resolve-emulator-device-id.cjs';\nexport type { RunObsidianVersionMatrixParams } from './run-version-matrix.cjs';\nexport { runObsidianVersionMatrix } from './run-version-matrix.cjs';\nexport type { SilentAsarFallbackErrorConstructorParams } from './silent-asar-fallback-error.cjs';\nexport { SilentAsarFallbackError } from './silent-asar-fallback-error.cjs';\nexport type {\n  BuildSoftKeyboardDiagnosticMessageParams,\n  CheckIsSoftKeyboardUpParams,\n  ElementRect,\n  ResolveSoftKeyboardTapPointsParams,\n  SoftKeyboardTapPoint,\n  SoftKeyboardViewportSnapshot\n} from './soft-keyboard-geometry.cjs';\nexport {\n  buildSoftKeyboardDiagnosticMessage,\n  checkIsInputMethodShown,\n  checkIsSoftKeyboardUp,\n  DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,\n  parseInputMethodState,\n  resolveSoftKeyboardTapPoints\n} from './soft-keyboard-geometry.cjs';\nexport type {\n  RaiseSoftKeyboardParams,\n  TapDeviceParams\n} from './soft-keyboard.cjs';\nexport {\n  raiseSoftKeyboard,\n  tapDevice\n} from './soft-keyboard.cjs';\nexport type { StaleBuildErrorConstructorParams } from './stale-build-error.cjs';\nexport { StaleBuildError } from './stale-build-error.cjs';\nexport type {\n  PopulateFileContent,\n  PopulateFilesParams,\n  TemporaryVaultConstructorOptions\n} from './temporary-vault.cjs';\nexport { TemporaryVault } from './temporary-vault.cjs';\nexport type {\n  AppiumSessionInfo,\n  AppiumTransportConfig\n} from './transport-appium.cjs';\nexport { AppiumTransport } from './transport-appium.cjs';\nexport type {\n  DesktopCdpTransportConfig,\n  OwnedInstanceAsar,\n  OwnedInstanceConfig,\n  OwnedInstanceEndpoint\n} from './transport-desktop-cdp.cjs';\nexport { DesktopCdpTransport } from './transport-desktop-cdp.cjs';\nexport { createTransportFromOptions } from './transport-factory.cjs';\nexport type {\n  ObsidianAndroidAppiumTransportOptions,\n  ObsidianCdpTransportOptions,\n  ObsidianTransportOptions\n} from './transport-options.cjs';\nexport { checkIsMobileTransport } from './transport-options.cjs';\nexport type {\n  ConsoleCaptureHandle,\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.cjs';\nexport {\n  registerVault,\n  unregisterVault\n} from './vault-registry.cjs';\nexport type { ObsidianVersionMatrixEntry } from './version-matrix.cjs';\nexport { DEFAULT_OBSIDIAN_VERSION_SPECS } from './version-matrix.cjs';\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,iBAIO;AAOP,wBAKO;AAMP,qCAAoC;AAEpC,yCAA0C;AAK1C,gCAKO;AAEP,uCAAuC;AAEvC,6CAA6C;AAC7C,8BAGO;AAKP,4BAA6B;AAK7B,wBAA0B;AAM1B,8BAIO;AAOP,kCAGO;AAMP,iCAGO;AAEP,6BAAkC;AAClC,4CAA2C;AAE3C,+BAAwC;AAMxC,oCAGO;AAEP,qCAIO;AAMP,6BAKO;AAMP,oCAA6C;AAK7C,gCAAuC;AAEvC,qCAGO;AACP,sBAAiD;AAkBjD,8BAA+B;AAM/B,4BAGO;AAEP,6BAA8B;AAE9B,kDAAkD;AAMlD,qCAA8C;AAE9C,4CAA4C;AAQ5C,8BAMO;AAEP,0BAAoC;AAOpC,+BAAmC;AACnC,8BAGO;AAEP,wCAAwC;AAExC,yCAAyC;AAQzC,kCAMO;AAEP,8BAA+B;AAC/B,iDAAgD;AAEhD,wCAAwC;AAExC,gCAAyC;AAEzC,wCAAwC;AASxC,oCAOO;AAKP,2BAGO;AAEP,+BAAgC;AAMhC,6BAA+B;AAK/B,8BAAgC;AAOhC,mCAAoC;AACpC,+BAA2C;AAM3C,+BAAuC;AAMvC,4BAGO;AAEP,4BAA+C;",
  "names": []
}


package/dist/lib/cjs/index.d.cts

@@ -69,6 +69,8 @@ export type { OpenObsidianSettingsTabParams } from './open-obsidian-settings-tab
 export { openObsidianSettingsTab } from './open-obsidian-settings-tab.cjs';
 export type { OwnedInstanceExitedErrorConstructorParams } from './owned-instance-exited-error.cjs';
 export { OwnedInstanceExitedError } from './owned-instance-exited-error.cjs';
+export type { BuildStatusBarBandFailureMessageParams, PaintOutStatusBarOptions, ResolveStatusBarBandParams, StatusBarBandColor, StatusBarBandVerdict } from './paint-out-status-bar.cjs';
+export { buildStatusBarBandFailureMessage, DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS, DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS, paintOutStatusBar, resolveStatusBarBand } from './paint-out-status-bar.cjs';
 export type { PollInObsidianParams } from './poll-in-obsidian.cjs';
 export { pollInObsidian } from './poll-in-obsidian.cjs';
 export { RendererFailedToInitializeError } from './renderer-failed-to-initialize-error.cjs';
@@ -79,7 +81,7 @@ export { runObsidianVersionMatrix } from './run-version-matrix.cjs';
 export type { SilentAsarFallbackErrorConstructorParams } from './silent-asar-fallback-error.cjs';
 export { SilentAsarFallbackError } from './silent-asar-fallback-error.cjs';
 export type { BuildSoftKeyboardDiagnosticMessageParams, CheckIsSoftKeyboardUpParams, ElementRect, ResolveSoftKeyboardTapPointsParams, SoftKeyboardTapPoint, SoftKeyboardViewportSnapshot } from './soft-keyboard-geometry.cjs';
-export { buildSoftKeyboardDiagnosticMessage, checkIsSoftKeyboardUp, DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS, parseInputMethodState, resolveSoftKeyboardTapPoints } from './soft-keyboard-geometry.cjs';
+export { buildSoftKeyboardDiagnosticMessage, checkIsInputMethodShown, checkIsSoftKeyboardUp, DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS, parseInputMethodState, resolveSoftKeyboardTapPoints } from './soft-keyboard-geometry.cjs';
 export type { RaiseSoftKeyboardParams, TapDeviceParams } from './soft-keyboard.cjs';
 export { raiseSoftKeyboard, tapDevice } from './soft-keyboard.cjs';
 export type { StaleBuildErrorConstructorParams } from './stale-build-error.cjs';

package/dist/lib/cjs/launched-device-selection.cjs

@@ -0,0 +1,46 @@
+"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 launched_device_selection_exports = {};
+__export(launched_device_selection_exports, {
+  resolveLaunchedDevice: () => resolveLaunchedDevice,
+  splitNewDevices: () => splitNewDevices
+});
+module.exports = __toCommonJS(launched_device_selection_exports);
+var import_avd_probe_verdict = require("./avd-probe-verdict.cjs");
+function resolveLaunchedDevice(params) {
+  const match = params.candidates.find((candidate) => candidate.probedAvdName === params.avdName);
+  return {
+    deviceId: match?.deviceId,
+    otherAvdDeviceIds: params.candidates.filter((candidate) => candidate.probedAvdName !== void 0 && candidate.probedAvdName !== params.avdName).map((candidate) => candidate.deviceId),
+    unansweredDeviceIds: params.candidates.filter((candidate) => candidate.probedAvdName === void 0).map((candidate) => candidate.deviceId)
+  };
+}
+function splitNewDevices(params) {
+  const newDeviceIds = params.connectedDeviceIds.filter((deviceId) => !params.deviceIdsBefore.includes(deviceId));
+  return {
+    emulatorDeviceIds: newDeviceIds.filter((deviceId) => (0, import_avd_probe_verdict.checkIsEmulatorDeviceId)(deviceId)),
+    nonEmulatorDeviceIds: newDeviceIds.filter((deviceId) => !(0, import_avd_probe_verdict.checkIsEmulatorDeviceId)(deviceId))
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveLaunchedDevice,
+  splitNewDevices
+});
+//# sourceMappingURL=data:application/json;base64,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