obsidian-integration-testing 11.0.0 → 12.1.0

package/dist/lib/esm/parent-liveness.d.mts

@@ -24,11 +24,37 @@
  * So we use the one cross-platform resource the kernel *does* reclaim
  * deterministically on process death: a socket. The harness listens on a
  * loopback port and the instance's renderer connects to it. However the harness
- * dies — cleanly, `SIGKILL`ed, or crashed — the kernel closes its end, the
- * renderer sees `close`, and the window destroys itself. No polling, no
- * heartbeat interval, no timeout to tune.
+ * dies — cleanly, `SIGKILL`ed, or crashed — the kernel closes its end and the
+ * renderer sees `close`. No polling, no heartbeat interval, no timeout to tune.
  *
- * Deliberately fail-open: the renderer only arms the destroy handler after the
+ * **A close is a question, not a verdict.** A socket closing is not the same
+ * event as a process dying, and treating them as identical destroyed healthy
+ * instances: measured on 2026-09-05, a renderer's idle liveness socket sent
+ * `FIN` on its own — 3 min 13 s into one run, 11 min 56 s into another — while
+ * the harness was still listening and went on working for another 14 minutes.
+ * Every test file scheduled after the death then failed in tens of milliseconds
+ * with `ECONNREFUSED` on the dead CDP port; the worst run reported 156 such
+ * failures across 21 files, not one of them a test result. Why an idle unref'd
+ * loopback socket in an Electron renderer does that is not established, and does
+ * not need to be: the lifetimes vary run to run, so no fixed timeout explains it.
+ *
+ * So the `close` handler **verifies before destroying**: it reconnects to the
+ * same loopback port. A harness that is alive is still listening, so the
+ * reconnect succeeds and the new socket becomes the liveness token; only when
+ * nothing answers after a few tries — what a dead harness actually looks like —
+ * is the window destroyed. The leak the watchdog exists to prevent is still
+ * prevented, and the measured recovery is 11 ms.
+ *
+ * A reconnect rather than a check on the harness's process id, because it proves
+ * the thing the watchdog actually depends on — the liveness server still serving
+ * — and it stays correct against a *busy* harness: the kernel completes a
+ * loopback handshake out of the listen backlog even while Node's event loop is
+ * blocked. Its one residual ambiguity is accepted: a reconnect proves *something*
+ * is listening on that ephemeral port, not that it is ours. The probe follows the
+ * close by milliseconds, so another process winning that exact port in between is
+ * not a risk worth a handshake protocol.
+ *
+ * Deliberately fail-open: the renderer only arms the destroy path after the
  * connection is actually established. A watchdog that cannot reach the harness
  * leaves the instance running rather than killing a window the developer is
  * working in.
@@ -39,7 +65,13 @@
  */
 export interface ParentLivenessServer {
     /**
-    Stops listening and drops every accepted connection.
+     * Stops listening.
+     *
+     * Node keeps already-accepted connections alive across a `close()`, so this
+     * does not by itself signal the renderer — the kernel reclaiming the socket on
+     * process death is what does. What it does guarantee is that a watchdog probe
+     * arriving afterwards is refused, which is the answer a torn-down harness
+     * should give.
      */
     close(): void;
     /**

package/dist/lib/esm/parent-liveness.mjs

@@ -1,5 +1,7 @@
 import { createServer } from "node:net";
 const PARENT_LIVENESS_HOST = "127.0.0.1";
+const RECONNECT_ATTEMPT_LIMIT = 3;
+const RECONNECT_DELAY_IN_MILLISECONDS = 250;
 function buildParentLivenessWatchdogExpression(port) {
   return `(function() {
   var FLAG = '__obsidianIntegrationTestingParentLiveness';
@@ -14,20 +16,55 @@ function buildParentLivenessWatchdogExpression(port) {
       return 'unavailable';
     }
   }
-  var socket = net.connect(${String(port)}, '${PARENT_LIVENESS_HOST}');
+  var PORT = ${String(port)};
+  var HOST = '${PARENT_LIVENESS_HOST}';
+  var RECONNECT_ATTEMPT_LIMIT = ${String(RECONNECT_ATTEMPT_LIMIT)};
+  var RECONNECT_DELAY_IN_MILLISECONDS = ${String(RECONNECT_DELAY_IN_MILLISECONDS)};
+  var socket = net.connect(PORT, HOST);
   window[FLAG] = socket;
   var isConnected = false;
   socket.on('connect', function() { isConnected = true; });
-  socket.on('error', function() { /* Handled by the close listener below. */ });
+  socket.on('error', function() { /* The close handler below decides what an error meant. */ });
   socket.on('close', function() {
+    /* Fail open: a connection that never established is no evidence the harness died. */
     if (!isConnected) { return; }
+    reconnect(1);
+  });
+  return 'armed';
+
+  /* A close only asks the question. Reconnecting answers it. */
+  function reconnect(attempt) {
+    var didConnect = false;
+    var probe = net.connect(PORT, HOST);
+    probe.on('connect', function() {
+      /* Someone is still listening, so the harness is alive. This is the new token. */
+      didConnect = true;
+      window[FLAG] = probe;
+      probe.on('close', function() { reconnect(1); });
+    });
+    probe.on('error', function() {
+      /*
+       * This handler outlives the connect, so it doubles as the adopted socket's
+       * error handler. Once connected, an error says nothing about the harness \u2014
+       * the close that follows it re-runs the probe.
+       */
+      if (didConnect) { return; }
+      if (attempt < RECONNECT_ATTEMPT_LIMIT) {
+        setTimeout(function() { reconnect(attempt + 1); }, RECONNECT_DELAY_IN_MILLISECONDS);
+        return;
+      }
+      /* Nothing answered after several tries: the harness really is gone. */
+      destroyWindow();
+    });
+  }
+
+  function destroyWindow() {
     try {
       window.electronWindow.destroy();
     } catch (destroyError) {
       window.close();
     }
-  });
-  return 'armed';
+  }
 })()`;
 }
 async function startParentLivenessServer() {
@@ -64,4 +101,4 @@ export {
   buildParentLivenessWatchdogExpression,
   startParentLivenessServer
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/parent-liveness.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Ties a harness-owned Obsidian instance's lifetime to the harness process that\n * launched it, in the one direction the operating system will not do for us.\n *\n * The owned instance is already a child of the harness process, but that link\n * carries no lifetime guarantee. Windows never propagates a parent's death to\n * its children \u2014 an orphan simply keeps running with a stale parent id \u2014 and on\n * POSIX a `SIGKILL` aimed at a single pid never cascades either. The instance is\n * additionally spawned `detached`, so it is not even in the harness's process\n * group. Teardown therefore relies entirely on the harness running its own\n * cleanup (`killProcessTree` from an `exit`/signal handler), which is exactly\n * what a `SIGKILL`, a Task Manager kill, or an IDE stop button denies it. Every\n * such kill leaks a hidden Obsidian holding a user-data dir and a CDP port, and\n * they accumulate: the next run picks a fresh temp dir and a free port, so\n * nothing collides and nothing complains.\n *\n * The guaranteed fix is an OS primitive \u2014 a Windows Job Object with\n * `JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE`, or `prctl(PR_SET_PDEATHSIG)` on Linux \u2014\n * but neither is reachable from Node without a native addon, which is far too\n * heavy a dependency for this harness.\n *\n * So we use the one cross-platform resource the kernel *does* reclaim\n * deterministically on process death: a socket. The harness listens on a\n * loopback port and the instance's renderer connects to it. However the harness\n * dies \u2014 cleanly, `SIGKILL`ed, or crashed \u2014 the kernel closes its end, the\n * renderer sees `close`, and the window destroys itself. No polling, no\n * heartbeat interval, no timeout to tune.\n *\n * Deliberately fail-open: the renderer only arms the destroy handler after the\n * connection is actually established. A watchdog that cannot reach the harness\n * leaves the instance running rather than killing a window the developer is\n * working in.\n */\n\nimport type { Server } from 'node:net';\n\nimport { createServer } from 'node:net';\n\n/**\n * A listening loopback server whose accepted connections act as liveness tokens\n * for the harness process.\n */\nexport interface ParentLivenessServer {\n  /**\n  Stops listening and drops every accepted connection.\n   */\n  close(): void;\n\n  /**\n  The loopback port the renderer watchdog should connect back to.\n   */\n  readonly port: number;\n}\n\n/**\n * Loopback host the liveness server binds to. Never exposed off-machine.\n */\nexport const PARENT_LIVENESS_HOST = '127.0.0.1';\n\n/**\n * Builds the expression evaluated in the owned instance's renderer to arm the\n * watchdog.\n *\n * Written in ES5 style (`var`, `function`) with no optional chaining, matching\n * {@link DISMISS_TRUST_DIALOG_EXPR}: the same expression has to parse on the\n * Chromium 80-era renderers of the oldest supported Obsidian versions (L26).\n *\n * Arming is idempotent \u2014 a second evaluation finds the stored socket and\n * returns without opening another connection, so a retried readiness pass does\n * not pile up sockets.\n *\n * @param port - The loopback port returned by {@link startParentLivenessServer}.\n * @returns The expression to evaluate, yielding `'armed'`, `'already-armed'`, or `'unavailable'`.\n */\nexport function buildParentLivenessWatchdogExpression(port: number): string {\n  return `(function() {\n  var FLAG = '__obsidianIntegrationTestingParentLiveness';\n  if (window[FLAG]) { return 'already-armed'; }\n  var net;\n  try {\n    net = window.require('node:net');\n  } catch (nodePrefixError) {\n    try {\n      net = window.require('net');\n    } catch (barePrefixError) {\n      return 'unavailable';\n    }\n  }\n  var socket = net.connect(${String(port)}, '${PARENT_LIVENESS_HOST}');\n  window[FLAG] = socket;\n  var isConnected = false;\n  socket.on('connect', function() { isConnected = true; });\n  socket.on('error', function() { /* Handled by the close listener below. */ });\n  socket.on('close', function() {\n    if (!isConnected) { return; }\n    try {\n      window.electronWindow.destroy();\n    } catch (destroyError) {\n      window.close();\n    }\n  });\n  return 'armed';\n})()`;\n}\n\n/**\n * Starts the loopback liveness server the owned instance's renderer connects\n * back to.\n *\n * The server and every accepted socket are `unref`ed, so holding a watchdog\n * connection open never keeps the harness process alive on its own \u2014 the\n * connection is a token the kernel reclaims, not work to wait on.\n *\n * @returns A {@link Promise} resolving to the listening {@link ParentLivenessServer}.\n */\nexport async function startParentLivenessServer(): Promise<ParentLivenessServer> {\n  const server = createServer((socket) => {\n    socket.unref();\n    // The connection carries no data \u2014 it exists only so its close is observable.\n    socket.on('error', () => {\n      // A renderer torn down mid-connection resets rather than closes; not an error here.\n    });\n  });\n  server.unref();\n\n  const port = await listenOnFreeLoopbackPort(server);\n  return {\n    close(): void {\n      server.close();\n    },\n    port\n  };\n}\n\n/**\n * Binds the server to an ephemeral loopback port and reports which one it got.\n *\n * @param server - The server to bind.\n * @returns A {@link Promise} resolving to the assigned port.\n * @throws If the server reports an error before listening, or binds to a pipe rather than a port.\n */\nasync function listenOnFreeLoopbackPort(server: Server): Promise<number> {\n  return new Promise<number>((resolve, reject) => {\n    server.once('error', reject);\n    server.listen(0, PARENT_LIVENESS_HOST, () => {\n      const address = server.address();\n      if (address === null || typeof address === 'string') {\n        server.close();\n        reject(new Error('Failed to determine the parent-liveness port.'));\n        return;\n      }\n      resolve(address.port);\n    });\n  });\n}\n"],
  "mappings": "AAsCA,SAAS,oBAAoB;AAqBtB,MAAM,uBAAuB;AAiB7B,SAAS,sCAAsC,MAAsB;AAC1E,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,6BAaoB,OAAO,IAAI,CAAC,MAAM,oBAAoB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAenE;AAYA,eAAsB,4BAA2D;AAC/E,QAAM,SAAS,aAAa,CAAC,WAAW;AACtC,WAAO,MAAM;AAEb,WAAO,GAAG,SAAS,MAAM;AAAA,IAEzB,CAAC;AAAA,EACH,CAAC;AACD,SAAO,MAAM;AAEb,QAAM,OAAO,MAAM,yBAAyB,MAAM;AAClD,SAAO;AAAA,IACL,QAAc;AACZ,aAAO,MAAM;AAAA,IACf;AAAA,IACA;AAAA,EACF;AACF;AASA,eAAe,yBAAyB,QAAiC;AACvE,SAAO,IAAI,QAAgB,CAAC,SAAS,WAAW;AAC9C,WAAO,KAAK,SAAS,MAAM;AAC3B,WAAO,OAAO,GAAG,sBAAsB,MAAM;AAC3C,YAAM,UAAU,OAAO,QAAQ;AAC/B,UAAI,YAAY,QAAQ,OAAO,YAAY,UAAU;AACnD,eAAO,MAAM;AACb,eAAO,IAAI,MAAM,+CAA+C,CAAC;AACjE;AAAA,MACF;AACA,cAAQ,QAAQ,IAAI;AAAA,IACtB,CAAC;AAAA,EACH,CAAC;AACH;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/parent-liveness.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Ties a harness-owned Obsidian instance's lifetime to the harness process that\n * launched it, in the one direction the operating system will not do for us.\n *\n * The owned instance is already a child of the harness process, but that link\n * carries no lifetime guarantee. Windows never propagates a parent's death to\n * its children \u2014 an orphan simply keeps running with a stale parent id \u2014 and on\n * POSIX a `SIGKILL` aimed at a single pid never cascades either. The instance is\n * additionally spawned `detached`, so it is not even in the harness's process\n * group. Teardown therefore relies entirely on the harness running its own\n * cleanup (`killProcessTree` from an `exit`/signal handler), which is exactly\n * what a `SIGKILL`, a Task Manager kill, or an IDE stop button denies it. Every\n * such kill leaks a hidden Obsidian holding a user-data dir and a CDP port, and\n * they accumulate: the next run picks a fresh temp dir and a free port, so\n * nothing collides and nothing complains.\n *\n * The guaranteed fix is an OS primitive \u2014 a Windows Job Object with\n * `JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE`, or `prctl(PR_SET_PDEATHSIG)` on Linux \u2014\n * but neither is reachable from Node without a native addon, which is far too\n * heavy a dependency for this harness.\n *\n * So we use the one cross-platform resource the kernel *does* reclaim\n * deterministically on process death: a socket. The harness listens on a\n * loopback port and the instance's renderer connects to it. However the harness\n * dies \u2014 cleanly, `SIGKILL`ed, or crashed \u2014 the kernel closes its end and the\n * renderer sees `close`. No polling, no heartbeat interval, no timeout to tune.\n *\n * **A close is a question, not a verdict.** A socket closing is not the same\n * event as a process dying, and treating them as identical destroyed healthy\n * instances: measured on 2026-09-05, a renderer's idle liveness socket sent\n * `FIN` on its own \u2014 3 min 13 s into one run, 11 min 56 s into another \u2014 while\n * the harness was still listening and went on working for another 14 minutes.\n * Every test file scheduled after the death then failed in tens of milliseconds\n * with `ECONNREFUSED` on the dead CDP port; the worst run reported 156 such\n * failures across 21 files, not one of them a test result. Why an idle unref'd\n * loopback socket in an Electron renderer does that is not established, and does\n * not need to be: the lifetimes vary run to run, so no fixed timeout explains it.\n *\n * So the `close` handler **verifies before destroying**: it reconnects to the\n * same loopback port. A harness that is alive is still listening, so the\n * reconnect succeeds and the new socket becomes the liveness token; only when\n * nothing answers after a few tries \u2014 what a dead harness actually looks like \u2014\n * is the window destroyed. The leak the watchdog exists to prevent is still\n * prevented, and the measured recovery is 11 ms.\n *\n * A reconnect rather than a check on the harness's process id, because it proves\n * the thing the watchdog actually depends on \u2014 the liveness server still serving\n * \u2014 and it stays correct against a *busy* harness: the kernel completes a\n * loopback handshake out of the listen backlog even while Node's event loop is\n * blocked. Its one residual ambiguity is accepted: a reconnect proves *something*\n * is listening on that ephemeral port, not that it is ours. The probe follows the\n * close by milliseconds, so another process winning that exact port in between is\n * not a risk worth a handshake protocol.\n *\n * Deliberately fail-open: the renderer only arms the destroy path after the\n * connection is actually established. A watchdog that cannot reach the harness\n * leaves the instance running rather than killing a window the developer is\n * working in.\n */\n\nimport type { Server } from 'node:net';\n\nimport { createServer } from 'node:net';\n\n/**\n * A listening loopback server whose accepted connections act as liveness tokens\n * for the harness process.\n */\nexport interface ParentLivenessServer {\n  /**\n   * Stops listening.\n   *\n   * Node keeps already-accepted connections alive across a `close()`, so this\n   * does not by itself signal the renderer \u2014 the kernel reclaiming the socket on\n   * process death is what does. What it does guarantee is that a watchdog probe\n   * arriving afterwards is refused, which is the answer a torn-down harness\n   * should give.\n   */\n  close(): void;\n\n  /**\n  The loopback port the renderer watchdog should connect back to.\n   */\n  readonly port: number;\n}\n\n/**\n * Loopback host the liveness server binds to. Never exposed off-machine.\n */\nexport const PARENT_LIVENESS_HOST = '127.0.0.1';\n\n/**\n * How many times the watchdog probes the loopback port before concluding the\n * harness is gone.\n *\n * More than one, so a single transient refusal cannot cost a whole run; small,\n * because every attempt is a loopback connect that either completes or is\n * refused immediately, and an instance whose harness really did die should not\n * linger.\n */\nconst RECONNECT_ATTEMPT_LIMIT = 3;\n\n/**\n * How long the watchdog waits between probes.\n *\n * Long enough to outlast a momentary refusal, short enough that exhausting the\n * whole budget still destroys an orphaned window inside a second.\n */\nconst RECONNECT_DELAY_IN_MILLISECONDS = 250;\n\n/**\n * Builds the expression evaluated in the owned instance's renderer to arm the\n * watchdog.\n *\n * Written in ES5 style (`var`, `function`) with no optional chaining, matching\n * {@link DISMISS_TRUST_DIALOG_EXPR}: the same expression has to parse on the\n * Chromium 80-era renderers of the oldest supported Obsidian versions (L26).\n *\n * Arming is idempotent \u2014 a second evaluation finds the stored socket and\n * returns without opening another connection, so a retried readiness pass does\n * not pile up sockets.\n *\n * @param port - The loopback port returned by {@link startParentLivenessServer}.\n * @returns The expression to evaluate, yielding `'armed'`, `'already-armed'`, or `'unavailable'`.\n */\nexport function buildParentLivenessWatchdogExpression(port: number): string {\n  return `(function() {\n  var FLAG = '__obsidianIntegrationTestingParentLiveness';\n  if (window[FLAG]) { return 'already-armed'; }\n  var net;\n  try {\n    net = window.require('node:net');\n  } catch (nodePrefixError) {\n    try {\n      net = window.require('net');\n    } catch (barePrefixError) {\n      return 'unavailable';\n    }\n  }\n  var PORT = ${String(port)};\n  var HOST = '${PARENT_LIVENESS_HOST}';\n  var RECONNECT_ATTEMPT_LIMIT = ${String(RECONNECT_ATTEMPT_LIMIT)};\n  var RECONNECT_DELAY_IN_MILLISECONDS = ${String(RECONNECT_DELAY_IN_MILLISECONDS)};\n  var socket = net.connect(PORT, HOST);\n  window[FLAG] = socket;\n  var isConnected = false;\n  socket.on('connect', function() { isConnected = true; });\n  socket.on('error', function() { /* The close handler below decides what an error meant. */ });\n  socket.on('close', function() {\n    /* Fail open: a connection that never established is no evidence the harness died. */\n    if (!isConnected) { return; }\n    reconnect(1);\n  });\n  return 'armed';\n\n  /* A close only asks the question. Reconnecting answers it. */\n  function reconnect(attempt) {\n    var didConnect = false;\n    var probe = net.connect(PORT, HOST);\n    probe.on('connect', function() {\n      /* Someone is still listening, so the harness is alive. This is the new token. */\n      didConnect = true;\n      window[FLAG] = probe;\n      probe.on('close', function() { reconnect(1); });\n    });\n    probe.on('error', function() {\n      /*\n       * This handler outlives the connect, so it doubles as the adopted socket's\n       * error handler. Once connected, an error says nothing about the harness \u2014\n       * the close that follows it re-runs the probe.\n       */\n      if (didConnect) { return; }\n      if (attempt < RECONNECT_ATTEMPT_LIMIT) {\n        setTimeout(function() { reconnect(attempt + 1); }, RECONNECT_DELAY_IN_MILLISECONDS);\n        return;\n      }\n      /* Nothing answered after several tries: the harness really is gone. */\n      destroyWindow();\n    });\n  }\n\n  function destroyWindow() {\n    try {\n      window.electronWindow.destroy();\n    } catch (destroyError) {\n      window.close();\n    }\n  }\n})()`;\n}\n\n/**\n * Starts the loopback liveness server the owned instance's renderer connects\n * back to.\n *\n * The server and every accepted socket are `unref`ed, so holding a watchdog\n * connection open never keeps the harness process alive on its own \u2014 the\n * connection is a token the kernel reclaims, not work to wait on.\n *\n * @returns A {@link Promise} resolving to the listening {@link ParentLivenessServer}.\n */\nexport async function startParentLivenessServer(): Promise<ParentLivenessServer> {\n  const server = createServer((socket) => {\n    socket.unref();\n    // The connection carries no data \u2014 it exists only so its close is observable.\n    socket.on('error', () => {\n      // A renderer torn down mid-connection resets rather than closes; not an error here.\n    });\n  });\n  server.unref();\n\n  const port = await listenOnFreeLoopbackPort(server);\n  return {\n    close(): void {\n      server.close();\n    },\n    port\n  };\n}\n\n/**\n * Binds the server to an ephemeral loopback port and reports which one it got.\n *\n * @param server - The server to bind.\n * @returns A {@link Promise} resolving to the assigned port.\n * @throws If the server reports an error before listening, or binds to a pipe rather than a port.\n */\nasync function listenOnFreeLoopbackPort(server: Server): Promise<number> {\n  return new Promise<number>((resolve, reject) => {\n    server.once('error', reject);\n    server.listen(0, PARENT_LIVENESS_HOST, () => {\n      const address = server.address();\n      if (address === null || typeof address === 'string') {\n        server.close();\n        reject(new Error('Failed to determine the parent-liveness port.'));\n        return;\n      }\n      resolve(address.port);\n    });\n  });\n}\n"],
  "mappings": "AAgEA,SAAS,oBAAoB;AA2BtB,MAAM,uBAAuB;AAWpC,MAAM,0BAA0B;AAQhC,MAAM,kCAAkC;AAiBjC,SAAS,sCAAsC,MAAsB;AAC1E,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,eAaM,OAAO,IAAI,CAAC;AAAA,gBACX,oBAAoB;AAAA,kCACF,OAAO,uBAAuB,CAAC;AAAA,0CACvB,OAAO,+BAA+B,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA+CjF;AAYA,eAAsB,4BAA2D;AAC/E,QAAM,SAAS,aAAa,CAAC,WAAW;AACtC,WAAO,MAAM;AAEb,WAAO,GAAG,SAAS,MAAM;AAAA,IAEzB,CAAC;AAAA,EACH,CAAC;AACD,SAAO,MAAM;AAEb,QAAM,OAAO,MAAM,yBAAyB,MAAM;AAClD,SAAO;AAAA,IACL,QAAc;AACZ,aAAO,MAAM;AAAA,IACf;AAAA,IACA;AAAA,EACF;AACF;AASA,eAAe,yBAAyB,QAAiC;AACvE,SAAO,IAAI,QAAgB,CAAC,SAAS,WAAW;AAC9C,WAAO,KAAK,SAAS,MAAM;AAC3B,WAAO,OAAO,GAAG,sBAAsB,MAAM;AAC3C,YAAM,UAAU,OAAO,QAAQ;AAC/B,UAAI,YAAY,QAAQ,OAAO,YAAY,UAAU;AACnD,eAAO,MAAM;AACb,eAAO,IAAI,MAAM,+CAA+C,CAAC;AACjE;AAAA,MACF;AACA,cAAQ,QAAQ,IAAI;AAAA,IACtB,CAAC;AAAA,EACH,CAAC;AACH;",
  "names": []
}


package/dist/lib/esm/port-owner.d.mts

@@ -0,0 +1,47 @@
+/**
+ * @file
+ *
+ * Pure helpers for answering "which process is still holding this port?".
+ *
+ * A teardown that cannot answer that question can only re-issue the same kill at
+ * the same PID, which is no escalation at all: the PID the harness holds is the
+ * shell wrapper it spawned, and what survives is whatever that wrapper's tree
+ * walk failed to reach. The port, by contrast, is direct evidence — a socket
+ * still answering on 4723 after this run killed the server it started belongs to
+ * that server.
+ *
+ * Kept separate from the integration-only `transport-factory` so the parsing
+ * stays unit-testable; the factory shells out to `netstat` / `lsof`.
+ */
+/**
+ * Parameters for {@link parseWindowsNetstatPids}.
+ */
+export interface ParseWindowsNetstatPidsParams {
+    /**
+    Raw stdout of `netstat -ano`.
+     */
+    readonly netstatOutput: string;
+    /**
+    The local port whose listener is wanted.
+     */
+    readonly port: number;
+}
+/**
+ * Parses `lsof -ti tcp:<port>` output, which is already one PID per line.
+ *
+ * @param lsofOutput - Raw stdout of the `lsof` query.
+ * @returns The distinct PIDs, in listed order.
+ */
+export declare function parsePosixLsofPids(lsofOutput: string): number[];
+/**
+ * Parses `netstat -ano` output for the PIDs **listening** on a port.
+ *
+ * Only `TCP` rows in the `LISTENING` state count: an established connection *to*
+ * the port belongs to a client, not to the server that must die, and the `UDP`
+ * rows have no state column at all. The same server appears twice when it binds
+ * both IPv4 and IPv6, so PIDs are de-duplicated.
+ *
+ * @param params - The listing output and the port to match.
+ * @returns The distinct listening PIDs, in listed order.
+ */
+export declare function parseWindowsNetstatPids(params: ParseWindowsNetstatPidsParams): number[];

package/dist/lib/esm/port-owner.mjs

@@ -0,0 +1,36 @@
+const LISTENING_STATE = "LISTENING";
+const RADIX_DECIMAL = 10;
+const TCP_PROTOCOL = "TCP";
+const WHITESPACE_PATTERN = /\s+/;
+function parsePosixLsofPids(lsofOutput) {
+  const pids = [];
+  for (const line of lsofOutput.split("\n")) {
+    const pid = Number.parseInt(line.trim(), RADIX_DECIMAL);
+    if (Number.isNaN(pid) || pids.includes(pid)) {
+      continue;
+    }
+    pids.push(pid);
+  }
+  return pids;
+}
+function parseWindowsNetstatPids(params) {
+  const localAddressSuffix = `:${String(params.port)}`;
+  const pids = [];
+  for (const rawLine of params.netstatOutput.split("\n")) {
+    const [protocol = "", localAddress = "", , state = "", rawPid = ""] = rawLine.trim().split(WHITESPACE_PATTERN);
+    if (protocol !== TCP_PROTOCOL || state !== LISTENING_STATE || !localAddress.endsWith(localAddressSuffix)) {
+      continue;
+    }
+    const pid = Number.parseInt(rawPid, RADIX_DECIMAL);
+    if (Number.isNaN(pid) || pids.includes(pid)) {
+      continue;
+    }
+    pids.push(pid);
+  }
+  return pids;
+}
+export {
+  parsePosixLsofPids,
+  parseWindowsNetstatPids
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3BvcnQtb3duZXIudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBQdXJlIGhlbHBlcnMgZm9yIGFuc3dlcmluZyBcIndoaWNoIHByb2Nlc3MgaXMgc3RpbGwgaG9sZGluZyB0aGlzIHBvcnQ/XCIuXG4gKlxuICogQSB0ZWFyZG93biB0aGF0IGNhbm5vdCBhbnN3ZXIgdGhhdCBxdWVzdGlvbiBjYW4gb25seSByZS1pc3N1ZSB0aGUgc2FtZSBraWxsIGF0XG4gKiB0aGUgc2FtZSBQSUQsIHdoaWNoIGlzIG5vIGVzY2FsYXRpb24gYXQgYWxsOiB0aGUgUElEIHRoZSBoYXJuZXNzIGhvbGRzIGlzIHRoZVxuICogc2hlbGwgd3JhcHBlciBpdCBzcGF3bmVkLCBhbmQgd2hhdCBzdXJ2aXZlcyBpcyB3aGF0ZXZlciB0aGF0IHdyYXBwZXIncyB0cmVlXG4gKiB3YWxrIGZhaWxlZCB0byByZWFjaC4gVGhlIHBvcnQsIGJ5IGNvbnRyYXN0LCBpcyBkaXJlY3QgZXZpZGVuY2UgXHUyMDE0IGEgc29ja2V0XG4gKiBzdGlsbCBhbnN3ZXJpbmcgb24gNDcyMyBhZnRlciB0aGlzIHJ1biBraWxsZWQgdGhlIHNlcnZlciBpdCBzdGFydGVkIGJlbG9uZ3MgdG9cbiAqIHRoYXQgc2VydmVyLlxuICpcbiAqIEtlcHQgc2VwYXJhdGUgZnJvbSB0aGUgaW50ZWdyYXRpb24tb25seSBgdHJhbnNwb3J0LWZhY3RvcnlgIHNvIHRoZSBwYXJzaW5nXG4gKiBzdGF5cyB1bml0LXRlc3RhYmxlOyB0aGUgZmFjdG9yeSBzaGVsbHMgb3V0IHRvIGBuZXRzdGF0YCAvIGBsc29mYC5cbiAqL1xuXG4vKipcbiAqIFBhcmFtZXRlcnMgZm9yIHtAbGluayBwYXJzZVdpbmRvd3NOZXRzdGF0UGlkc30uXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUGFyc2VXaW5kb3dzTmV0c3RhdFBpZHNQYXJhbXMge1xuICAvKipcbiAgUmF3IHN0ZG91dCBvZiBgbmV0c3RhdCAtYW5vYC5cbiAgICovXG4gIHJlYWRvbmx5IG5ldHN0YXRPdXRwdXQ6IHN0cmluZztcblxuICAvKipcbiAgVGhlIGxvY2FsIHBvcnQgd2hvc2UgbGlzdGVuZXIgaXMgd2FudGVkLlxuICAgKi9cbiAgcmVhZG9ubHkgcG9ydDogbnVtYmVyO1xufVxuXG5jb25zdCBMSVNURU5JTkdfU1RBVEUgPSAnTElTVEVOSU5HJztcbmNvbnN0IFJBRElYX0RFQ0lNQUwgPSAxMDtcbmNvbnN0IFRDUF9QUk9UT0NPTCA9ICdUQ1AnO1xuY29uc3QgV0hJVEVTUEFDRV9QQVRURVJOID0gL1xccysvO1xuXG4vKipcbiAqIFBhcnNlcyBgbHNvZiAtdGkgdGNwOjxwb3J0PmAgb3V0cHV0LCB3aGljaCBpcyBhbHJlYWR5IG9uZSBQSUQgcGVyIGxpbmUuXG4gKlxuICogQHBhcmFtIGxzb2ZPdXRwdXQgLSBSYXcgc3Rkb3V0IG9mIHRoZSBgbHNvZmAgcXVlcnkuXG4gKiBAcmV0dXJucyBUaGUgZGlzdGluY3QgUElEcywgaW4gbGlzdGVkIG9yZGVyLlxuICovXG5leHBvcnQgZnVuY3Rpb24gcGFyc2VQb3NpeExzb2ZQaWRzKGxzb2ZPdXRwdXQ6IHN0cmluZyk6IG51bWJlcltdIHtcbiAgY29uc3QgcGlkczogbnVtYmVyW10gPSBbXTtcblxuICBmb3IgKGNvbnN0IGxpbmUgb2YgbHNvZk91dHB1dC5zcGxpdCgnXFxuJykpIHtcbiAgICBjb25zdCBwaWQgPSBOdW1iZXIucGFyc2VJbnQobGluZS50cmltKCksIFJBRElYX0RFQ0lNQUwpO1xuICAgIGlmIChOdW1iZXIuaXNOYU4ocGlkKSB8fCBwaWRzLmluY2x1ZGVzKHBpZCkpIHtcbiAgICAgIGNvbnRpbnVlO1xuICAgIH1cblxuICAgIHBpZHMucHVzaChwaWQpO1xuICB9XG5cbiAgcmV0dXJuIHBpZHM7XG59XG5cbi8qKlxuICogUGFyc2VzIGBuZXRzdGF0IC1hbm9gIG91dHB1dCBmb3IgdGhlIFBJRHMgKipsaXN0ZW5pbmcqKiBvbiBhIHBvcnQuXG4gKlxuICogT25seSBgVENQYCByb3dzIGluIHRoZSBgTElTVEVOSU5HYCBzdGF0ZSBjb3VudDogYW4gZXN0YWJsaXNoZWQgY29ubmVjdGlvbiAqdG8qXG4gKiB0aGUgcG9ydCBiZWxvbmdzIHRvIGEgY2xpZW50LCBub3QgdG8gdGhlIHNlcnZlciB0aGF0IG11c3QgZGllLCBhbmQgdGhlIGBVRFBgXG4gKiByb3dzIGhhdmUgbm8gc3RhdGUgY29sdW1uIGF0IGFsbC4gVGhlIHNhbWUgc2VydmVyIGFwcGVhcnMgdHdpY2Ugd2hlbiBpdCBiaW5kc1xuICogYm90aCBJUHY0IGFuZCBJUHY2LCBzbyBQSURzIGFyZSBkZS1kdXBsaWNhdGVkLlxuICpcbiAqIEBwYXJhbSBwYXJhbXMgLSBUaGUgbGlzdGluZyBvdXRwdXQgYW5kIHRoZSBwb3J0IHRvIG1hdGNoLlxuICogQHJldHVybnMgVGhlIGRpc3RpbmN0IGxpc3RlbmluZyBQSURzLCBpbiBsaXN0ZWQgb3JkZXIuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBwYXJzZVdpbmRvd3NOZXRzdGF0UGlkcyhwYXJhbXM6IFBhcnNlV2luZG93c05ldHN0YXRQaWRzUGFyYW1zKTogbnVtYmVyW10ge1xuICBjb25zdCBsb2NhbEFkZHJlc3NTdWZmaXggPSBgOiR7U3RyaW5nKHBhcmFtcy5wb3J0KX1gO1xuICBjb25zdCBwaWRzOiBudW1iZXJbXSA9IFtdO1xuXG4gIGZvciAoY29uc3QgcmF3TGluZSBvZiBwYXJhbXMubmV0c3RhdE91dHB1dC5zcGxpdCgnXFxuJykpIHtcbiAgICBjb25zdCBbcHJvdG9jb2wgPSAnJywgbG9jYWxBZGRyZXNzID0gJycsICwgc3RhdGUgPSAnJywgcmF3UGlkID0gJyddID0gcmF3TGluZS50cmltKCkuc3BsaXQoV0hJVEVTUEFDRV9QQVRURVJOKTtcbiAgICBpZiAocHJvdG9jb2wgIT09IFRDUF9QUk9UT0NPTCB8fCBzdGF0ZSAhPT0gTElTVEVOSU5HX1NUQVRFIHx8ICFsb2NhbEFkZHJlc3MuZW5kc1dpdGgobG9jYWxBZGRyZXNzU3VmZml4KSkge1xuICAgICAgY29udGludWU7XG4gICAgfVxuXG4gICAgY29uc3QgcGlkID0gTnVtYmVyLnBhcnNlSW50KHJhd1BpZCwgUkFESVhfREVDSU1BTCk7XG4gICAgaWYgKE51bWJlci5pc05hTihwaWQpIHx8IHBpZHMuaW5jbHVkZXMocGlkKSkge1xuICAgICAgY29udGludWU7XG4gICAgfVxuXG4gICAgcGlkcy5wdXNoKHBpZCk7XG4gIH1cblxuICByZXR1cm4gcGlkcztcbn1cbiJdLAogICJtYXBwaW5ncyI6ICJBQStCQSxNQUFNLGtCQUFrQjtBQUN4QixNQUFNLGdCQUFnQjtBQUN0QixNQUFNLGVBQWU7QUFDckIsTUFBTSxxQkFBcUI7QUFRcEIsU0FBUyxtQkFBbUIsWUFBOEI7QUFDL0QsUUFBTSxPQUFpQixDQUFDO0FBRXhCLGFBQVcsUUFBUSxXQUFXLE1BQU0sSUFBSSxHQUFHO0FBQ3pDLFVBQU0sTUFBTSxPQUFPLFNBQVMsS0FBSyxLQUFLLEdBQUcsYUFBYTtBQUN0RCxRQUFJLE9BQU8sTUFBTSxHQUFHLEtBQUssS0FBSyxTQUFTLEdBQUcsR0FBRztBQUMzQztBQUFBLElBQ0Y7QUFFQSxTQUFLLEtBQUssR0FBRztBQUFBLEVBQ2Y7QUFFQSxTQUFPO0FBQ1Q7QUFhTyxTQUFTLHdCQUF3QixRQUFpRDtBQUN2RixRQUFNLHFCQUFxQixJQUFJLE9BQU8sT0FBTyxJQUFJLENBQUM7QUFDbEQsUUFBTSxPQUFpQixDQUFDO0FBRXhCLGFBQVcsV0FBVyxPQUFPLGNBQWMsTUFBTSxJQUFJLEdBQUc7QUFDdEQsVUFBTSxDQUFDLFdBQVcsSUFBSSxlQUFlLElBQUksRUFBRSxRQUFRLElBQUksU0FBUyxFQUFFLElBQUksUUFBUSxLQUFLLEVBQUUsTUFBTSxrQkFBa0I7QUFDN0csUUFBSSxhQUFhLGdCQUFnQixVQUFVLG1CQUFtQixDQUFDLGFBQWEsU0FBUyxrQkFBa0IsR0FBRztBQUN4RztBQUFBLElBQ0Y7QUFFQSxVQUFNLE1BQU0sT0FBTyxTQUFTLFFBQVEsYUFBYTtBQUNqRCxRQUFJLE9BQU8sTUFBTSxHQUFHLEtBQUssS0FBSyxTQUFTLEdBQUcsR0FBRztBQUMzQztBQUFBLElBQ0Y7QUFFQSxTQUFLLEtBQUssR0FBRztBQUFBLEVBQ2Y7QUFFQSxTQUFPO0FBQ1Q7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/lib/esm/process-capture.d.mts

@@ -0,0 +1,83 @@
+/**
+ * @file
+ *
+ * Attaches output capture and exit observation to a spawned child process.
+ *
+ * A long-running child spawned with piped stdio needs three things done to it,
+ * and getting any of them wrong is its own bug: its pipes must be **drained**
+ * (a full OS pipe buffer blocks the writer — a chatty renderer would hang the
+ * app it belongs to), its output must be kept **bounded** (an hour of logs is
+ * not a diagnostic), and its `exit` / `error` must be **recorded** so a caller
+ * that later finds the process unreachable can say why instead of guessing.
+ *
+ * Extracted so the state machine is unit-testable: the launchers that use it
+ * (`obsidian-instance.ts`, and the emulator/Appium spawns in
+ * `transport-factory.ts`) are integration-time glue excluded from unit tests,
+ * which is how the owned Obsidian instance came to be spawned `stdio: 'ignore'`
+ * with no `exit` listener at all — its death was unobservable by construction.
+ */
+import type { ChildProcess } from 'node:child_process';
+import type { ProcessExitInfo } from './process-exit-message.mjs';
+/**
+ * Parameters for {@link attachProcessCapture}.
+ */
+export interface AttachProcessCaptureParams {
+    /**
+     * How many characters of the most recent output to keep. Older output is
+     * dropped from the front as new output arrives.
+     */
+    readonly maxOutputLengthInCharacters: number;
+    /**
+     * Called for every chunk as it arrives, for callers that want the output
+     * **live** (logged as the process runs) rather than only as a post-mortem
+     * tail. Fires regardless of {@link ProcessCapture.stopCapture}, which freezes
+     * the retained tail and nothing else.
+     */
+    readonly onChunk?: ((chunk: ProcessOutputChunk) => void) | undefined;
+}
+/**
+ * A child process's captured output and exit status.
+ */
+export interface ProcessCapture {
+    /**
+    Returns the exit / spawn-failure details once the process is no longer running, otherwise `undefined`.
+     */
+    readExitInfo: () => ProcessExitInfo | undefined;
+    /**
+    Returns the captured stdout+stderr, bounded to the most recent output.
+     */
+    readOutput: () => string;
+    /**
+     * Stops accumulating output, freezing the tail at what has arrived so far.
+     * Call once startup has succeeded and the tail has served its purpose.
+     *
+     * The `data` listeners stay attached deliberately, so the pipes keep draining
+     * for the rest of the process's life.
+     */
+    stopCapture: () => void;
+}
+/**
+ * One chunk of a child process's output, and which stream it came from.
+ */
+export interface ProcessOutputChunk {
+    /**
+    The stream the chunk was written to.
+     */
+    readonly stream: 'stderr' | 'stdout';
+    /**
+    The chunk's text.
+     */
+    readonly text: string;
+}
+/**
+ * Attaches output capture and exit observation to an already-spawned process.
+ *
+ * Tolerates a process spawned without pipes (`stdio: 'ignore'` leaves
+ * `stdout` / `stderr` `null`): the exit half still works, and the captured
+ * output stays empty.
+ *
+ * @param child - The spawned process.
+ * @param params - The tail budget, and an optional live-output callback.
+ * @returns Readers for the captured output and the exit status.
+ */
+export declare function attachProcessCapture(child: ChildProcess, params: AttachProcessCaptureParams): ProcessCapture;

package/dist/lib/esm/process-capture.mjs

@@ -0,0 +1,38 @@
+function attachProcessCapture(child, params) {
+  const { maxOutputLengthInCharacters, onChunk } = params;
+  let capturedOutput = "";
+  let exitInfo;
+  let isCapturing = true;
+  attachStream(child.stdout, "stdout");
+  attachStream(child.stderr, "stderr");
+  child.once("exit", (code, signal) => {
+    exitInfo = { code, signal };
+  });
+  child.once("error", (error) => {
+    exitInfo = { code: null, signal: null, spawnError: error.message };
+  });
+  return {
+    readExitInfo: () => exitInfo,
+    readOutput: () => capturedOutput,
+    stopCapture: () => {
+      isCapturing = false;
+    }
+  };
+  function attachStream(stream, name) {
+    if (!stream) {
+      return;
+    }
+    stream.on("data", (chunk) => {
+      const text = chunk.toString();
+      onChunk?.({ stream: name, text });
+      if (isCapturing) {
+        capturedOutput = (capturedOutput + text).slice(-maxOutputLengthInCharacters);
+      }
+    });
+    stream.unref?.();
+  }
+}
+export {
+  attachProcessCapture
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/process-capture.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Attaches output capture and exit observation to a spawned child process.\n *\n * A long-running child spawned with piped stdio needs three things done to it,\n * and getting any of them wrong is its own bug: its pipes must be **drained**\n * (a full OS pipe buffer blocks the writer \u2014 a chatty renderer would hang the\n * app it belongs to), its output must be kept **bounded** (an hour of logs is\n * not a diagnostic), and its `exit` / `error` must be **recorded** so a caller\n * that later finds the process unreachable can say why instead of guessing.\n *\n * Extracted so the state machine is unit-testable: the launchers that use it\n * (`obsidian-instance.ts`, and the emulator/Appium spawns in\n * `transport-factory.ts`) are integration-time glue excluded from unit tests,\n * which is how the owned Obsidian instance came to be spawned `stdio: 'ignore'`\n * with no `exit` listener at all \u2014 its death was unobservable by construction.\n */\n\nimport type { ChildProcess } from 'node:child_process';\nimport type { Readable } from 'node:stream';\n\nimport type { ProcessExitInfo } from './process-exit-message.mjs';\n\n/**\n * Parameters for {@link attachProcessCapture}.\n */\nexport interface AttachProcessCaptureParams {\n  /**\n   * How many characters of the most recent output to keep. Older output is\n   * dropped from the front as new output arrives.\n   */\n  readonly maxOutputLengthInCharacters: number;\n\n  /**\n   * Called for every chunk as it arrives, for callers that want the output\n   * **live** (logged as the process runs) rather than only as a post-mortem\n   * tail. Fires regardless of {@link ProcessCapture.stopCapture}, which freezes\n   * the retained tail and nothing else.\n   */\n  readonly onChunk?: ((chunk: ProcessOutputChunk) => void) | undefined;\n}\n\n/**\n * A child process's captured output and exit status.\n */\nexport interface ProcessCapture {\n  /**\n  Returns the exit / spawn-failure details once the process is no longer running, otherwise `undefined`.\n   */\n  readExitInfo: () => ProcessExitInfo | undefined;\n\n  /**\n  Returns the captured stdout+stderr, bounded to the most recent output.\n   */\n  readOutput: () => string;\n\n  /**\n   * Stops accumulating output, freezing the tail at what has arrived so far.\n   * Call once startup has succeeded and the tail has served its purpose.\n   *\n   * The `data` listeners stay attached deliberately, so the pipes keep draining\n   * for the rest of the process's life.\n   */\n  stopCapture: () => void;\n}\n\n/**\n * One chunk of a child process's output, and which stream it came from.\n */\nexport interface ProcessOutputChunk {\n  /**\n  The stream the chunk was written to.\n   */\n  readonly stream: 'stderr' | 'stdout';\n\n  /**\n  The chunk's text.\n   */\n  readonly text: string;\n}\n\n/**\n * The `unref` a piped stdio stream carries through its underlying socket, which\n * `Readable` alone does not declare.\n */\ninterface StreamWithUnref {\n  unref: () => void;\n}\n\n/**\n * Attaches output capture and exit observation to an already-spawned process.\n *\n * Tolerates a process spawned without pipes (`stdio: 'ignore'` leaves\n * `stdout` / `stderr` `null`): the exit half still works, and the captured\n * output stays empty.\n *\n * @param child - The spawned process.\n * @param params - The tail budget, and an optional live-output callback.\n * @returns Readers for the captured output and the exit status.\n */\nexport function attachProcessCapture(child: ChildProcess, params: AttachProcessCaptureParams): ProcessCapture {\n  const { maxOutputLengthInCharacters, onChunk } = params;\n\n  let capturedOutput = '';\n  let exitInfo: ProcessExitInfo | undefined;\n  let isCapturing = true;\n\n  attachStream(child.stdout, 'stdout');\n  attachStream(child.stderr, 'stderr');\n\n  child.once('exit', (code: null | number, signal: NodeJS.Signals | null) => {\n    exitInfo = { code, signal };\n  });\n\n  /*\n   * A spawn failure (e.g. ENOENT for a missing binary) emits 'error', not\n   * 'exit'. Record it as a synthetic exit so a caller polling for readiness can\n   * fail fast instead of spinning out its whole budget against a process that\n   * never existed.\n   */\n  child.once('error', (error: Error) => {\n    exitInfo = { code: null, signal: null, spawnError: error.message };\n  });\n\n  return {\n    readExitInfo: () => exitInfo,\n    readOutput: () => capturedOutput,\n    stopCapture: (): void => {\n      isCapturing = false;\n    }\n  };\n\n  function attachStream(stream: null | Readable, name: ProcessOutputChunk['stream']): void {\n    if (!stream) {\n      return;\n    }\n\n    stream.on('data', (chunk: Buffer) => {\n      const text = chunk.toString();\n      onChunk?.({ stream: name, text });\n      if (isCapturing) {\n        capturedOutput = (capturedOutput + text).slice(-maxOutputLengthInCharacters);\n      }\n    });\n\n    /*\n     * `child.unref()` only releases the process handle; the stdio pipes are\n     * separate handles that keep the event loop alive on their own. A harness\n     * that pipes a detached child's output would then refuse to exit until that\n     * child died \u2014 the opposite of what `detached` + `unref` was asked for.\n     *\n     * `unref` lives on the underlying socket rather than on `Readable`, so it is\n     * reached structurally: a stream that does not carry one simply skips this.\n     */\n    (stream as Partial<StreamWithUnref>).unref?.();\n  }\n}\n"],
  "mappings": "AAqGO,SAAS,qBAAqB,OAAqB,QAAoD;AAC5G,QAAM,EAAE,6BAA6B,QAAQ,IAAI;AAEjD,MAAI,iBAAiB;AACrB,MAAI;AACJ,MAAI,cAAc;AAElB,eAAa,MAAM,QAAQ,QAAQ;AACnC,eAAa,MAAM,QAAQ,QAAQ;AAEnC,QAAM,KAAK,QAAQ,CAAC,MAAqB,WAAkC;AACzE,eAAW,EAAE,MAAM,OAAO;AAAA,EAC5B,CAAC;AAQD,QAAM,KAAK,SAAS,CAAC,UAAiB;AACpC,eAAW,EAAE,MAAM,MAAM,QAAQ,MAAM,YAAY,MAAM,QAAQ;AAAA,EACnE,CAAC;AAED,SAAO;AAAA,IACL,cAAc,MAAM;AAAA,IACpB,YAAY,MAAM;AAAA,IAClB,aAAa,MAAY;AACvB,oBAAc;AAAA,IAChB;AAAA,EACF;AAEA,WAAS,aAAa,QAAyB,MAA0C;AACvF,QAAI,CAAC,QAAQ;AACX;AAAA,IACF;AAEA,WAAO,GAAG,QAAQ,CAAC,UAAkB;AACnC,YAAM,OAAO,MAAM,SAAS;AAC5B,gBAAU,EAAE,QAAQ,MAAM,KAAK,CAAC;AAChC,UAAI,aAAa;AACf,0BAAkB,iBAAiB,MAAM,MAAM,CAAC,2BAA2B;AAAA,MAC7E;AAAA,IACF,CAAC;AAWD,IAAC,OAAoC,QAAQ;AAAA,EAC/C;AACF;",
  "names": []
}


package/dist/lib/esm/process-exit-message.d.mts

@@ -1,14 +1,32 @@
 /**
  * @file
  *
- * Pure builder for the diagnostic message describing an auto-started child
- * process (the Android emulator or the Appium server) that died during startup,
- * appending the captured output tail when available.
+ * Pure builders for the diagnostic message describing an auto-started child
+ * process (the Android emulator or the Appium server) that failed during
+ * startup, appending the captured output tail when available.
+ *
+ * A startup fails two ways — the process **dies**, or it **hangs** past a
+ * budget — and the captured tail is equally the explanation in both. So the
+ * tail-appending half is its own export, used by the timeout throws that once
+ * reported only the budget they blew.
  *
  * Kept separate from the integration-only `transport-factory` (excluded from
  * unit tests) so the message formatting stays unit-testable — the launchers
  * themselves spawn real processes.
  */
+/**
+ * Parameters for {@link appendProcessOutputTail}.
+ */
+export interface AppendProcessOutputTailParams {
+    /**
+    The captured stdout+stderr tail (empty when none was captured).
+     */
+    readonly output: string;
+    /**
+    Label for the captured output section (e.g. `"Emulator output"`).
+     */
+    readonly outputLabel: string;
+}
 /**
  * Parameters for {@link buildProcessExitMessage}.
  */
@@ -51,6 +69,22 @@ export interface ProcessExitInfo {
      */
     readonly spawnError?: string;
 }
+/**
+ * Appends a process's captured output tail to a message, when there is one.
+ *
+ * Split out of {@link buildProcessExitMessage} so the **timeout** failures can
+ * carry the tail too. A process that dies gets its output attached; one that
+ * hangs used to get `No new emulator device appeared within 300000ms.` and
+ * nothing else — even though the line that explains it (`FATAL | Running
+ * multiple emulators with the same AVD is an experimental feature`) had already
+ * been captured. The emulator writing its own diagnosis is worth nothing if the
+ * harness reads it on only one of the two ways a startup can fail.
+ *
+ * @param message - The failure message to extend.
+ * @param params - The captured tail and its label.
+ * @returns The message, with the tail appended when non-empty.
+ */
+export declare function appendProcessOutputTail(message: string, params: AppendProcessOutputTailParams): string;
 /**
  * Builds a descriptive error message for an auto-started child process that
  * exited (or failed to spawn) during startup, appending the captured output

package/dist/lib/esm/process-exit-message.mjs

@@ -1,12 +1,16 @@
+function appendProcessOutputTail(message, params) {
+  const trimmedOutput = params.output.trim();
+  if (trimmedOutput.length === 0) {
+    return message;
+  }
+  return `${message}
+
+${params.outputLabel} (tail):
+${trimmedOutput}`;
+}
 function buildProcessExitMessage(params) {
   const { exitInfo, output, outputLabel, subject } = params;
-  const reason = resolveReason(exitInfo);
-  const trimmedOutput = output.trim();
-  const details = trimmedOutput.length > 0 ? `
-
-${outputLabel} (tail):
-${trimmedOutput}` : "";
-  return `${subject} ${reason} during startup.${details}`;
+  return appendProcessOutputTail(`${subject} ${resolveReason(exitInfo)} during startup.`, { output, outputLabel });
 }
 function resolveReason(exitInfo) {
   if (exitInfo.spawnError !== void 0) {
@@ -18,6 +22,7 @@ function resolveReason(exitInfo) {
   return `exited prematurely with code ${exitInfo.code === null ? "(null)" : String(exitInfo.code)}`;
 }
 export {
+  appendProcessOutputTail,
   buildProcessExitMessage
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3Byb2Nlc3MtZXhpdC1tZXNzYWdlLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogUHVyZSBidWlsZGVyIGZvciB0aGUgZGlhZ25vc3RpYyBtZXNzYWdlIGRlc2NyaWJpbmcgYW4gYXV0by1zdGFydGVkIGNoaWxkXG4gKiBwcm9jZXNzICh0aGUgQW5kcm9pZCBlbXVsYXRvciBvciB0aGUgQXBwaXVtIHNlcnZlcikgdGhhdCBkaWVkIGR1cmluZyBzdGFydHVwLFxuICogYXBwZW5kaW5nIHRoZSBjYXB0dXJlZCBvdXRwdXQgdGFpbCB3aGVuIGF2YWlsYWJsZS5cbiAqXG4gKiBLZXB0IHNlcGFyYXRlIGZyb20gdGhlIGludGVncmF0aW9uLW9ubHkgYHRyYW5zcG9ydC1mYWN0b3J5YCAoZXhjbHVkZWQgZnJvbVxuICogdW5pdCB0ZXN0cykgc28gdGhlIG1lc3NhZ2UgZm9ybWF0dGluZyBzdGF5cyB1bml0LXRlc3RhYmxlIFx1MjAxNCB0aGUgbGF1bmNoZXJzXG4gKiB0aGVtc2VsdmVzIHNwYXduIHJlYWwgcHJvY2Vzc2VzLlxuICovXG5cbi8qKlxuICogUGFyYW1ldGVycyBmb3Ige0BsaW5rIGJ1aWxkUHJvY2Vzc0V4aXRNZXNzYWdlfS5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBCdWlsZFByb2Nlc3NFeGl0TWVzc2FnZVBhcmFtcyB7XG4gIC8qKlxuICBUaGUgcHJvY2VzcydzIGV4aXQgLyBzcGF3bi1mYWlsdXJlIGRldGFpbHMuXG4gICAqL1xuICByZWFkb25seSBleGl0SW5mbzogUHJvY2Vzc0V4aXRJbmZvO1xuXG4gIC8qKlxuICBUaGUgY2FwdHVyZWQgc3Rkb3V0K3N0ZGVyciB0YWlsIChlbXB0eSB3aGVuIG5vbmUgd2FzIGNhcHR1cmVkKS5cbiAgICovXG4gIHJlYWRvbmx5IG91dHB1dDogc3RyaW5nO1xuXG4gIC8qKlxuICBMYWJlbCBmb3IgdGhlIGNhcHR1cmVkIG91dHB1dCBzZWN0aW9uIChlLmcuIGBcIkVtdWxhdG9yIG91dHB1dFwiYCkuXG4gICAqL1xuICByZWFkb25seSBvdXRwdXRMYWJlbDogc3RyaW5nO1xuXG4gIC8qKlxuICBIdW1hbi1yZWFkYWJsZSBzdWJqZWN0IG9mIHRoZSBwcm9jZXNzIChlLmcuIGBcIkFuZHJvaWQgZW11bGF0b3JcImApLlxuICAgKi9cbiAgcmVhZG9ubHkgc3ViamVjdDogc3RyaW5nO1xufVxuXG4vKipcbiAqIERldGFpbHMgb2YgYSBzcGF3bmVkIGNoaWxkIHByb2Nlc3MgdGhhdCBoYXMgZXhpdGVkIG9yIGZhaWxlZCB0byBzcGF3bi5cbiAqXG4gKiBBIG5vcm1hbCBleGl0IHNldHMgYGNvZGVgL2BzaWduYWxgIChleGFjdGx5IG9uZSBpcyBub24tYG51bGxgKTsgYSBzcGF3blxuICogZmFpbHVyZSAoZS5nLiBgRU5PRU5UYCBmb3IgYSBtaXNzaW5nIGJpbmFyeSkgbGVhdmVzIGJvdGggYG51bGxgIGFuZCBzZXRzXG4gKiBgc3Bhd25FcnJvcmAgdG8gdGhlIGZhaWx1cmUgbWVzc2FnZS5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBQcm9jZXNzRXhpdEluZm8ge1xuICAvKipcbiAgRXhpdCBjb2RlLCBvciBgbnVsbGAgd2hlbiB0ZXJtaW5hdGVkIGJ5IGEgc2lnbmFsIG9yIHdoZW4gaXQgZmFpbGVkIHRvIHNwYXduLlxuICAgKi9cbiAgcmVhZG9ubHkgY29kZTogbnVsbCB8IG51bWJlcjtcblxuICAvKipcbiAgVGVybWluYXRpbmcgc2lnbmFsLCBvciBgbnVsbGAgd2hlbiBpdCBleGl0ZWQgbm9ybWFsbHkgb3IgZmFpbGVkIHRvIHNwYXduLlxuICAgKi9cbiAgcmVhZG9ubHkgc2lnbmFsOiBOb2RlSlMuU2lnbmFscyB8IG51bGw7XG5cbiAgLyoqXG4gIFRoZSBzcGF3bi1mYWlsdXJlIG1lc3NhZ2Ugd2hlbiB0aGUgcHJvY2VzcyBuZXZlciBzdGFydGVkIChlLmcuIGBFTk9FTlRgKSwgb3RoZXJ3aXNlIGFic2VudC5cbiAgICovXG4gIHJlYWRvbmx5IHNwYXduRXJyb3I/OiBzdHJpbmc7XG59XG5cbi8qKlxuICogQnVpbGRzIGEgZGVzY3JpcHRpdmUgZXJyb3IgbWVzc2FnZSBmb3IgYW4gYXV0by1zdGFydGVkIGNoaWxkIHByb2Nlc3MgdGhhdFxuICogZXhpdGVkIChvciBmYWlsZWQgdG8gc3Bhd24pIGR1cmluZyBzdGFydHVwLCBhcHBlbmRpbmcgdGhlIGNhcHR1cmVkIG91dHB1dFxuICogdGFpbCB3aGVuIGF2YWlsYWJsZS5cbiAqXG4gKiBAcGFyYW0gcGFyYW1zIC0gVGhlIHN1YmplY3QsIGV4aXQgZGV0YWlscywgYW5kIGNhcHR1cmVkIG91dHB1dC5cbiAqIEByZXR1cm5zIEEgaHVtYW4tcmVhZGFibGUgZXJyb3IgbWVzc2FnZS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGJ1aWxkUHJvY2Vzc0V4aXRNZXNzYWdlKHBhcmFtczogQnVpbGRQcm9jZXNzRXhpdE1lc3NhZ2VQYXJhbXMpOiBzdHJpbmcge1xuICBjb25zdCB7IGV4aXRJbmZvLCBvdXRwdXQsIG91dHB1dExhYmVsLCBzdWJqZWN0IH0gPSBwYXJhbXM7XG5cbiAgY29uc3QgcmVhc29uID0gcmVzb2x2ZVJlYXNvbihleGl0SW5mbyk7XG4gIGNvbnN0IHRyaW1tZWRPdXRwdXQgPSBvdXRwdXQudHJpbSgpO1xuICBjb25zdCBkZXRhaWxzID0gdHJpbW1lZE91dHB1dC5sZW5ndGggPiAwXG4gICAgPyBgXFxuXFxuJHtvdXRwdXRMYWJlbH0gKHRhaWwpOlxcbiR7dHJpbW1lZE91dHB1dH1gXG4gICAgOiAnJztcbiAgcmV0dXJuIGAke3N1YmplY3R9ICR7cmVhc29ufSBkdXJpbmcgc3RhcnR1cC4ke2RldGFpbHN9YDtcbn1cblxuLyoqXG4gKiBEZXNjcmliZXMgd2h5IHRoZSBwcm9jZXNzIGlzIG5vIGxvbmdlciBydW5uaW5nLlxuICpcbiAqIEBwYXJhbSBleGl0SW5mbyAtIFRoZSBleGl0IC8gc3Bhd24tZmFpbHVyZSBkZXRhaWxzLlxuICogQHJldHVybnMgVGhlIHJlYXNvbiBjbGF1c2UuXG4gKi9cbmZ1bmN0aW9uIHJlc29sdmVSZWFzb24oZXhpdEluZm86IFByb2Nlc3NFeGl0SW5mbyk6IHN0cmluZyB7XG4gIGlmIChleGl0SW5mby5zcGF3bkVycm9yICE9PSB1bmRlZmluZWQpIHtcbiAgICByZXR1cm4gYGZhaWxlZCB0byBzdGFydCAoJHtleGl0SW5mby5zcGF3bkVycm9yfSlgO1xuICB9XG4gIGlmIChleGl0SW5mby5zaWduYWwgIT09IG51bGwpIHtcbiAgICByZXR1cm4gYHdhcyB0ZXJtaW5hdGVkIGJ5IHNpZ25hbCAke2V4aXRJbmZvLnNpZ25hbH1gO1xuICB9XG4gIHJldHVybiBgZXhpdGVkIHByZW1hdHVyZWx5IHdpdGggY29kZSAke2V4aXRJbmZvLmNvZGUgPT09IG51bGwgPyAnKG51bGwpJyA6IFN0cmluZyhleGl0SW5mby5jb2RlKX1gO1xufVxuIl0sCiAgIm1hcHBpbmdzIjogIkFBcUVPLFNBQVMsd0JBQXdCLFFBQStDO0FBQ3JGLFFBQU0sRUFBRSxVQUFVLFFBQVEsYUFBYSxRQUFRLElBQUk7QUFFbkQsUUFBTSxTQUFTLGNBQWMsUUFBUTtBQUNyQyxRQUFNLGdCQUFnQixPQUFPLEtBQUs7QUFDbEMsUUFBTSxVQUFVLGNBQWMsU0FBUyxJQUNuQztBQUFBO0FBQUEsRUFBTyxXQUFXO0FBQUEsRUFBYSxhQUFhLEtBQzVDO0FBQ0osU0FBTyxHQUFHLE9BQU8sSUFBSSxNQUFNLG1CQUFtQixPQUFPO0FBQ3ZEO0FBUUEsU0FBUyxjQUFjLFVBQW1DO0FBQ3hELE1BQUksU0FBUyxlQUFlLFFBQVc7QUFDckMsV0FBTyxvQkFBb0IsU0FBUyxVQUFVO0FBQUEsRUFDaEQ7QUFDQSxNQUFJLFNBQVMsV0FBVyxNQUFNO0FBQzVCLFdBQU8sNEJBQTRCLFNBQVMsTUFBTTtBQUFBLEVBQ3BEO0FBQ0EsU0FBTyxnQ0FBZ0MsU0FBUyxTQUFTLE9BQU8sV0FBVyxPQUFPLFNBQVMsSUFBSSxDQUFDO0FBQ2xHOyIsCiAgIm5hbWVzIjogW10KfQo=
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/process-liveness.d.mts

@@ -0,0 +1,18 @@
+/**
+ * @file
+ *
+ * Cheap, synchronous "is this PID still running?" probe.
+ *
+ * Signal `0` performs the permission and existence checks without delivering a
+ * signal, on Windows as well as POSIX, so it costs nothing at teardown-poll
+ * frequency. `EPERM` means the process exists but is owned by another user —
+ * still alive, and the distinction matters: reading it as dead is how a
+ * teardown convinces itself a process it could not touch is gone.
+ */
+/**
+ * Checks whether a process is still running.
+ *
+ * @param pid - The PID to probe.
+ * @returns `true` when the process exists.
+ */
+export declare function checkIsProcessAlive(pid: number): boolean;

package/dist/lib/esm/process-liveness.mjs

@@ -0,0 +1,17 @@
+import process from "node:process";
+const PROCESS_EXISTENCE_PROBE_SIGNAL = 0;
+function checkIsProcessAlive(pid) {
+  try {
+    process.kill(pid, PROCESS_EXISTENCE_PROBE_SIGNAL);
+    return true;
+  } catch (error) {
+    return getErrorCode(error) === "EPERM";
+  }
+}
+function getErrorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
+}
+export {
+  checkIsProcessAlive
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3Byb2Nlc3MtbGl2ZW5lc3MudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBDaGVhcCwgc3luY2hyb25vdXMgXCJpcyB0aGlzIFBJRCBzdGlsbCBydW5uaW5nP1wiIHByb2JlLlxuICpcbiAqIFNpZ25hbCBgMGAgcGVyZm9ybXMgdGhlIHBlcm1pc3Npb24gYW5kIGV4aXN0ZW5jZSBjaGVja3Mgd2l0aG91dCBkZWxpdmVyaW5nIGFcbiAqIHNpZ25hbCwgb24gV2luZG93cyBhcyB3ZWxsIGFzIFBPU0lYLCBzbyBpdCBjb3N0cyBub3RoaW5nIGF0IHRlYXJkb3duLXBvbGxcbiAqIGZyZXF1ZW5jeS4gYEVQRVJNYCBtZWFucyB0aGUgcHJvY2VzcyBleGlzdHMgYnV0IGlzIG93bmVkIGJ5IGFub3RoZXIgdXNlciBcdTIwMTRcbiAqIHN0aWxsIGFsaXZlLCBhbmQgdGhlIGRpc3RpbmN0aW9uIG1hdHRlcnM6IHJlYWRpbmcgaXQgYXMgZGVhZCBpcyBob3cgYVxuICogdGVhcmRvd24gY29udmluY2VzIGl0c2VsZiBhIHByb2Nlc3MgaXQgY291bGQgbm90IHRvdWNoIGlzIGdvbmUuXG4gKi9cblxuaW1wb3J0IHByb2Nlc3MgZnJvbSAnbm9kZTpwcm9jZXNzJztcblxuY29uc3QgUFJPQ0VTU19FWElTVEVOQ0VfUFJPQkVfU0lHTkFMID0gMDtcblxuLyoqXG4gKiBDaGVja3Mgd2hldGhlciBhIHByb2Nlc3MgaXMgc3RpbGwgcnVubmluZy5cbiAqXG4gKiBAcGFyYW0gcGlkIC0gVGhlIFBJRCB0byBwcm9iZS5cbiAqIEByZXR1cm5zIGB0cnVlYCB3aGVuIHRoZSBwcm9jZXNzIGV4aXN0cy5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGNoZWNrSXNQcm9jZXNzQWxpdmUocGlkOiBudW1iZXIpOiBib29sZWFuIHtcbiAgdHJ5IHtcbiAgICBwcm9jZXNzLmtpbGwocGlkLCBQUk9DRVNTX0VYSVNURU5DRV9QUk9CRV9TSUdOQUwpO1xuICAgIHJldHVybiB0cnVlO1xuICB9IGNhdGNoIChlcnJvcjogdW5rbm93bikge1xuICAgIHJldHVybiBnZXRFcnJvckNvZGUoZXJyb3IpID09PSAnRVBFUk0nO1xuICB9XG59XG5cbmZ1bmN0aW9uIGdldEVycm9yQ29kZShlcnJvcjogdW5rbm93bik6IHN0cmluZyB8IHVuZGVmaW5lZCB7XG4gIHJldHVybiB0eXBlb2YgZXJyb3IgPT09ICdvYmplY3QnICYmIGVycm9yICE9PSBudWxsICYmICdjb2RlJyBpbiBlcnJvciA/IFN0cmluZyhlcnJvci5jb2RlKSA6IHVuZGVmaW5lZDtcbn1cbiJdLAogICJtYXBwaW5ncyI6ICJBQVlBLE9BQU8sYUFBYTtBQUVwQixNQUFNLGlDQUFpQztBQVFoQyxTQUFTLG9CQUFvQixLQUFzQjtBQUN4RCxNQUFJO0FBQ0YsWUFBUSxLQUFLLEtBQUssOEJBQThCO0FBQ2hELFdBQU87QUFBQSxFQUNULFNBQVMsT0FBZ0I7QUFDdkIsV0FBTyxhQUFhLEtBQUssTUFBTTtBQUFBLEVBQ2pDO0FBQ0Y7QUFFQSxTQUFTLGFBQWEsT0FBb0M7QUFDeEQsU0FBTyxPQUFPLFVBQVUsWUFBWSxVQUFVLFFBQVEsVUFBVSxRQUFRLE9BQU8sTUFBTSxJQUFJLElBQUk7QUFDL0Y7IiwKICAibmFtZXMiOiBbXQp9Cg==