obsidian-integration-testing 12.0.0 → 12.1.1

package/dist/lib/cjs/appium-server-marker.cjs

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,41 +15,28 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var appium_server_marker_exports = {};
 __export(appium_server_marker_exports, {
   checkIsHarnessOwnedAppiumServer: () => checkIsHarnessOwnedAppiumServer,
   clearAppiumServerMarker: () => clearAppiumServerMarker,
   readAppiumServerMarker: () => readAppiumServerMarker,
+  recordAppiumServerStopAttempt: () => recordAppiumServerStopAttempt,
   writeAppiumServerMarker: () => writeAppiumServerMarker
 });
 module.exports = __toCommonJS(appium_server_marker_exports);
 var import_node_fs = require("node:fs");
 var import_node_os = require("node:os");
 var import_node_path = require("node:path");
-var import_node_process = __toESM(require("node:process"), 1);
 var import_log = require("./log.cjs");
+var import_process_liveness = require("./process-liveness.cjs");
 const MARKER_DIR_NAME = "obsidian-integration-testing";
 const MARKER_FILE_SUFFIX = ".appium-server.json";
-const PROCESS_EXISTENCE_PROBE_SIGNAL = 0;
 function checkIsHarnessOwnedAppiumServer(marker) {
   if (!marker) {
     return false;
   }
-  try {
-    import_node_process.default.kill(marker.pid, PROCESS_EXISTENCE_PROBE_SIGNAL);
-    return true;
-  } catch (error) {
-    return getErrorCode(error) === "EPERM";
-  }
+  return (0, import_process_liveness.checkIsProcessAlive)(marker.pid);
 }
 function clearAppiumServerMarker(port) {
   try {
@@ -69,21 +54,19 @@ function readAppiumServerMarker(port) {
   }
   return parseMarker(parsed, port);
 }
+function recordAppiumServerStopAttempt(port) {
+  const marker = readAppiumServerMarker(port);
+  if (!marker) {
+    return;
+  }
+  writeMarker({ ...marker, stopAttemptedAtInMilliseconds: Date.now() });
+}
 function writeAppiumServerMarker(params) {
-  const marker = {
+  writeMarker({
     pid: params.pid,
     port: params.port,
     startedAtInMilliseconds: Date.now()
-  };
-  try {
-    (0, import_node_fs.mkdirSync)(getMarkerDirectory(), { recursive: true });
-    (0, import_node_fs.writeFileSync)(getMarkerFilePath(params.port), JSON.stringify(marker));
-  } catch (error) {
-    (0, import_log.log)(`[appium-server-marker] Could not record the server on port ${String(params.port)}: ${getErrorMessage(error)}`);
-  }
-}
-function getErrorCode(error) {
-  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
+  });
 }
 function getErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
@@ -99,17 +82,31 @@ function parseMarker(parsed, port) {
     return void 0;
   }
   const record = parsed;
-  const { pid, port: markedPort, startedAtInMilliseconds } = record;
+  const { pid, port: markedPort, startedAtInMilliseconds, stopAttemptedAtInMilliseconds } = record;
   if (typeof pid !== "number" || typeof startedAtInMilliseconds !== "number" || markedPort !== port) {
     return void 0;
   }
-  return { pid, port, startedAtInMilliseconds };
+  return {
+    pid,
+    port,
+    startedAtInMilliseconds,
+    ...typeof stopAttemptedAtInMilliseconds === "number" && { stopAttemptedAtInMilliseconds }
+  };
+}
+function writeMarker(marker) {
+  try {
+    (0, import_node_fs.mkdirSync)(getMarkerDirectory(), { recursive: true });
+    (0, import_node_fs.writeFileSync)(getMarkerFilePath(marker.port), JSON.stringify(marker));
+  } catch (error) {
+    (0, import_log.log)(`[appium-server-marker] Could not record the server on port ${String(marker.port)}: ${getErrorMessage(error)}`);
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   checkIsHarnessOwnedAppiumServer,
   clearAppiumServerMarker,
   readAppiumServerMarker,
+  recordAppiumServerStopAttempt,
   writeAppiumServerMarker
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/appium-server-marker.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Records which Appium server on a port this harness started, so a later run\n * that finds a server already listening can tell **provenance**: one of our own\n * servers left over from an earlier run, or a foreign one the user manages.\n *\n * The preflight adopts any server that answers `/status`, and adoption is the\n * right default \u2014 starting a second server on an occupied port cannot work. But\n * adopting silently means a wedged leftover (see `wedged-appium-server.ts`) is\n * indistinguishable from a healthy server, and the harness has no basis on which\n * to decide whether restarting it is its call to make. The marker supplies that\n * basis: a server we started may be restarted, a foreign one is only ever\n * reported.\n *\n * The marker is a small JSON sentinel next to the setup lock (`setup-lock.ts`),\n * keyed by port, and is deliberately tolerant \u2014 a missing, unreadable, or\n * mismatched marker simply reads as \"not ours\".\n */\n\nimport {\n  mkdirSync,\n  readFileSync,\n  rmSync,\n  writeFileSync\n} from 'node:fs';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\nimport process from 'node:process';\n\nimport { log } from './log.cjs';\n\nconst MARKER_DIR_NAME = 'obsidian-integration-testing';\nconst MARKER_FILE_SUFFIX = '.appium-server.json';\nconst PROCESS_EXISTENCE_PROBE_SIGNAL = 0;\n\n/**\n * Identifies the Appium server this harness started on a port.\n */\nexport interface AppiumServerMarker {\n  /**\n  PID of the spawned server process (the shell wrapper that owns the server's process tree).\n   */\n  readonly pid: number;\n\n  /**\n  The port the server was started on.\n   */\n  readonly port: number;\n\n  /**\n  When the server was started (`Date.now()` epoch milliseconds).\n   */\n  readonly startedAtInMilliseconds: number;\n}\n\n/**\n * Parameters for {@link writeAppiumServerMarker}.\n */\nexport interface WriteAppiumServerMarkerParams {\n  /**\n  PID of the spawned server process.\n   */\n  readonly pid: number;\n\n  /**\n  The port the server was started on.\n   */\n  readonly port: number;\n}\n\n/**\n * Checks whether the marked server is still running, which is what makes an\n * adopted server ours to restart.\n *\n * A dead PID means the marker outlived its server, so whatever answers on that\n * port now is somebody else's \u2014 the marker proves nothing about it.\n *\n * @param marker - The marker read for the port, or `undefined` when there is none.\n * @returns `true` when an earlier run of this harness started the server now listening.\n */\nexport function checkIsHarnessOwnedAppiumServer(marker: AppiumServerMarker | undefined): boolean {\n  if (!marker) {\n    return false;\n  }\n\n  try {\n    process.kill(marker.pid, PROCESS_EXISTENCE_PROBE_SIGNAL);\n    return true;\n  } catch (error: unknown) {\n    // `EPERM` means the process exists but is owned by another user \u2014 still alive.\n    return getErrorCode(error) === 'EPERM';\n  }\n}\n\n/**\n * Removes the marker for a port. Called once the marked server has been stopped,\n * so a later run does not mistake a recycled PID for our server.\n *\n * @param port - The Appium server port.\n */\nexport function clearAppiumServerMarker(port: number): void {\n  try {\n    rmSync(getMarkerFilePath(port), { force: true });\n  } catch (error: unknown) {\n    log(`[appium-server-marker] Could not remove the marker for port ${String(port)}: ${getErrorMessage(error)}`);\n  }\n}\n\n/**\n * Reads the marker for a port.\n *\n * @param port - The Appium server port.\n * @returns The marker, or `undefined` when there is none, it is unreadable, or it does not describe this port.\n */\nexport function readAppiumServerMarker(port: number): AppiumServerMarker | undefined {\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(readFileSync(getMarkerFilePath(port), 'utf-8'));\n  } catch {\n    return undefined;\n  }\n\n  return parseMarker(parsed, port);\n}\n\n/**\n * Records the server this run just started, stamping it with the current time so\n * a later run can report how long it has been up.\n *\n * @param params - The started server's PID and port.\n */\nexport function writeAppiumServerMarker(params: WriteAppiumServerMarkerParams): void {\n  const marker: AppiumServerMarker = {\n    pid: params.pid,\n    port: params.port,\n    startedAtInMilliseconds: Date.now()\n  };\n\n  try {\n    mkdirSync(getMarkerDirectory(), { recursive: true });\n    writeFileSync(getMarkerFilePath(params.port), JSON.stringify(marker));\n  } catch (error: unknown) {\n    log(`[appium-server-marker] Could not record the server on port ${String(params.port)}: ${getErrorMessage(error)}`);\n  }\n}\n\nfunction getErrorCode(error: unknown): string | undefined {\n  return typeof error === 'object' && error !== null && 'code' in error ? String(error.code) : undefined;\n}\n\nfunction getErrorMessage(error: unknown): string {\n  return error instanceof Error ? error.message : String(error);\n}\n\nfunction getMarkerDirectory(): string {\n  return join(tmpdir(), MARKER_DIR_NAME);\n}\n\nfunction getMarkerFilePath(port: number): string {\n  return join(getMarkerDirectory(), `${String(port)}${MARKER_FILE_SUFFIX}`);\n}\n\nfunction parseMarker(parsed: unknown, port: number): AppiumServerMarker | undefined {\n  if (typeof parsed !== 'object' || parsed === null) {\n    return undefined;\n  }\n\n  const record = parsed as Record<string, unknown>;\n  const { pid, port: markedPort, startedAtInMilliseconds } = record;\n\n  if (typeof pid !== 'number' || typeof startedAtInMilliseconds !== 'number' || markedPort !== port) {\n    return undefined;\n  }\n\n  return { pid, port, startedAtInMilliseconds };\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAoBA,qBAKO;AACP,qBAAuB;AACvB,uBAAqB;AACrB,0BAAoB;AAEpB,iBAAoB;AAEpB,MAAM,kBAAkB;AACxB,MAAM,qBAAqB;AAC3B,MAAM,iCAAiC;AA+ChC,SAAS,gCAAgC,QAAiD;AAC/F,MAAI,CAAC,QAAQ;AACX,WAAO;AAAA,EACT;AAEA,MAAI;AACF,wBAAAA,QAAQ,KAAK,OAAO,KAAK,8BAA8B;AACvD,WAAO;AAAA,EACT,SAAS,OAAgB;AAEvB,WAAO,aAAa,KAAK,MAAM;AAAA,EACjC;AACF;AAQO,SAAS,wBAAwB,MAAoB;AAC1D,MAAI;AACF,+BAAO,kBAAkB,IAAI,GAAG,EAAE,OAAO,KAAK,CAAC;AAAA,EACjD,SAAS,OAAgB;AACvB,wBAAI,+DAA+D,OAAO,IAAI,CAAC,KAAK,gBAAgB,KAAK,CAAC,EAAE;AAAA,EAC9G;AACF;AAQO,SAAS,uBAAuB,MAA8C;AACnF,MAAI;AACJ,MAAI;AACF,aAAS,KAAK,UAAM,6BAAa,kBAAkB,IAAI,GAAG,OAAO,CAAC;AAAA,EACpE,QAAQ;AACN,WAAO;AAAA,EACT;AAEA,SAAO,YAAY,QAAQ,IAAI;AACjC;AAQO,SAAS,wBAAwB,QAA6C;AACnF,QAAM,SAA6B;AAAA,IACjC,KAAK,OAAO;AAAA,IACZ,MAAM,OAAO;AAAA,IACb,yBAAyB,KAAK,IAAI;AAAA,EACpC;AAEA,MAAI;AACF,kCAAU,mBAAmB,GAAG,EAAE,WAAW,KAAK,CAAC;AACnD,sCAAc,kBAAkB,OAAO,IAAI,GAAG,KAAK,UAAU,MAAM,CAAC;AAAA,EACtE,SAAS,OAAgB;AACvB,wBAAI,8DAA8D,OAAO,OAAO,IAAI,CAAC,KAAK,gBAAgB,KAAK,CAAC,EAAE;AAAA,EACpH;AACF;AAEA,SAAS,aAAa,OAAoC;AACxD,SAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,UAAU,QAAQ,OAAO,MAAM,IAAI,IAAI;AAC/F;AAEA,SAAS,gBAAgB,OAAwB;AAC/C,SAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AAC9D;AAEA,SAAS,qBAA6B;AACpC,aAAO,2BAAK,uBAAO,GAAG,eAAe;AACvC;AAEA,SAAS,kBAAkB,MAAsB;AAC/C,aAAO,uBAAK,mBAAmB,GAAG,GAAG,OAAO,IAAI,CAAC,GAAG,kBAAkB,EAAE;AAC1E;AAEA,SAAS,YAAY,QAAiB,MAA8C;AAClF,MAAI,OAAO,WAAW,YAAY,WAAW,MAAM;AACjD,WAAO;AAAA,EACT;AAEA,QAAM,SAAS;AACf,QAAM,EAAE,KAAK,MAAM,YAAY,wBAAwB,IAAI;AAE3D,MAAI,OAAO,QAAQ,YAAY,OAAO,4BAA4B,YAAY,eAAe,MAAM;AACjG,WAAO;AAAA,EACT;AAEA,SAAO,EAAE,KAAK,MAAM,wBAAwB;AAC9C;",
  "names": ["process"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/appium-server-marker.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Records which Appium server on a port this harness started, so a later run\n * that finds a server already listening can tell **provenance**: one of our own\n * servers left over from an earlier run, or a foreign one the user manages.\n *\n * The preflight adopts any server that answers `/status`, and adoption is the\n * right default \u2014 starting a second server on an occupied port cannot work. But\n * adopting silently means a wedged leftover (see `wedged-appium-server.ts`) is\n * indistinguishable from a healthy server, and the harness has no basis on which\n * to decide whether restarting it is its call to make. The marker supplies that\n * basis: a server we started may be restarted, a foreign one is only ever\n * reported.\n *\n * The marker is a small JSON sentinel next to the setup lock (`setup-lock.ts`),\n * keyed by port, and is deliberately tolerant \u2014 a missing, unreadable, or\n * mismatched marker simply reads as \"not ours\".\n */\n\nimport {\n  mkdirSync,\n  readFileSync,\n  rmSync,\n  writeFileSync\n} from 'node:fs';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\n\nimport { log } from './log.cjs';\nimport { checkIsProcessAlive } from './process-liveness.cjs';\n\nconst MARKER_DIR_NAME = 'obsidian-integration-testing';\nconst MARKER_FILE_SUFFIX = '.appium-server.json';\n\n/**\n * Identifies the Appium server this harness started on a port.\n */\nexport interface AppiumServerMarker {\n  /**\n  PID of the spawned server process (the shell wrapper that owns the server's process tree).\n   */\n  readonly pid: number;\n\n  /**\n  The port the server was started on.\n   */\n  readonly port: number;\n\n  /**\n  When the server was started (`Date.now()` epoch milliseconds).\n   */\n  readonly startedAtInMilliseconds: number;\n\n  /**\n   * When a run tried to stop this server and could not verify it exited\n   * (`Date.now()` epoch milliseconds), or `undefined` when no stop has failed.\n   *\n   * Its presence means the server is a **known-doomed leftover**: it was ours,\n   * we asked it to die, and it did not. See {@link recordAppiumServerStopAttempt}.\n   */\n  readonly stopAttemptedAtInMilliseconds?: number | undefined;\n}\n\n/**\n * Parameters for {@link writeAppiumServerMarker}.\n */\nexport interface WriteAppiumServerMarkerParams {\n  /**\n  PID of the spawned server process.\n   */\n  readonly pid: number;\n\n  /**\n  The port the server was started on.\n   */\n  readonly port: number;\n}\n\n/**\n * Checks whether the marked server is still running, which is what makes an\n * adopted server ours to restart.\n *\n * A dead PID means the marker outlived its server, so whatever answers on that\n * port now is somebody else's \u2014 the marker proves nothing about it.\n *\n * @param marker - The marker read for the port, or `undefined` when there is none.\n * @returns `true` when an earlier run of this harness started the server now listening.\n */\nexport function checkIsHarnessOwnedAppiumServer(marker: AppiumServerMarker | undefined): boolean {\n  if (!marker) {\n    return false;\n  }\n\n  return checkIsProcessAlive(marker.pid);\n}\n\n/**\n * Removes the marker for a port. Called once the marked server has been stopped,\n * so a later run does not mistake a recycled PID for our server.\n *\n * @param port - The Appium server port.\n */\nexport function clearAppiumServerMarker(port: number): void {\n  try {\n    rmSync(getMarkerFilePath(port), { force: true });\n  } catch (error: unknown) {\n    log(`[appium-server-marker] Could not remove the marker for port ${String(port)}: ${getErrorMessage(error)}`);\n  }\n}\n\n/**\n * Reads the marker for a port.\n *\n * @param port - The Appium server port.\n * @returns The marker, or `undefined` when there is none, it is unreadable, or it does not describe this port.\n */\nexport function readAppiumServerMarker(port: number): AppiumServerMarker | undefined {\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(readFileSync(getMarkerFilePath(port), 'utf-8'));\n  } catch {\n    return undefined;\n  }\n\n  return parseMarker(parsed, port);\n}\n\n/**\n * Records that a run tried to stop the marked server and could not verify it\n * exited \u2014 **instead of** clearing the marker.\n *\n * Clearing it would be the worst of both worlds: the leftover keeps serving, and\n * the next run reads it as a foreign, user-managed server it must never touch\n * (`checkIsHarnessOwnedAppiumServer` needs the marker to convict it). Keeping\n * the marker, stamped, says exactly what is true \u2014 this is ours, and it outlived\n * our teardown \u2014 which is what lets the next run refuse to adopt it and replace\n * it instead.\n *\n * @param port - The Appium server port.\n */\nexport function recordAppiumServerStopAttempt(port: number): void {\n  const marker = readAppiumServerMarker(port);\n  if (!marker) {\n    return;\n  }\n\n  writeMarker({ ...marker, stopAttemptedAtInMilliseconds: Date.now() });\n}\n\n/**\n * Records the server this run just started, stamping it with the current time so\n * a later run can report how long it has been up.\n *\n * @param params - The started server's PID and port.\n */\nexport function writeAppiumServerMarker(params: WriteAppiumServerMarkerParams): void {\n  writeMarker({\n    pid: params.pid,\n    port: params.port,\n    startedAtInMilliseconds: Date.now()\n  });\n}\n\nfunction getErrorMessage(error: unknown): string {\n  return error instanceof Error ? error.message : String(error);\n}\n\nfunction getMarkerDirectory(): string {\n  return join(tmpdir(), MARKER_DIR_NAME);\n}\n\nfunction getMarkerFilePath(port: number): string {\n  return join(getMarkerDirectory(), `${String(port)}${MARKER_FILE_SUFFIX}`);\n}\n\nfunction parseMarker(parsed: unknown, port: number): AppiumServerMarker | undefined {\n  if (typeof parsed !== 'object' || parsed === null) {\n    return undefined;\n  }\n\n  const record = parsed as Record<string, unknown>;\n  const { pid, port: markedPort, startedAtInMilliseconds, stopAttemptedAtInMilliseconds } = record;\n\n  if (typeof pid !== 'number' || typeof startedAtInMilliseconds !== 'number' || markedPort !== port) {\n    return undefined;\n  }\n\n  return {\n    pid,\n    port,\n    startedAtInMilliseconds,\n    ...(typeof stopAttemptedAtInMilliseconds === 'number' && { stopAttemptedAtInMilliseconds })\n  };\n}\n\nfunction writeMarker(marker: AppiumServerMarker): void {\n  try {\n    mkdirSync(getMarkerDirectory(), { recursive: true });\n    writeFileSync(getMarkerFilePath(marker.port), JSON.stringify(marker));\n  } catch (error: unknown) {\n    log(`[appium-server-marker] Could not record the server on port ${String(marker.port)}: ${getErrorMessage(error)}`);\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAoBA,qBAKO;AACP,qBAAuB;AACvB,uBAAqB;AAErB,iBAAoB;AACpB,8BAAoC;AAEpC,MAAM,kBAAkB;AACxB,MAAM,qBAAqB;AAwDpB,SAAS,gCAAgC,QAAiD;AAC/F,MAAI,CAAC,QAAQ;AACX,WAAO;AAAA,EACT;AAEA,aAAO,6CAAoB,OAAO,GAAG;AACvC;AAQO,SAAS,wBAAwB,MAAoB;AAC1D,MAAI;AACF,+BAAO,kBAAkB,IAAI,GAAG,EAAE,OAAO,KAAK,CAAC;AAAA,EACjD,SAAS,OAAgB;AACvB,wBAAI,+DAA+D,OAAO,IAAI,CAAC,KAAK,gBAAgB,KAAK,CAAC,EAAE;AAAA,EAC9G;AACF;AAQO,SAAS,uBAAuB,MAA8C;AACnF,MAAI;AACJ,MAAI;AACF,aAAS,KAAK,UAAM,6BAAa,kBAAkB,IAAI,GAAG,OAAO,CAAC;AAAA,EACpE,QAAQ;AACN,WAAO;AAAA,EACT;AAEA,SAAO,YAAY,QAAQ,IAAI;AACjC;AAeO,SAAS,8BAA8B,MAAoB;AAChE,QAAM,SAAS,uBAAuB,IAAI;AAC1C,MAAI,CAAC,QAAQ;AACX;AAAA,EACF;AAEA,cAAY,EAAE,GAAG,QAAQ,+BAA+B,KAAK,IAAI,EAAE,CAAC;AACtE;AAQO,SAAS,wBAAwB,QAA6C;AACnF,cAAY;AAAA,IACV,KAAK,OAAO;AAAA,IACZ,MAAM,OAAO;AAAA,IACb,yBAAyB,KAAK,IAAI;AAAA,EACpC,CAAC;AACH;AAEA,SAAS,gBAAgB,OAAwB;AAC/C,SAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AAC9D;AAEA,SAAS,qBAA6B;AACpC,aAAO,2BAAK,uBAAO,GAAG,eAAe;AACvC;AAEA,SAAS,kBAAkB,MAAsB;AAC/C,aAAO,uBAAK,mBAAmB,GAAG,GAAG,OAAO,IAAI,CAAC,GAAG,kBAAkB,EAAE;AAC1E;AAEA,SAAS,YAAY,QAAiB,MAA8C;AAClF,MAAI,OAAO,WAAW,YAAY,WAAW,MAAM;AACjD,WAAO;AAAA,EACT;AAEA,QAAM,SAAS;AACf,QAAM,EAAE,KAAK,MAAM,YAAY,yBAAyB,8BAA8B,IAAI;AAE1F,MAAI,OAAO,QAAQ,YAAY,OAAO,4BAA4B,YAAY,eAAe,MAAM;AACjG,WAAO;AAAA,EACT;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA,GAAI,OAAO,kCAAkC,YAAY,EAAE,8BAA8B;AAAA,EAC3F;AACF;AAEA,SAAS,YAAY,QAAkC;AACrD,MAAI;AACF,kCAAU,mBAAmB,GAAG,EAAE,WAAW,KAAK,CAAC;AACnD,sCAAc,kBAAkB,OAAO,IAAI,GAAG,KAAK,UAAU,MAAM,CAAC;AAAA,EACtE,SAAS,OAAgB;AACvB,wBAAI,8DAA8D,OAAO,OAAO,IAAI,CAAC,KAAK,gBAAgB,KAAK,CAAC,EAAE;AAAA,EACpH;AACF;",
  "names": []
}


package/dist/lib/cjs/appium-server-marker.d.cts

@@ -33,6 +33,14 @@ export interface AppiumServerMarker {
     When the server was started (`Date.now()` epoch milliseconds).
      */
     readonly startedAtInMilliseconds: number;
+    /**
+     * When a run tried to stop this server and could not verify it exited
+     * (`Date.now()` epoch milliseconds), or `undefined` when no stop has failed.
+     *
+     * Its presence means the server is a **known-doomed leftover**: it was ours,
+     * we asked it to die, and it did not. See {@link recordAppiumServerStopAttempt}.
+     */
+    readonly stopAttemptedAtInMilliseconds?: number | undefined;
 }
 /**
  * Parameters for {@link writeAppiumServerMarker}.
@@ -72,6 +80,20 @@ export declare function clearAppiumServerMarker(port: number): void;
  * @returns The marker, or `undefined` when there is none, it is unreadable, or it does not describe this port.
  */
 export declare function readAppiumServerMarker(port: number): AppiumServerMarker | undefined;
+/**
+ * Records that a run tried to stop the marked server and could not verify it
+ * exited — **instead of** clearing the marker.
+ *
+ * Clearing it would be the worst of both worlds: the leftover keeps serving, and
+ * the next run reads it as a foreign, user-managed server it must never touch
+ * (`checkIsHarnessOwnedAppiumServer` needs the marker to convict it). Keeping
+ * the marker, stamped, says exactly what is true — this is ours, and it outlived
+ * our teardown — which is what lets the next run refuse to adopt it and replace
+ * it instead.
+ *
+ * @param port - The Appium server port.
+ */
+export declare function recordAppiumServerStopAttempt(port: number): void;
 /**
  * Records the server this run just started, stamping it with the current time so
  * a later run can report how long it has been up.

package/dist/lib/cjs/avd-probe-verdict.cjs

@@ -0,0 +1,90 @@
+"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 avd_probe_verdict_exports = {};
+__export(avd_probe_verdict_exports, {
+  buildAvdProbeSummary: () => buildAvdProbeSummary,
+  buildUnreadableDevicesMessage: () => buildUnreadableDevicesMessage,
+  checkIsEmulatorDeviceId: () => checkIsEmulatorDeviceId,
+  classifyAvdProbe: () => classifyAvdProbe,
+  resolveAvdProbeVerdict: () => resolveAvdProbeVerdict
+});
+module.exports = __toCommonJS(avd_probe_verdict_exports);
+var import_type_guards = require("./type-guards.cjs");
+const EMULATOR_DEVICE_ID_PATTERN = /^emulator-\d+$/;
+function buildAvdProbeSummary(results) {
+  if (results.length === 0) {
+    return "no devices";
+  }
+  return results.map((result) => `${result.deviceId}=${result.outcome}`).join(", ");
+}
+function buildUnreadableDevicesMessage(params) {
+  const deviceList = params.unreadableDeviceIds.join(", ");
+  const isSingle = params.unreadableDeviceIds.length === 1;
+  const subject = isSingle ? `device ${deviceList}` : `devices ${deviceList}`;
+  const command = isSingle ? `adb -s ${deviceList} emu avd name` : "adb -s <device> emu avd name";
+  const holder = isSingle ? "it is" : "one of them is";
+  const remedy = isSingle ? "Kill the unresponsive device" : "Kill the unresponsive devices";
+  return `AVD "${params.avdName}": ${subject} did not answer \`${command}\` within ${String(params.probeTimeoutInMilliseconds)}ms (retried once), so this run cannot tell whether ${holder} already serving that AVD. Starting an emulator anyway would collide (\`FATAL | Running multiple emulators with the same AVD is an experimental feature\`), which the emulator reports only to its own stdout. ${remedy}, or run \`adb kill-server\`, then retry.`;
+}
+function checkIsEmulatorDeviceId(deviceId) {
+  return EMULATOR_DEVICE_ID_PATTERN.test(deviceId);
+}
+function classifyAvdProbe(params) {
+  if (!checkIsEmulatorDeviceId(params.deviceId)) {
+    return "not-an-emulator";
+  }
+  if (params.probedAvdName === void 0 || params.probedAvdName.length === 0) {
+    return "no-answer";
+  }
+  return params.probedAvdName === params.avdName ? "match" : "other-avd";
+}
+function resolveAvdProbeVerdict(results) {
+  const unreadableDeviceIds = [];
+  for (const result of results) {
+    switch (result.outcome) {
+      case "match": {
+        return { deviceId: result.deviceId, verdict: "reuse" };
+      }
+      case "no-answer": {
+        unreadableDeviceIds.push(result.deviceId);
+        break;
+      }
+      case "not-an-emulator":
+      case "other-avd": {
+        break;
+      }
+      default: {
+        return (0, import_type_guards.assertNever)(result.outcome);
+      }
+    }
+  }
+  if (unreadableDeviceIds.length > 0) {
+    return { unreadableDeviceIds, verdict: "refuse" };
+  }
+  return { verdict: "start-new" };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildAvdProbeSummary,
+  buildUnreadableDevicesMessage,
+  checkIsEmulatorDeviceId,
+  classifyAvdProbe,
+  resolveAvdProbeVerdict
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/avd-probe-verdict.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure classification of the AVD adoption probe \u2014 deciding, from what each\n * connected device answered, whether this run may reuse one, must start its\n * own emulator, or cannot safely do either.\n *\n * The probe (`adb -s <device> emu avd name`) used to discard its error and\n * resolve `''`, so a call that **never answered** was indistinguishable from one\n * that answered *\"a different AVD\"*. Both fell through to \"start a new\n * emulator\", which collides with the emulator already serving that AVD:\n *\n * ```text\n * 14:27:52.114  Checking existing devices for AVD \"obsidian_test\"... (connected: [emulator-5554])\n * 14:27:57.170  AVD \"obsidian_test\" not found on any existing device, starting a new emulator...\n * ```\n *\n * 5.056s apart \u2014 exactly the probe's own timeout. The launch that followed hit\n * `FATAL | Running multiple emulators with the same AVD is an experimental\n * feature`, which the emulator writes to its own stdout. **A probe that never\n * answered is not evidence that the answer is no** \u2014 the same distinction\n * `adb-device-list.ts` draws between `offline` and absent, and the same one\n * the connectivity probe draws between a failed dump and a missing network.\n *\n * Worse, the probe is asked its question precisely when the guest is least able\n * to answer it \u2014 a wedged emulator times out every `adb` call \u2014 which is the\n * condition under which a colliding launch does the most damage.\n *\n * Kept separate from the integration-only `transport-factory` (excluded from\n * unit tests) so the classification stays unit-testable \u2014 the factory itself\n * shells out to `adb`.\n */\n\nimport { assertNever } from './type-guards.cjs';\n\n/**\n * What one device answered when asked which AVD it is serving.\n *\n * `not-an-emulator` and `other-avd` are both legitimate skips; only\n * `no-answer` is the silence that must never be read as one.\n */\nexport type AvdProbeOutcome = 'match' | 'no-answer' | 'not-an-emulator' | 'other-avd';\n\n/**\n * The run cannot tell whether the AVD is already running, so it must not launch.\n */\nexport interface AvdProbeRefuseVerdict {\n  /**\n  The devices that could not be read, and therefore cannot be ruled out as the AVD's holder.\n   */\n  readonly unreadableDeviceIds: string[];\n\n  /**\n  Discriminant.\n   */\n  readonly verdict: 'refuse';\n}\n\n/**\n * One device's probe outcome.\n */\nexport interface AvdProbeResult {\n  /**\n  The device UDID, e.g. `emulator-5554`.\n   */\n  readonly deviceId: string;\n\n  /**\n  What the device answered.\n   */\n  readonly outcome: AvdProbeOutcome;\n}\n\n/**\n * The AVD is already running, on a device this run may adopt.\n */\nexport interface AvdProbeReuseVerdict {\n  /**\n  The device already serving the requested AVD.\n   */\n  readonly deviceId: string;\n\n  /**\n  Discriminant.\n   */\n  readonly verdict: 'reuse';\n}\n\n/**\n * Every device answered, none is serving the AVD, so launching cannot collide.\n */\nexport interface AvdProbeStartNewVerdict {\n  /**\n  Discriminant.\n   */\n  readonly verdict: 'start-new';\n}\n\n/**\n * What the run may do, given every device's probe outcome.\n */\nexport type AvdProbeVerdict = AvdProbeRefuseVerdict | AvdProbeReuseVerdict | AvdProbeStartNewVerdict;\n\n/**\n * Parameters for {@link buildUnreadableDevicesMessage}.\n */\nexport interface BuildUnreadableDevicesMessageParams {\n  /**\n  The AVD the run wanted.\n   */\n  readonly avdName: string;\n\n  /**\n  The budget each probe attempt was given, in milliseconds.\n   */\n  readonly probeTimeoutInMilliseconds: number;\n\n  /**\n  The devices that did not answer.\n   */\n  readonly unreadableDeviceIds: readonly string[];\n}\n\n/**\n * Parameters for {@link classifyAvdProbe}.\n */\nexport interface ClassifyAvdProbeParams {\n  /**\n  The AVD the run wants.\n   */\n  readonly avdName: string;\n\n  /**\n  The device that was probed.\n   */\n  readonly deviceId: string;\n\n  /**\n  The AVD name the device answered, or `undefined` when it did not answer at all.\n   */\n  readonly probedAvdName?: string | undefined;\n}\n\n/**\n * Matches the device IDs adb gives emulators started the way this harness\n * starts them: `emulator -avd <name>`, whose console lands on a local port.\n *\n * Only such a device can collide with this run's launch, so only such a device's\n * silence is worth refusing over. A physical handset (an arbitrary serial) or a\n * TCP-attached device answers `adb \u2026 emu avd name` with an error however healthy\n * it is; reading that as \"did not answer\" would block every run on a host with a\n * phone plugged in, which is a worse defect than the one this module fixes.\n */\nconst EMULATOR_DEVICE_ID_PATTERN = /^emulator-\\d+$/;\n\n/**\n * Builds the summary line naming what each device answered.\n *\n * The old log printed only the conclusion (`not found on any existing device`),\n * which is exactly the line that was wrong; printing the evidence next to it is\n * what makes a bad conclusion visible without a second run.\n *\n * @param results - Every device's probe outcome.\n * @returns The summary, or `no devices` when nothing was connected.\n */\nexport function buildAvdProbeSummary(results: readonly AvdProbeResult[]): string {\n  if (results.length === 0) {\n    return 'no devices';\n  }\n\n  return results.map((result) => `${result.deviceId}=${result.outcome}`).join(', ');\n}\n\n/**\n * Builds the refusal message for devices that could not be read.\n *\n * Names the device, the AVD, the budget, the consequence and the recovery \u2014 the\n * shape `teardown-verdict.ts` uses for its own warning, because a message that\n * stops a run has to leave the reader able to unblock it.\n *\n * @param params - The AVD, the probe budget, and the devices that did not answer.\n * @returns The refusal message.\n */\nexport function buildUnreadableDevicesMessage(params: BuildUnreadableDevicesMessageParams): string {\n  /*\n   * When there is exactly one device the joined list IS its ID, so the singular\n   * wording needs no index access \u2014 and no unreachable fallback for one.\n   */\n  const deviceList = params.unreadableDeviceIds.join(', ');\n  const isSingle = params.unreadableDeviceIds.length === 1;\n\n  const subject = isSingle ? `device ${deviceList}` : `devices ${deviceList}`;\n  const command = isSingle ? `adb -s ${deviceList} emu avd name` : 'adb -s <device> emu avd name';\n  const holder = isSingle ? 'it is' : 'one of them is';\n  const remedy = isSingle ? 'Kill the unresponsive device' : 'Kill the unresponsive devices';\n\n  return `AVD \"${params.avdName}\": ${subject} did not answer \\`${command}\\` within ${String(params.probeTimeoutInMilliseconds)}ms (retried once), `\n    + `so this run cannot tell whether ${holder} already serving that AVD. Starting an emulator anyway would collide `\n    + '(`FATAL | Running multiple emulators with the same AVD is an experimental feature`), which the emulator reports only to its own stdout. '\n    + `${remedy}, or run \\`adb kill-server\\`, then retry.`;\n}\n\n/**\n * Decides whether a device can hold an AVD this run could collide with.\n *\n * @param deviceId - The device UDID to judge.\n * @returns `true` for a locally started emulator, whose console this run can ask.\n */\nexport function checkIsEmulatorDeviceId(deviceId: string): boolean {\n  return EMULATOR_DEVICE_ID_PATTERN.test(deviceId);\n}\n\n/**\n * Classifies one device's probe.\n *\n * @param params - The AVD wanted, the device probed, and what it answered.\n * @returns The outcome.\n */\nexport function classifyAvdProbe(params: ClassifyAvdProbeParams): AvdProbeOutcome {\n  if (!checkIsEmulatorDeviceId(params.deviceId)) {\n    return 'not-an-emulator';\n  }\n\n  if (params.probedAvdName === undefined || params.probedAvdName.length === 0) {\n    return 'no-answer';\n  }\n\n  return params.probedAvdName === params.avdName ? 'match' : 'other-avd';\n}\n\n/**\n * Decides what the run may do, from every device's probe outcome.\n *\n * **A match wins over an unreadable sibling.** Once the requested AVD is found\n * and reusable, an unrelated wedged device is somebody else's problem and must\n * not block a run that has everything it needs \u2014 the same restraint\n * `emulator-backend.ts` shows in never sweeping a `qemu*` it does not own. Only\n * when nothing matched does silence become decisive, because only then would the\n * run go on to launch.\n *\n * @param results - Every device's probe outcome.\n * @returns The verdict.\n */\nexport function resolveAvdProbeVerdict(results: readonly AvdProbeResult[]): AvdProbeVerdict {\n  const unreadableDeviceIds: string[] = [];\n\n  for (const result of results) {\n    switch (result.outcome) {\n      case 'match': {\n        return { deviceId: result.deviceId, verdict: 'reuse' };\n      }\n      case 'no-answer': {\n        unreadableDeviceIds.push(result.deviceId);\n        break;\n      }\n      case 'not-an-emulator':\n      case 'other-avd': {\n        break;\n      }\n      default: {\n        return assertNever(result.outcome);\n      }\n    }\n  }\n\n  if (unreadableDeviceIds.length > 0) {\n    return { unreadableDeviceIds, verdict: 'refuse' };\n  }\n\n  return { verdict: 'start-new' };\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAiCA,yBAA4B;AAwH5B,MAAM,6BAA6B;AAY5B,SAAS,qBAAqB,SAA4C;AAC/E,MAAI,QAAQ,WAAW,GAAG;AACxB,WAAO;AAAA,EACT;AAEA,SAAO,QAAQ,IAAI,CAAC,WAAW,GAAG,OAAO,QAAQ,IAAI,OAAO,OAAO,EAAE,EAAE,KAAK,IAAI;AAClF;AAYO,SAAS,8BAA8B,QAAqD;AAKjG,QAAM,aAAa,OAAO,oBAAoB,KAAK,IAAI;AACvD,QAAM,WAAW,OAAO,oBAAoB,WAAW;AAEvD,QAAM,UAAU,WAAW,UAAU,UAAU,KAAK,WAAW,UAAU;AACzE,QAAM,UAAU,WAAW,UAAU,UAAU,kBAAkB;AACjE,QAAM,SAAS,WAAW,UAAU;AACpC,QAAM,SAAS,WAAW,iCAAiC;AAE3D,SAAO,QAAQ,OAAO,OAAO,MAAM,OAAO,qBAAqB,OAAO,aAAa,OAAO,OAAO,0BAA0B,CAAC,sDACrF,MAAM,kNAEtC,MAAM;AACf;AAQO,SAAS,wBAAwB,UAA2B;AACjE,SAAO,2BAA2B,KAAK,QAAQ;AACjD;AAQO,SAAS,iBAAiB,QAAiD;AAChF,MAAI,CAAC,wBAAwB,OAAO,QAAQ,GAAG;AAC7C,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,kBAAkB,UAAa,OAAO,cAAc,WAAW,GAAG;AAC3E,WAAO;AAAA,EACT;AAEA,SAAO,OAAO,kBAAkB,OAAO,UAAU,UAAU;AAC7D;AAeO,SAAS,uBAAuB,SAAqD;AAC1F,QAAM,sBAAgC,CAAC;AAEvC,aAAW,UAAU,SAAS;AAC5B,YAAQ,OAAO,SAAS;AAAA,MACtB,KAAK,SAAS;AACZ,eAAO,EAAE,UAAU,OAAO,UAAU,SAAS,QAAQ;AAAA,MACvD;AAAA,MACA,KAAK,aAAa;AAChB,4BAAoB,KAAK,OAAO,QAAQ;AACxC;AAAA,MACF;AAAA,MACA,KAAK;AAAA,MACL,KAAK,aAAa;AAChB;AAAA,MACF;AAAA,MACA,SAAS;AACP,mBAAO,gCAAY,OAAO,OAAO;AAAA,MACnC;AAAA,IACF;AAAA,EACF;AAEA,MAAI,oBAAoB,SAAS,GAAG;AAClC,WAAO,EAAE,qBAAqB,SAAS,SAAS;AAAA,EAClD;AAEA,SAAO,EAAE,SAAS,YAAY;AAChC;",
  "names": []
}


package/dist/lib/cjs/avd-probe-verdict.d.cts

@@ -0,0 +1,175 @@
+/**
+ * @file
+ *
+ * Pure classification of the AVD adoption probe — deciding, from what each
+ * connected device answered, whether this run may reuse one, must start its
+ * own emulator, or cannot safely do either.
+ *
+ * The probe (`adb -s <device> emu avd name`) used to discard its error and
+ * resolve `''`, so a call that **never answered** was indistinguishable from one
+ * that answered *"a different AVD"*. Both fell through to "start a new
+ * emulator", which collides with the emulator already serving that AVD:
+ *
+ * ```text
+ * 14:27:52.114  Checking existing devices for AVD "obsidian_test"... (connected: [emulator-5554])
+ * 14:27:57.170  AVD "obsidian_test" not found on any existing device, starting a new emulator...
+ * ```
+ *
+ * 5.056s apart — exactly the probe's own timeout. The launch that followed hit
+ * `FATAL | Running multiple emulators with the same AVD is an experimental
+ * feature`, which the emulator writes to its own stdout. **A probe that never
+ * answered is not evidence that the answer is no** — the same distinction
+ * `adb-device-list.ts` draws between `offline` and absent, and the same one
+ * the connectivity probe draws between a failed dump and a missing network.
+ *
+ * Worse, the probe is asked its question precisely when the guest is least able
+ * to answer it — a wedged emulator times out every `adb` call — which is the
+ * condition under which a colliding launch does the most damage.
+ *
+ * Kept separate from the integration-only `transport-factory` (excluded from
+ * unit tests) so the classification stays unit-testable — the factory itself
+ * shells out to `adb`.
+ */
+/**
+ * What one device answered when asked which AVD it is serving.
+ *
+ * `not-an-emulator` and `other-avd` are both legitimate skips; only
+ * `no-answer` is the silence that must never be read as one.
+ */
+export type AvdProbeOutcome = 'match' | 'no-answer' | 'not-an-emulator' | 'other-avd';
+/**
+ * The run cannot tell whether the AVD is already running, so it must not launch.
+ */
+export interface AvdProbeRefuseVerdict {
+    /**
+    The devices that could not be read, and therefore cannot be ruled out as the AVD's holder.
+     */
+    readonly unreadableDeviceIds: string[];
+    /**
+    Discriminant.
+     */
+    readonly verdict: 'refuse';
+}
+/**
+ * One device's probe outcome.
+ */
+export interface AvdProbeResult {
+    /**
+    The device UDID, e.g. `emulator-5554`.
+     */
+    readonly deviceId: string;
+    /**
+    What the device answered.
+     */
+    readonly outcome: AvdProbeOutcome;
+}
+/**
+ * The AVD is already running, on a device this run may adopt.
+ */
+export interface AvdProbeReuseVerdict {
+    /**
+    The device already serving the requested AVD.
+     */
+    readonly deviceId: string;
+    /**
+    Discriminant.
+     */
+    readonly verdict: 'reuse';
+}
+/**
+ * Every device answered, none is serving the AVD, so launching cannot collide.
+ */
+export interface AvdProbeStartNewVerdict {
+    /**
+    Discriminant.
+     */
+    readonly verdict: 'start-new';
+}
+/**
+ * What the run may do, given every device's probe outcome.
+ */
+export type AvdProbeVerdict = AvdProbeRefuseVerdict | AvdProbeReuseVerdict | AvdProbeStartNewVerdict;
+/**
+ * Parameters for {@link buildUnreadableDevicesMessage}.
+ */
+export interface BuildUnreadableDevicesMessageParams {
+    /**
+    The AVD the run wanted.
+     */
+    readonly avdName: string;
+    /**
+    The budget each probe attempt was given, in milliseconds.
+     */
+    readonly probeTimeoutInMilliseconds: number;
+    /**
+    The devices that did not answer.
+     */
+    readonly unreadableDeviceIds: readonly string[];
+}
+/**
+ * Parameters for {@link classifyAvdProbe}.
+ */
+export interface ClassifyAvdProbeParams {
+    /**
+    The AVD the run wants.
+     */
+    readonly avdName: string;
+    /**
+    The device that was probed.
+     */
+    readonly deviceId: string;
+    /**
+    The AVD name the device answered, or `undefined` when it did not answer at all.
+     */
+    readonly probedAvdName?: string | undefined;
+}
+/**
+ * Builds the summary line naming what each device answered.
+ *
+ * The old log printed only the conclusion (`not found on any existing device`),
+ * which is exactly the line that was wrong; printing the evidence next to it is
+ * what makes a bad conclusion visible without a second run.
+ *
+ * @param results - Every device's probe outcome.
+ * @returns The summary, or `no devices` when nothing was connected.
+ */
+export declare function buildAvdProbeSummary(results: readonly AvdProbeResult[]): string;
+/**
+ * Builds the refusal message for devices that could not be read.
+ *
+ * Names the device, the AVD, the budget, the consequence and the recovery — the
+ * shape `teardown-verdict.ts` uses for its own warning, because a message that
+ * stops a run has to leave the reader able to unblock it.
+ *
+ * @param params - The AVD, the probe budget, and the devices that did not answer.
+ * @returns The refusal message.
+ */
+export declare function buildUnreadableDevicesMessage(params: BuildUnreadableDevicesMessageParams): string;
+/**
+ * Decides whether a device can hold an AVD this run could collide with.
+ *
+ * @param deviceId - The device UDID to judge.
+ * @returns `true` for a locally started emulator, whose console this run can ask.
+ */
+export declare function checkIsEmulatorDeviceId(deviceId: string): boolean;
+/**
+ * Classifies one device's probe.
+ *
+ * @param params - The AVD wanted, the device probed, and what it answered.
+ * @returns The outcome.
+ */
+export declare function classifyAvdProbe(params: ClassifyAvdProbeParams): AvdProbeOutcome;
+/**
+ * Decides what the run may do, from every device's probe outcome.
+ *
+ * **A match wins over an unreadable sibling.** Once the requested AVD is found
+ * and reusable, an unrelated wedged device is somebody else's problem and must
+ * not block a run that has everything it needs — the same restraint
+ * `emulator-backend.ts` shows in never sweeping a `qemu*` it does not own. Only
+ * when nothing matched does silence become decisive, because only then would the
+ * run go on to launch.
+ *
+ * @param results - Every device's probe outcome.
+ * @returns The verdict.
+ */
+export declare function resolveAvdProbeVerdict(results: readonly AvdProbeResult[]): AvdProbeVerdict;

package/dist/lib/cjs/community-plugin-registry.cjs

@@ -49,4 +49,4 @@ function selectPluginRepo(params) {
   isValidRepoReference,
   selectPluginRepo
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/community-plugin-registry.d.cts

@@ -5,7 +5,7 @@
  * nothing but its plugin id — the id → repo lookup and the asset URL shapes.
  *
  * A plugin's built files never live in git: `.obsidian/plugins/*` is gitignored in
- * every fleet plugin repo, so a demo vault's injected community plugins exist on
+ * a plugin repo, so a demo vault's injected community plugins exist on
  * exactly the machine that once opened that vault in Obsidian. To install them
  * headlessly (see `demo-vault-bootstrap.ts`) two things must be derivable:
  *

package/dist/lib/cjs/config-directory-fallback-error.cjs

@@ -0,0 +1,57 @@
+"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 config_directory_fallback_error_exports = {};
+__export(config_directory_fallback_error_exports, {
+  ConfigDirectoryFallbackError: () => ConfigDirectoryFallbackError
+});
+module.exports = __toCommonJS(config_directory_fallback_error_exports);
+class ConfigDirectoryFallbackError extends Error {
+  /**
+  The config folder the vault is actually using.
+   */
+  actualConfigDirectory;
+  /**
+  The config folder that was requested.
+   */
+  requestedConfigDirectory;
+  /**
+  Absolute path to the vault that was opened.
+   */
+  vaultPath;
+  /**
+   * Creates the error from the requested and actual config folders.
+   *
+   * @param params - The requested folder, the folder actually in use, and the vault path.
+   */
+  constructor(params) {
+    const { actualConfigDirectory, requestedConfigDirectory, vaultPath } = params;
+    super(
+      `Vault ${vaultPath} was opened with config folder ${actualConfigDirectory} but ${requestedConfigDirectory} was requested \u2014 Obsidian rejected the override or never saw it, and silently fell back. Check that ${requestedConfigDirectory} exists in the vault and is a name Obsidian accepts.`
+    );
+    this.name = "ConfigDirectoryFallbackError";
+    this.actualConfigDirectory = actualConfigDirectory;
+    this.requestedConfigDirectory = requestedConfigDirectory;
+    this.vaultPath = vaultPath;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigDirectoryFallbackError
+});
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2NvbmZpZy1kaXJlY3RvcnktZmFsbGJhY2stZXJyb3IudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBUaGUgZGlzdGluY3QgZXJyb3IgdGhyb3duIHdoZW4gYW4gb3duZWQgT2JzaWRpYW4gaW5zdGFuY2UgYm9vdGVkIGEgdmF1bHRcbiAqIGFnYWluc3QgYSAqKmRpZmZlcmVudCBjb25maWcgZm9sZGVyKiogdGhhbiB0aGUgb25lIHJlcXVlc3RlZCB0aHJvdWdoXG4gKiBgY29uZmlnRGlyZWN0b3J5YCBcdTIwMTQgT2JzaWRpYW4gcmVqZWN0ZWQgdGhlIG92ZXJyaWRlLCBvciBuZXZlciBzYXcgaXQsIGFuZCBzaWxlbnRseVxuICogZmVsbCBiYWNrIHRvIGAub2JzaWRpYW5gLlxuICpcbiAqIFRoZSBmYWxsYmFjayBpcyBzaWxlbnQgYnkgY29uc3RydWN0aW9uIChgc2V0Q29uZmlnRGlyYCBzd2FwcyBhbiBpbnZhbGlkIHZhbHVlXG4gKiBmb3IgdGhlIGRlZmF1bHQgd2l0aG91dCBhIHdvcmQpIGFuZCB0aGUgcmVzdWx0aW5nIHZhdWx0IGxvb2tzIHBlcmZlY3RseVxuICogaGVhbHRoeTogaXQgb3BlbnMsIGl0cyBsYXlvdXQgaXMgcmVhZHksIGFuZCBpdCByZXBvcnRzIHN1Y2Nlc3MuIFdoYXQgaXQgZG9lc1xuICogbm90IGhhdmUgaXMgdGhlIHNldHRpbmdzLCBlbmFibGVkIHBsdWdpbnMsIGFuZCB3b3Jrc3BhY2Ugb2YgdGhlIGZvbGRlciB0aGF0XG4gKiB3YXMgYXNrZWQgZm9yIFx1MjAxNCBzbyBhIHN1aXRlIHRoYXQgdmVyaWZpZXMgYmVoYXZpb3VyIGFnYWluc3QgYSByZWFsIHZhdWx0J3NcbiAqIHBsdWdpbiBzZXQgd291bGQgc2lsZW50bHkgdmVyaWZ5IG5vdGhpbmcuIEhlbmNlIGEgaGFyZCBmYWlsdXJlIHJhdGhlciB0aGFuIGFcbiAqIHdhcm5pbmcsIGFuZCwgdW5saWtlIGBTaWxlbnRBc2FyRmFsbGJhY2tFcnJvcmAsIG5vIGtub2IgdG8gZG93bmdyYWRlIGl0OiB0aGVyZVxuICogaXMgbm8gdmVyc2lvbiBvZiB0aGlzIG91dGNvbWUgd29ydGggY29udGludWluZyBhZ2FpbnN0LlxuICpcbiAqIEV4cG9ydGVkIHNvIGNhbGxlcnMgb2YgYGNvbm5lY3RUb0NkcGAgLyB0aGUgdHJhbnNwb3J0IGNhbiBgaW5zdGFuY2VvZmAtbWF0Y2hcbiAqIHRoaXMgc3BlY2lmaWMgZmFpbHVyZS5cbiAqL1xuXG4vKipcbiAqIFBhcmFtZXRlcnMgZm9yIHRoZSB7QGxpbmsgQ29uZmlnRGlyZWN0b3J5RmFsbGJhY2tFcnJvcn0gY29uc3RydWN0b3IuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQ29uZmlnRGlyZWN0b3J5RmFsbGJhY2tFcnJvckNvbnN0cnVjdG9yUGFyYW1zIHtcbiAgLyoqXG4gIFRoZSBjb25maWcgZm9sZGVyIHRoZSB2YXVsdCBpcyBhY3R1YWxseSB1c2luZywgYXMgcmVhZCBiYWNrIGZyb20gYGFwcC52YXVsdC5jb25maWdEaXJgLlxuICAgKi9cbiAgcmVhZG9ubHkgYWN0dWFsQ29uZmlnRGlyZWN0b3J5OiBzdHJpbmc7XG5cbiAgLyoqXG4gIFRoZSBjb25maWcgZm9sZGVyIHRoYXQgd2FzIHJlcXVlc3RlZCB0aHJvdWdoIGBjb25maWdEaXJlY3RvcnlgLlxuICAgKi9cbiAgcmVhZG9ubHkgcmVxdWVzdGVkQ29uZmlnRGlyZWN0b3J5OiBzdHJpbmc7XG5cbiAgLyoqXG4gIEFic29sdXRlIHBhdGggdG8gdGhlIHZhdWx0IHRoYXQgd2FzIG9wZW5lZC5cbiAgICovXG4gIHJlYWRvbmx5IHZhdWx0UGF0aDogc3RyaW5nO1xufVxuXG4vKipcbiAqIFRocm93biB3aGVuIGEgYm9vdGVkIG93bmVkIGluc3RhbmNlIHJlcG9ydHMgYSBkaWZmZXJlbnQgYGFwcC52YXVsdC5jb25maWdEaXJgXG4gKiB0aGFuIHRoZSByZXF1ZXN0ZWRcbiAqIHtAbGluayBDb25maWdEaXJlY3RvcnlGYWxsYmFja0Vycm9yQ29uc3RydWN0b3JQYXJhbXMucmVxdWVzdGVkQ29uZmlnRGlyZWN0b3J5fS5cbiAqIENhcnJpZXMgYm90aCBmb2xkZXIgbmFtZXMgYW5kIHRoZSB2YXVsdCBwYXRoIHNvIGNhbGxlcnMgY2FuIGBpbnN0YW5jZW9mYC1tYXRjaFxuICogYW5kIHJlcG9ydCB3aGljaCB2YXVsdCB3YXMgb3BlbmVkIHdyb25nbHkuXG4gKi9cbmV4cG9ydCBjbGFzcyBDb25maWdEaXJlY3RvcnlGYWxsYmFja0Vycm9yIGV4dGVuZHMgRXJyb3Ige1xuICAvKipcbiAgVGhlIGNvbmZpZyBmb2xkZXIgdGhlIHZhdWx0IGlzIGFjdHVhbGx5IHVzaW5nLlxuICAgKi9cbiAgcHVibGljIHJlYWRvbmx5IGFjdHVhbENvbmZpZ0RpcmVjdG9yeTogc3RyaW5nO1xuXG4gIC8qKlxuICBUaGUgY29uZmlnIGZvbGRlciB0aGF0IHdhcyByZXF1ZXN0ZWQuXG4gICAqL1xuICBwdWJsaWMgcmVhZG9ubHkgcmVxdWVzdGVkQ29uZmlnRGlyZWN0b3J5OiBzdHJpbmc7XG5cbiAgLyoqXG4gIEFic29sdXRlIHBhdGggdG8gdGhlIHZhdWx0IHRoYXQgd2FzIG9wZW5lZC5cbiAgICovXG4gIHB1YmxpYyByZWFkb25seSB2YXVsdFBhdGg6IHN0cmluZztcblxuICAvKipcbiAgICogQ3JlYXRlcyB0aGUgZXJyb3IgZnJvbSB0aGUgcmVxdWVzdGVkIGFuZCBhY3R1YWwgY29uZmlnIGZvbGRlcnMuXG4gICAqXG4gICAqIEBwYXJhbSBwYXJhbXMgLSBUaGUgcmVxdWVzdGVkIGZvbGRlciwgdGhlIGZvbGRlciBhY3R1YWxseSBpbiB1c2UsIGFuZCB0aGUgdmF1bHQgcGF0aC5cbiAgICovXG4gIHB1YmxpYyBjb25zdHJ1Y3RvcihwYXJhbXM6IENvbmZpZ0RpcmVjdG9yeUZhbGxiYWNrRXJyb3JDb25zdHJ1Y3RvclBhcmFtcykge1xuICAgIGNvbnN0IHsgYWN0dWFsQ29uZmlnRGlyZWN0b3J5LCByZXF1ZXN0ZWRDb25maWdEaXJlY3RvcnksIHZhdWx0UGF0aCB9ID0gcGFyYW1zO1xuICAgIHN1cGVyKFxuICAgICAgYFZhdWx0ICR7dmF1bHRQYXRofSB3YXMgb3BlbmVkIHdpdGggY29uZmlnIGZvbGRlciAke2FjdHVhbENvbmZpZ0RpcmVjdG9yeX0gYnV0ICR7cmVxdWVzdGVkQ29uZmlnRGlyZWN0b3J5fSB3YXMgcmVxdWVzdGVkIFx1MjAxNCBgXG4gICAgICAgICsgJ09ic2lkaWFuIHJlamVjdGVkIHRoZSBvdmVycmlkZSBvciBuZXZlciBzYXcgaXQsIGFuZCBzaWxlbnRseSBmZWxsIGJhY2suICdcbiAgICAgICAgKyBgQ2hlY2sgdGhhdCAke3JlcXVlc3RlZENvbmZpZ0RpcmVjdG9yeX0gZXhpc3RzIGluIHRoZSB2YXVsdCBhbmQgaXMgYSBuYW1lIE9ic2lkaWFuIGFjY2VwdHMuYFxuICAgICk7XG4gICAgdGhpcy5uYW1lID0gJ0NvbmZpZ0RpcmVjdG9yeUZhbGxiYWNrRXJyb3InO1xuICAgIHRoaXMuYWN0dWFsQ29uZmlnRGlyZWN0b3J5ID0gYWN0dWFsQ29uZmlnRGlyZWN0b3J5O1xuICAgIHRoaXMucmVxdWVzdGVkQ29uZmlnRGlyZWN0b3J5ID0gcmVxdWVzdGVkQ29uZmlnRGlyZWN0b3J5O1xuICAgIHRoaXMudmF1bHRQYXRoID0gdmF1bHRQYXRoO1xuICB9XG59XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBZ0RPLE1BQU0scUNBQXFDLE1BQU07QUFBQTtBQUFBO0FBQUE7QUFBQSxFQUl0QztBQUFBO0FBQUE7QUFBQTtBQUFBLEVBS0E7QUFBQTtBQUFBO0FBQUE7QUFBQSxFQUtBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBT1QsWUFBWSxRQUF1RDtBQUN4RSxVQUFNLEVBQUUsdUJBQXVCLDBCQUEwQixVQUFVLElBQUk7QUFDdkU7QUFBQSxNQUNFLFNBQVMsU0FBUyxrQ0FBa0MscUJBQXFCLFFBQVEsd0JBQXdCLDRHQUV2Rix3QkFBd0I7QUFBQSxJQUM1QztBQUNBLFNBQUssT0FBTztBQUNaLFNBQUssd0JBQXdCO0FBQzdCLFNBQUssMkJBQTJCO0FBQ2hDLFNBQUssWUFBWTtBQUFBLEVBQ25CO0FBQ0Y7IiwKICAibmFtZXMiOiBbXQp9Cg==