obsidian-integration-testing 16.0.0 → 17.0.0

package/dist/lib/esm/host-process-query-verdict.d.mts

@@ -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/esm/host-process-query-verdict.mjs

@@ -0,0 +1,74 @@
+import { assertNever } from "./type-guards.mjs";
+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 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";
+}
+export {
+  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.mjs';\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": "AAoDA,SAAS,mBAAmB;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,aAAO,YAAY,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/esm/index.d.mts

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

package/dist/lib/esm/index.mjs

@@ -87,6 +87,13 @@ import {
 } from "./obsidian-version.mjs";
 import { openObsidianSettingsTab } from "./open-obsidian-settings-tab.mjs";
 import { OwnedInstanceExitedError } from "./owned-instance-exited-error.mjs";
+import {
+  buildStatusBarBandFailureMessage,
+  DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS,
+  DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS,
+  paintOutStatusBar,
+  resolveStatusBarBand
+} from "./paint-out-status-bar.mjs";
 import { pollInObsidian } from "./poll-in-obsidian.mjs";
 import { RendererFailedToInitializeError } from "./renderer-failed-to-initialize-error.mjs";
 import { resolveEmulatorDeviceId } from "./resolve-emulator-device-id.mjs";
@@ -94,6 +101,7 @@ import { runObsidianVersionMatrix } from "./run-version-matrix.mjs";
 import { SilentAsarFallbackError } from "./silent-asar-fallback-error.mjs";
 import {
   buildSoftKeyboardDiagnosticMessage,
+  checkIsInputMethodShown,
   checkIsSoftKeyboardUp,
   DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,
   parseInputMethodState,
@@ -124,6 +132,8 @@ export {
   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,
@@ -146,8 +156,10 @@ export {
   buildDeviceSettingsCommandArguments,
   buildLabelSvg,
   buildSoftKeyboardDiagnosticMessage,
+  buildStatusBarBandFailureMessage,
   captureDeviceScreenshot,
   captureObsidianScreenshot,
+  checkIsInputMethodShown,
   checkIsMobileTransport,
   checkIsSoftKeyboardUp,
   computeFitToCanvas,
@@ -167,6 +179,7 @@ export {
   labelScreenshot,
   measureLabelCaption,
   openObsidianSettingsTab,
+  paintOutStatusBar,
   parseInputMethodState,
   pollInObsidian,
   raiseSoftKeyboard,
@@ -182,6 +195,7 @@ export {
   resolveInstallerCompatibility,
   resolveMissingInjectedPlugins,
   resolveSoftKeyboardTapPoints,
+  resolveStatusBarBand,
   restoreAppConfig,
   runAdbBinary,
   runAdbText,
@@ -198,4 +212,4 @@ export {
   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.mjs';\nexport {\n  runAdbBinary,\n  runAdbText,\n  runAdbTextWithoutDevice\n} from './adb.mjs';\nexport type {\n  AppConfigRestore,\n  GetAppConfigParams,\n  SetAppConfigParams,\n  WithAppConfigParams\n} from './app-config.mjs';\nexport {\n  getAppConfig,\n  restoreAppConfig,\n  setAppConfig,\n  withAppConfig\n} from './app-config.mjs';\nexport type {\n  AsarFallback,\n  AsarFallbackTier,\n  ResolveAsarFallbackParams\n} from './asar-fallback-detection.mjs';\nexport { resolveAsarFallback } from './asar-fallback-detection.mjs';\nexport type { CaptureObsidianScreenshotOptions } from './capture-obsidian-screenshot.mjs';\nexport { captureObsidianScreenshot } from './capture-obsidian-screenshot.mjs';\nexport type {\n  CaptureScreenshotParams,\n  PngDimensions\n} from './capture-screenshot.mjs';\nexport {\n  buildDeviceMetricsOverride,\n  decodeBase64Png,\n  isPng,\n  readPngDimensions\n} from './capture-screenshot.mjs';\nexport type { CdpCommandTimeoutErrorConstructorParams } from './cdp-command-timeout-error.mjs';\nexport { CdpCommandTimeoutError } from './cdp-command-timeout-error.mjs';\nexport type { ConfigDirectoryFallbackErrorConstructorParams } from './config-directory-fallback-error.mjs';\nexport { ConfigDirectoryFallbackError } from './config-directory-fallback-error.mjs';\nexport {\n  assertValidConfigDirectory,\n  DEFAULT_CONFIG_DIRECTORY\n} from './config-directory.mjs';\nexport type {\n  CdpConnection,\n  ConnectToCdpOptions\n} from './connect-to-cdp.mjs';\nexport { connectToCdp } from './connect-to-cdp.mjs';\nexport type {\n  ContextArguments,\n  ContextOf\n} from './context-id.mjs';\nexport { ContextId } from './context-id.mjs';\nexport type {\n  SetupErrorResolver,\n  TransportOptionsResolver,\n  VaultPathResolver\n} from './context-provider.mjs';\nexport {\n  setSetupErrorResolver,\n  setTransportOptionsResolver,\n  setVaultPathResolver\n} from './context-provider.mjs';\nexport type {\n  BootstrapDemoVaultPluginsParams,\n  BootstrapDemoVaultPluginsResult,\n  BuildDemoVaultPopulateAsyncParams,\n  InstalledPluginInfo\n} from './demo-vault-bootstrap.mjs';\nexport {\n  bootstrapDemoVaultPlugins,\n  buildDemoVaultPopulateAsync\n} from './demo-vault-bootstrap.mjs';\nexport type {\n  BuildDemoVaultPopulateParams,\n  InjectPluginParams,\n  ResolveMissingInjectedPluginsParams\n} from './demo-vault-populate.mjs';\nexport {\n  buildDemoVaultPopulate,\n  resolveMissingInjectedPlugins\n} from './demo-vault-populate.mjs';\nexport type { ReadDemoVaultTreeParams } from './demo-vault-tree.mjs';\nexport { readDemoVaultTree } from './demo-vault-tree.mjs';\nexport { DesktopOnlyPluginSkipError } from './desktop-only-plugin-skip-error.mjs';\nexport type { CaptureDeviceScreenshotParams } from './device-screenshot.mjs';\nexport { captureDeviceScreenshot } from './device-screenshot.mjs';\nexport type {\n  DeviceSettingRestore,\n  DeviceSettingRestoreDelete,\n  DeviceSettingRestoreWrite\n} from './device-setting-restore.mjs';\nexport {\n  DeviceSettingRestoreKind,\n  resolveDeviceSettingRestore\n} from './device-setting-restore.mjs';\nexport type { BuildDeviceSettingsCommandArgumentsParams } from './device-settings-command.mjs';\nexport {\n  buildDeviceSettingsCommandArguments,\n  DeviceSettingNamespace,\n  DeviceSettingVerb\n} from './device-settings-command.mjs';\nexport type {\n  DeviceSettingParams,\n  WithSoftKeyboardEnabledParams,\n  WriteDeviceSettingParams\n} from './device-settings.mjs';\nexport {\n  deleteDeviceSetting,\n  readDeviceSetting,\n  withSoftKeyboardEnabled,\n  writeDeviceSetting\n} from './device-settings.mjs';\nexport type {\n  ElectronCompatibility,\n  ElectronCompatibilityTier,\n  ResolveElectronCompatibilityParams\n} from './electron-compatibility.mjs';\nexport { resolveElectronCompatibility } from './electron-compatibility.mjs';\nexport type {\n  EmulatorDeviceCandidate,\n  SelectEmulatorDeviceIdParams\n} from './emulator-device-id.mjs';\nexport { selectEmulatorDeviceId } from './emulator-device-id.mjs';\nexport type { EvalCapExceededErrorConstructorParams } from './eval-cap-exceeded-error.mjs';\nexport {\n  EvalCapExceededError,\n  isScriptTimeoutError\n} from './eval-cap-exceeded-error.mjs';\nexport { DEFAULT_EVAL_CAP_IN_MILLISECONDS } from './eval-cap.mjs';\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.mjs';\nexport { evalInObsidian } from './eval-in-obsidian.mjs';\nexport type {\n  ComputeFitToCanvasParams,\n  FitScreenshotToCanvasOptions,\n  FitToCanvasGeometry\n} from './fit-screenshot.mjs';\nexport {\n  computeFitToCanvas,\n  fitScreenshotToCanvas\n} from './fit-screenshot.mjs';\nexport type { HideVaultNameOptions } from './hide-vault-name.mjs';\nexport { hideVaultName } from './hide-vault-name.mjs';\nexport type { IncompatibleInstallerVersionErrorConstructorParams } from './incompatible-installer-version-error.mjs';\nexport { IncompatibleInstallerVersionError } from './incompatible-installer-version-error.mjs';\nexport type {\n  InstallerCompatibility,\n  InstallerCompatibilityTier,\n  ResolveInstallerCompatibilityParams\n} from './installer-compatibility.mjs';\nexport { resolveInstallerCompatibility } from './installer-compatibility.mjs';\nexport type { IntegrationSetupFailedErrorConstructorParams } from './integration-setup-failed-error.mjs';\nexport { IntegrationSetupFailedError } from './integration-setup-failed-error.mjs';\nexport type {\n  ComputeLabelBandParams,\n  LabelBandGeometry,\n  LabelCaptionMeasurement,\n  LabelScreenshotOptions,\n  MeasureLabelCaptionParams\n} from './label-screenshot.mjs';\nexport {\n  buildLabelSvg,\n  computeLabelBand,\n  escapeSvgText,\n  labelScreenshot,\n  measureLabelCaption\n} from './label-screenshot.mjs';\nexport type { LibResolver } from './lib-registry.mjs';\nexport { registerLibResolver } from './lib-registry.mjs';\nexport type {\n  ObsidianRuntimeVersions,\n  ObsidianVersionChangelogUrls,\n  ObsidianVersionDownloads,\n  ObsidianVersionMetadata\n} from './obsidian-metadata.mjs';\nexport { getVersionMetadata } from './obsidian-metadata.mjs';\nexport {\n  CATALYST_LATEST,\n  PUBLIC_LATEST\n} from './obsidian-version.mjs';\nexport type { OpenObsidianSettingsTabParams } from './open-obsidian-settings-tab.mjs';\nexport { openObsidianSettingsTab } from './open-obsidian-settings-tab.mjs';\nexport type { OwnedInstanceExitedErrorConstructorParams } from './owned-instance-exited-error.mjs';\nexport { OwnedInstanceExitedError } from './owned-instance-exited-error.mjs';\nexport type { PollInObsidianParams } from './poll-in-obsidian.mjs';\nexport { pollInObsidian } from './poll-in-obsidian.mjs';\nexport { RendererFailedToInitializeError } from './renderer-failed-to-initialize-error.mjs';\nexport type { ResolveEmulatorDeviceIdParams } from './resolve-emulator-device-id.mjs';\nexport { resolveEmulatorDeviceId } from './resolve-emulator-device-id.mjs';\nexport type { RunObsidianVersionMatrixParams } from './run-version-matrix.mjs';\nexport { runObsidianVersionMatrix } from './run-version-matrix.mjs';\nexport type { SilentAsarFallbackErrorConstructorParams } from './silent-asar-fallback-error.mjs';\nexport { SilentAsarFallbackError } from './silent-asar-fallback-error.mjs';\nexport type {\n  BuildSoftKeyboardDiagnosticMessageParams,\n  CheckIsSoftKeyboardUpParams,\n  ElementRect,\n  ResolveSoftKeyboardTapPointsParams,\n  SoftKeyboardTapPoint,\n  SoftKeyboardViewportSnapshot\n} from './soft-keyboard-geometry.mjs';\nexport {\n  buildSoftKeyboardDiagnosticMessage,\n  checkIsSoftKeyboardUp,\n  DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,\n  parseInputMethodState,\n  resolveSoftKeyboardTapPoints\n} from './soft-keyboard-geometry.mjs';\nexport type {\n  RaiseSoftKeyboardParams,\n  TapDeviceParams\n} from './soft-keyboard.mjs';\nexport {\n  raiseSoftKeyboard,\n  tapDevice\n} from './soft-keyboard.mjs';\nexport type { StaleBuildErrorConstructorParams } from './stale-build-error.mjs';\nexport { StaleBuildError } from './stale-build-error.mjs';\nexport type {\n  PopulateFileContent,\n  PopulateFilesParams,\n  TemporaryVaultConstructorOptions\n} from './temporary-vault.mjs';\nexport { TemporaryVault } from './temporary-vault.mjs';\nexport type {\n  AppiumSessionInfo,\n  AppiumTransportConfig\n} from './transport-appium.mjs';\nexport { AppiumTransport } from './transport-appium.mjs';\nexport type {\n  DesktopCdpTransportConfig,\n  OwnedInstanceAsar,\n  OwnedInstanceConfig,\n  OwnedInstanceEndpoint\n} from './transport-desktop-cdp.mjs';\nexport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nexport { createTransportFromOptions } from './transport-factory.mjs';\nexport type {\n  ObsidianAndroidAppiumTransportOptions,\n  ObsidianCdpTransportOptions,\n  ObsidianTransportOptions\n} from './transport-options.mjs';\nexport { checkIsMobileTransport } from './transport-options.mjs';\nexport type {\n  ConsoleCaptureHandle,\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.mjs';\nexport {\n  registerVault,\n  unregisterVault\n} from './vault-registry.mjs';\nexport type { ObsidianVersionMatrixEntry } from './version-matrix.mjs';\nexport { DEFAULT_OBSIDIAN_VERSION_SPECS } from './version-matrix.mjs';\n"],
  "mappings": "AAOA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAOP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAMP,SAAS,2BAA2B;AAEpC,SAAS,iCAAiC;AAK1C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,8BAA8B;AAEvC,SAAS,oCAAoC;AAC7C;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAKP,SAAS,oBAAoB;AAK7B,SAAS,iBAAiB;AAM1B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAOP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAMP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,yBAAyB;AAClC,SAAS,kCAAkC;AAE3C,SAAS,+BAA+B;AAMxC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAMP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAMP,SAAS,oCAAoC;AAK7C,SAAS,8BAA8B;AAEvC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,wCAAwC;AAkBjD,SAAS,sBAAsB;AAM/B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,qBAAqB;AAE9B,SAAS,yCAAyC;AAMlD,SAAS,qCAAqC;AAE9C,SAAS,mCAAmC;AAQ5C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,2BAA2B;AAOpC,SAAS,0BAA0B;AACnC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,+BAA+B;AAExC,SAAS,gCAAgC;AAEzC,SAAS,sBAAsB;AAC/B,SAAS,uCAAuC;AAEhD,SAAS,+BAA+B;AAExC,SAAS,gCAAgC;AAEzC,SAAS,+BAA+B;AASxC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAKP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,uBAAuB;AAMhC,SAAS,sBAAsB;AAK/B,SAAS,uBAAuB;AAOhC,SAAS,2BAA2B;AACpC,SAAS,kCAAkC;AAM3C,SAAS,8BAA8B;AAMvC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,sCAAsC;",
  "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.mjs';\nexport {\n  runAdbBinary,\n  runAdbText,\n  runAdbTextWithoutDevice\n} from './adb.mjs';\nexport type {\n  AppConfigRestore,\n  GetAppConfigParams,\n  SetAppConfigParams,\n  WithAppConfigParams\n} from './app-config.mjs';\nexport {\n  getAppConfig,\n  restoreAppConfig,\n  setAppConfig,\n  withAppConfig\n} from './app-config.mjs';\nexport type {\n  AsarFallback,\n  AsarFallbackTier,\n  ResolveAsarFallbackParams\n} from './asar-fallback-detection.mjs';\nexport { resolveAsarFallback } from './asar-fallback-detection.mjs';\nexport type { CaptureObsidianScreenshotOptions } from './capture-obsidian-screenshot.mjs';\nexport { captureObsidianScreenshot } from './capture-obsidian-screenshot.mjs';\nexport type {\n  CaptureScreenshotParams,\n  PngDimensions\n} from './capture-screenshot.mjs';\nexport {\n  buildDeviceMetricsOverride,\n  decodeBase64Png,\n  isPng,\n  readPngDimensions\n} from './capture-screenshot.mjs';\nexport type { CdpCommandTimeoutErrorConstructorParams } from './cdp-command-timeout-error.mjs';\nexport { CdpCommandTimeoutError } from './cdp-command-timeout-error.mjs';\nexport type { ConfigDirectoryFallbackErrorConstructorParams } from './config-directory-fallback-error.mjs';\nexport { ConfigDirectoryFallbackError } from './config-directory-fallback-error.mjs';\nexport {\n  assertValidConfigDirectory,\n  DEFAULT_CONFIG_DIRECTORY\n} from './config-directory.mjs';\nexport type {\n  CdpConnection,\n  ConnectToCdpOptions\n} from './connect-to-cdp.mjs';\nexport { connectToCdp } from './connect-to-cdp.mjs';\nexport type {\n  ContextArguments,\n  ContextOf\n} from './context-id.mjs';\nexport { ContextId } from './context-id.mjs';\nexport type {\n  SetupErrorResolver,\n  TransportOptionsResolver,\n  VaultPathResolver\n} from './context-provider.mjs';\nexport {\n  setSetupErrorResolver,\n  setTransportOptionsResolver,\n  setVaultPathResolver\n} from './context-provider.mjs';\nexport type {\n  BootstrapDemoVaultPluginsParams,\n  BootstrapDemoVaultPluginsResult,\n  BuildDemoVaultPopulateAsyncParams,\n  InstalledPluginInfo\n} from './demo-vault-bootstrap.mjs';\nexport {\n  bootstrapDemoVaultPlugins,\n  buildDemoVaultPopulateAsync\n} from './demo-vault-bootstrap.mjs';\nexport type {\n  BuildDemoVaultPopulateParams,\n  InjectPluginParams,\n  ResolveMissingInjectedPluginsParams\n} from './demo-vault-populate.mjs';\nexport {\n  buildDemoVaultPopulate,\n  resolveMissingInjectedPlugins\n} from './demo-vault-populate.mjs';\nexport type { ReadDemoVaultTreeParams } from './demo-vault-tree.mjs';\nexport { readDemoVaultTree } from './demo-vault-tree.mjs';\nexport { DesktopOnlyPluginSkipError } from './desktop-only-plugin-skip-error.mjs';\nexport type { CaptureDeviceScreenshotParams } from './device-screenshot.mjs';\nexport { captureDeviceScreenshot } from './device-screenshot.mjs';\nexport type {\n  DeviceSettingRestore,\n  DeviceSettingRestoreDelete,\n  DeviceSettingRestoreWrite\n} from './device-setting-restore.mjs';\nexport {\n  DeviceSettingRestoreKind,\n  resolveDeviceSettingRestore\n} from './device-setting-restore.mjs';\nexport type { BuildDeviceSettingsCommandArgumentsParams } from './device-settings-command.mjs';\nexport {\n  buildDeviceSettingsCommandArguments,\n  DeviceSettingNamespace,\n  DeviceSettingVerb\n} from './device-settings-command.mjs';\nexport type {\n  DeviceSettingParams,\n  WithSoftKeyboardEnabledParams,\n  WriteDeviceSettingParams\n} from './device-settings.mjs';\nexport {\n  deleteDeviceSetting,\n  readDeviceSetting,\n  withSoftKeyboardEnabled,\n  writeDeviceSetting\n} from './device-settings.mjs';\nexport type {\n  ElectronCompatibility,\n  ElectronCompatibilityTier,\n  ResolveElectronCompatibilityParams\n} from './electron-compatibility.mjs';\nexport { resolveElectronCompatibility } from './electron-compatibility.mjs';\nexport type {\n  EmulatorDeviceCandidate,\n  SelectEmulatorDeviceIdParams\n} from './emulator-device-id.mjs';\nexport { selectEmulatorDeviceId } from './emulator-device-id.mjs';\nexport type { EvalCapExceededErrorConstructorParams } from './eval-cap-exceeded-error.mjs';\nexport {\n  EvalCapExceededError,\n  isScriptTimeoutError\n} from './eval-cap-exceeded-error.mjs';\nexport { DEFAULT_EVAL_CAP_IN_MILLISECONDS } from './eval-cap.mjs';\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.mjs';\nexport { evalInObsidian } from './eval-in-obsidian.mjs';\nexport type {\n  ComputeFitToCanvasParams,\n  FitScreenshotToCanvasOptions,\n  FitToCanvasGeometry\n} from './fit-screenshot.mjs';\nexport {\n  computeFitToCanvas,\n  fitScreenshotToCanvas\n} from './fit-screenshot.mjs';\nexport type { HideVaultNameOptions } from './hide-vault-name.mjs';\nexport { hideVaultName } from './hide-vault-name.mjs';\nexport type { IncompatibleInstallerVersionErrorConstructorParams } from './incompatible-installer-version-error.mjs';\nexport { IncompatibleInstallerVersionError } from './incompatible-installer-version-error.mjs';\nexport type {\n  InstallerCompatibility,\n  InstallerCompatibilityTier,\n  ResolveInstallerCompatibilityParams\n} from './installer-compatibility.mjs';\nexport { resolveInstallerCompatibility } from './installer-compatibility.mjs';\nexport type { IntegrationSetupFailedErrorConstructorParams } from './integration-setup-failed-error.mjs';\nexport { IntegrationSetupFailedError } from './integration-setup-failed-error.mjs';\nexport type {\n  ComputeLabelBandParams,\n  LabelBandGeometry,\n  LabelCaptionMeasurement,\n  LabelScreenshotOptions,\n  MeasureLabelCaptionParams\n} from './label-screenshot.mjs';\nexport {\n  buildLabelSvg,\n  computeLabelBand,\n  escapeSvgText,\n  labelScreenshot,\n  measureLabelCaption\n} from './label-screenshot.mjs';\nexport type { LibResolver } from './lib-registry.mjs';\nexport { registerLibResolver } from './lib-registry.mjs';\nexport type {\n  ObsidianRuntimeVersions,\n  ObsidianVersionChangelogUrls,\n  ObsidianVersionDownloads,\n  ObsidianVersionMetadata\n} from './obsidian-metadata.mjs';\nexport { getVersionMetadata } from './obsidian-metadata.mjs';\nexport {\n  CATALYST_LATEST,\n  PUBLIC_LATEST\n} from './obsidian-version.mjs';\nexport type { OpenObsidianSettingsTabParams } from './open-obsidian-settings-tab.mjs';\nexport { openObsidianSettingsTab } from './open-obsidian-settings-tab.mjs';\nexport type { OwnedInstanceExitedErrorConstructorParams } from './owned-instance-exited-error.mjs';\nexport { OwnedInstanceExitedError } from './owned-instance-exited-error.mjs';\nexport type {\n  BuildStatusBarBandFailureMessageParams,\n  PaintOutStatusBarOptions,\n  ResolveStatusBarBandParams,\n  StatusBarBandColor,\n  StatusBarBandVerdict\n} from './paint-out-status-bar.mjs';\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.mjs';\nexport type { PollInObsidianParams } from './poll-in-obsidian.mjs';\nexport { pollInObsidian } from './poll-in-obsidian.mjs';\nexport { RendererFailedToInitializeError } from './renderer-failed-to-initialize-error.mjs';\nexport type { ResolveEmulatorDeviceIdParams } from './resolve-emulator-device-id.mjs';\nexport { resolveEmulatorDeviceId } from './resolve-emulator-device-id.mjs';\nexport type { RunObsidianVersionMatrixParams } from './run-version-matrix.mjs';\nexport { runObsidianVersionMatrix } from './run-version-matrix.mjs';\nexport type { SilentAsarFallbackErrorConstructorParams } from './silent-asar-fallback-error.mjs';\nexport { SilentAsarFallbackError } from './silent-asar-fallback-error.mjs';\nexport type {\n  BuildSoftKeyboardDiagnosticMessageParams,\n  CheckIsSoftKeyboardUpParams,\n  ElementRect,\n  ResolveSoftKeyboardTapPointsParams,\n  SoftKeyboardTapPoint,\n  SoftKeyboardViewportSnapshot\n} from './soft-keyboard-geometry.mjs';\nexport {\n  buildSoftKeyboardDiagnosticMessage,\n  checkIsInputMethodShown,\n  checkIsSoftKeyboardUp,\n  DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,\n  parseInputMethodState,\n  resolveSoftKeyboardTapPoints\n} from './soft-keyboard-geometry.mjs';\nexport type {\n  RaiseSoftKeyboardParams,\n  TapDeviceParams\n} from './soft-keyboard.mjs';\nexport {\n  raiseSoftKeyboard,\n  tapDevice\n} from './soft-keyboard.mjs';\nexport type { StaleBuildErrorConstructorParams } from './stale-build-error.mjs';\nexport { StaleBuildError } from './stale-build-error.mjs';\nexport type {\n  PopulateFileContent,\n  PopulateFilesParams,\n  TemporaryVaultConstructorOptions\n} from './temporary-vault.mjs';\nexport { TemporaryVault } from './temporary-vault.mjs';\nexport type {\n  AppiumSessionInfo,\n  AppiumTransportConfig\n} from './transport-appium.mjs';\nexport { AppiumTransport } from './transport-appium.mjs';\nexport type {\n  DesktopCdpTransportConfig,\n  OwnedInstanceAsar,\n  OwnedInstanceConfig,\n  OwnedInstanceEndpoint\n} from './transport-desktop-cdp.mjs';\nexport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nexport { createTransportFromOptions } from './transport-factory.mjs';\nexport type {\n  ObsidianAndroidAppiumTransportOptions,\n  ObsidianCdpTransportOptions,\n  ObsidianTransportOptions\n} from './transport-options.mjs';\nexport { checkIsMobileTransport } from './transport-options.mjs';\nexport type {\n  ConsoleCaptureHandle,\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.mjs';\nexport {\n  registerVault,\n  unregisterVault\n} from './vault-registry.mjs';\nexport type { ObsidianVersionMatrixEntry } from './version-matrix.mjs';\nexport { DEFAULT_OBSIDIAN_VERSION_SPECS } from './version-matrix.mjs';\n"],
  "mappings": "AAOA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAOP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAMP,SAAS,2BAA2B;AAEpC,SAAS,iCAAiC;AAK1C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,8BAA8B;AAEvC,SAAS,oCAAoC;AAC7C;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAKP,SAAS,oBAAoB;AAK7B,SAAS,iBAAiB;AAM1B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAOP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAMP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,yBAAyB;AAClC,SAAS,kCAAkC;AAE3C,SAAS,+BAA+B;AAMxC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAMP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAMP,SAAS,oCAAoC;AAK7C,SAAS,8BAA8B;AAEvC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,wCAAwC;AAkBjD,SAAS,sBAAsB;AAM/B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,qBAAqB;AAE9B,SAAS,yCAAyC;AAMlD,SAAS,qCAAqC;AAE9C,SAAS,mCAAmC;AAQ5C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,2BAA2B;AAOpC,SAAS,0BAA0B;AACnC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,+BAA+B;AAExC,SAAS,gCAAgC;AAQzC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,sBAAsB;AAC/B,SAAS,uCAAuC;AAEhD,SAAS,+BAA+B;AAExC,SAAS,gCAAgC;AAEzC,SAAS,+BAA+B;AASxC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAKP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,uBAAuB;AAMhC,SAAS,sBAAsB;AAK/B,SAAS,uBAAuB;AAOhC,SAAS,2BAA2B;AACpC,SAAS,kCAAkC;AAM3C,SAAS,8BAA8B;AAMvC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,sCAAsC;",
  "names": []
}


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

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

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

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

package/dist/lib/esm/library.mjs

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