obsidian-integration-testing 11.0.0 → 12.1.0

package/dist/lib/cjs/owned-vault-seed.cjs

@@ -22,17 +22,21 @@ __export(owned_vault_seed_exports, {
 });
 module.exports = __toCommonJS(owned_vault_seed_exports);
 function buildOwnedObsidianJson(params) {
+  const shouldAutoOpenVault = params.shouldAutoOpenVault ?? true;
+  const entry = shouldAutoOpenVault ? { open: true, path: params.vaultPath, ts: params.ts } : { path: params.vaultPath, ts: params.ts };
   return {
+    // Spread rather than `last_open: undefined`, so the key is genuinely absent from
+    // The written JSON: this seed is read by Obsidian versions spanning a decade, and
+    // A present-but-undefined auto-open marker is not a shape any of them was tested
+    // Against.
     // eslint-disable-next-line camelcase -- Obsidian's own obsidian.json field name (old versions' auto-open marker).
-    last_open: params.vaultId,
+    ...shouldAutoOpenVault && { last_open: params.vaultId },
     updateDisabled: true,
-    vaults: {
-      [params.vaultId]: { open: true, path: params.vaultPath, ts: params.ts }
-    }
+    vaults: { [params.vaultId]: entry }
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   buildOwnedObsidianJson
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL293bmVkLXZhdWx0LXNlZWQudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBCdWlsZHMgdGhlIGlzb2xhdGVkIGBvYnNpZGlhbi5qc29uYCB0aGUgaGFybmVzcyBwcmUtc2VlZHMgaW50byBhbiBvd25lZFxuICogaW5zdGFuY2UncyB0ZW1wIGAtLXVzZXItZGF0YS1kaXJgIHNvIE9ic2lkaWFuIG9wZW5zIHRoZSBoYXJuZXNzIHZhdWx0IGRpcmVjdGx5XG4gKiBpbnN0ZWFkIG9mIHNob3dpbmcgdGhlIGZpcnN0LXJ1biB2YXVsdC1zZWxlY3RvciAodGhlIGBzdGFydGVyLXNjcmVlbmApLlxuICpcbiAqIFRoZSBhdXRvLW9wZW4gbWFya2VyIGNoYW5nZWQgYWNyb3NzIE9ic2lkaWFuJ3MgaGlzdG9yeSwgc28gdGhlIHNlZWQgY2Fycmllc1xuICogQk9USCBmb3JtcyBhbmQgZWFjaCB2ZXJzaW9uIHJlYWRzIHRoZSBvbmUgaXQgdW5kZXJzdGFuZHMgKGlnbm9yaW5nIHRoZSBvdGhlclxuICogdW5rbm93biBrZXkpIFx1MjAxNCBubyBwZXItdmVyc2lvbiBicmFuY2hpbmc6XG4gKlxuICogLSAqKk9sZCB2ZXJzaW9ucyoqIChjb25maXJtZWQgMC42LjQpIGF1dG8tb3BlbiBmcm9tIGEgKip0b3AtbGV2ZWwgYGxhc3Rfb3BlbmAqKlxuICogICBob2xkaW5nIHRoZSB2YXVsdCBpZCAoYG1haW4uanNgOiBgaWYgKGlkICYmIHZhdWx0cy5oYXNPd25Qcm9wZXJ0eShpZCkpXG4gKiAgIGNyZWF0ZVdpbmRvdyhpZCk7IGVsc2Ugb3BlblN0YXJ0ZXIoKTtgKSwgYW5kIHN0b3JlIGVhY2ggdmF1bHQgZW50cnkgYXMganVzdFxuICogICBgeyBwYXRoLCB0cyB9YC4gV2l0aG91dCBgbGFzdF9vcGVuYCB0aGV5IGZhbGwgdGhyb3VnaCB0byB0aGUgdmF1bHQtc2VsZWN0b3IuXG4gKiAtICoqTmV3ZXIgdmVyc2lvbnMqKiAoY29uZmlybWVkIDAuMTQuNSspIGRyb3BwZWQgYGxhc3Rfb3BlbmAgYW5kIGF1dG8tb3BlbiBmcm9tXG4gKiAgIHRoZSBwZXItZW50cnkgKipgb3BlbjogdHJ1ZWAqKiBmbGFnLlxuICpcbiAqIFNlZWRpbmcgYm90aCB3YXMgdmVyaWZpZWQgdG8gb3BlbiB0aGUgdmF1bHQgZGlyZWN0bHkgKG5vIHNlbGVjdG9yKSBvbiAwLjYuNCxcbiAqIDAuOS4yMCwgMC4xMi4xOSwgMC4xMy4xOSwgMC4xNC41IGFuZCAxLjEyLjcuIGB1cGRhdGVEaXNhYmxlZGAgc3VwcHJlc3NlcyB0aGVcbiAqIHRocm93YXdheSBpbnN0YW5jZSdzIHNlbGYtdXBkYXRlLlxuICpcbiAqIEJvdGggbWFya2VycyBjYW4gYWxzbyBiZSAqKndpdGhoZWxkKiogXHUyMDE0IHNlZVxuICoge0BsaW5rIEJ1aWxkT3duZWRPYnNpZGlhbkpzb25QYXJhbXMuc2hvdWxkQXV0b09wZW5WYXVsdH0uIFRoZSBvbmUgY2FsbGVyIHRoYXRcbiAqIGRvZXMgc28gd2FudHMgdGhlIHN0YXJ0ZXIgc2NyZWVuIG9uIHB1cnBvc2U6IGEgYGNvbmZpZ0RpcmVjdG9yeWAgb3ZlcnJpZGUgaXMgYVxuICogYGxvY2FsU3RvcmFnZWAgZW50cnksIGFuZCBgbG9jYWxTdG9yYWdlYCBvbmx5IGV4aXN0cyBvbmNlIGEgcmVuZGVyZXIgZG9lcywgc29cbiAqIHRoZSBvdmVycmlkZSBoYXMgdG8gYmUgd3JpdHRlbiBpbiB0aGUgc3RhcnRlciBzY3JlZW4ncyByZW5kZXJlciBiZWZvcmUgdGhlXG4gKiB2YXVsdCdzIG93biB3aW5kb3cgaXMgY3JlYXRlZC4gVGhlIHZhdWx0IHN0YXlzIHJlZ2lzdGVyZWQgdW5kZXIgdGhlIGhhcm5lc3Mnc1xuICogaWQgZWl0aGVyIHdheSwgYW5kIHRoZSBsYXRlciBgdmF1bHQtb3BlbmAgSVBDIHJldXNlcyB0aGF0IGlkICh2ZXJpZmllZCBvblxuICogMS4xMy43KSByYXRoZXIgdGhhbiBtaW50aW5nIGEgc2Vjb25kIGVudHJ5IFx1MjAxNCB3aGljaCBpcyB3aGF0IG1ha2VzIHRoZVxuICogYDx2YXVsdElkPi1jb25maWdgIGtleSBuYW1lIGtub3dhYmxlIGJlZm9yZSBsYXVuY2guXG4gKi9cblxuLyoqXG4gKiBQYXJhbWV0ZXJzIGZvciB7QGxpbmsgYnVpbGRPd25lZE9ic2lkaWFuSnNvbn0uXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQnVpbGRPd25lZE9ic2lkaWFuSnNvblBhcmFtcyB7XG4gIC8qKlxuICAgKiBXaGV0aGVyIHRvIGluY2x1ZGUgdGhlIGF1dG8tb3BlbiBtYXJrZXJzLCBzbyBPYnNpZGlhbiBvcGVucyB0aGUgdmF1bHRcbiAgICogZGlyZWN0bHkgaW5zdGVhZCBvZiBzaG93aW5nIHRoZSBzdGFydGVyIHNjcmVlbi4gUGFzcyBgZmFsc2VgIHRvIGtlZXAgdGhlXG4gICAqIHZhdWx0IHJlZ2lzdGVyZWQgYnV0IGNsb3NlZCBcdTIwMTQgdGhlIGNhbGxlciB0aGVuIG9wZW5zIGl0IGl0c2VsZiwgb3ZlciB0aGVcbiAgICogYHZhdWx0LW9wZW5gIElQQywgb25jZSBpdCBoYXMgcHJlcGFyZWQgdGhlIHN0YXJ0ZXIgc2NyZWVuJ3MgcmVuZGVyZXIuXG4gICAqXG4gICAqIEBkZWZhdWx0IGB0cnVlYFxuICAgKi9cbiAgcmVhZG9ubHkgc2hvdWxkQXV0b09wZW5WYXVsdD86IGJvb2xlYW47XG5cbiAgLyoqXG4gIExhc3QtYWNjZXNzIHRpbWVzdGFtcCB0byBzdGFtcCBvbiB0aGUgdmF1bHQgZW50cnkuXG4gICAqL1xuICByZWFkb25seSB0czogbnVtYmVyO1xuXG4gIC8qKlxuICBUaGUgcmFuZG9tbHktZ2VuZXJhdGVkIHZhdWx0IGlkIHVzZWQgYXMgdGhlIHJlZ2lzdHJ5IGtleSBhbmQgYGxhc3Rfb3BlbmAuXG4gICAqL1xuICByZWFkb25seSB2YXVsdElkOiBzdHJpbmc7XG5cbiAgLyoqXG4gIEFic29sdXRlIHBhdGggdG8gdGhlIGhhcm5lc3MgdmF1bHQgZm9sZGVyLlxuICAgKi9cbiAgcmVhZG9ubHkgdmF1bHRQYXRoOiBzdHJpbmc7XG59XG5cbi8qKlxuICogVGhlIGBvYnNpZGlhbi5qc29uYCBzdHJ1Y3R1cmUgdGhlIGhhcm5lc3Mgc2VlZHMgZm9yIGFuIG93bmVkIGluc3RhbmNlLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIE93bmVkT2JzaWRpYW5Kc29uIHtcbiAgLyoqXG4gICAqIFRvcC1sZXZlbCBhdXRvLW9wZW4gbWFya2VyICh2YXVsdCBpZCkgaG9ub3JlZCBieSBvbGQgT2JzaWRpYW4gdmVyc2lvbnM7XG4gICAqIGlnbm9yZWQgYXMgYW4gdW5rbm93biBrZXkgYnkgbmV3ZXIgdmVyc2lvbnMgdGhhdCB1c2UgdGhlIHBlci1lbnRyeSBgb3BlbmAuXG4gICAqIE9taXR0ZWQgd2hlbiB0aGUgY2FsbGVyIHdpdGhoZWxkIHRoZSBhdXRvLW9wZW4gbWFya2Vycy5cbiAgICovXG4gIHJlYWRvbmx5IGxhc3Rfb3Blbj86IHN0cmluZztcblxuICAvKipcbiAgRGlzYWJsZXMgdGhlIHRocm93YXdheSBpbnN0YW5jZSdzIHNlbGYtdXBkYXRlLlxuICAgKi9cbiAgcmVhZG9ubHkgdXBkYXRlRGlzYWJsZWQ6IHRydWU7XG5cbiAgLyoqXG4gIFZhdWx0IHJlZ2lzdHJ5IGtleWVkIGJ5IHZhdWx0IGlkLlxuICAgKi9cbiAgcmVhZG9ubHkgdmF1bHRzOiBSZWFkb25seTxSZWNvcmQ8c3RyaW5nLCBPd25lZE9ic2lkaWFuVmF1bHRFbnRyeT4+O1xufVxuXG4vKipcbiAqIEEgc2luZ2xlIHZhdWx0IGVudHJ5IGluIHRoZSBzZWVkZWQgYG9ic2lkaWFuLmpzb25gLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIE93bmVkT2JzaWRpYW5WYXVsdEVudHJ5IHtcbiAgLyoqXG4gICAqIFBlci1lbnRyeSBhdXRvLW9wZW4gZmxhZyBob25vcmVkIGJ5IG5ld2VyIE9ic2lkaWFuIHZlcnNpb25zLiBPbWl0dGVkIHdoZW5cbiAgICogdGhlIGNhbGxlciB3aXRoaGVsZCB0aGUgYXV0by1vcGVuIG1hcmtlcnMuXG4gICAqL1xuICByZWFkb25seSBvcGVuPzogdHJ1ZTtcblxuICAvKipcbiAgQWJzb2x1dGUgcGF0aCB0byB0aGUgaGFybmVzcyB2YXVsdCBmb2xkZXIuXG4gICAqL1xuICByZWFkb25seSBwYXRoOiBzdHJpbmc7XG5cbiAgLyoqXG4gIExhc3QtYWNjZXNzIHRpbWVzdGFtcC5cbiAgICovXG4gIHJlYWRvbmx5IHRzOiBudW1iZXI7XG59XG5cbi8qKlxuICogQnVpbGRzIHRoZSBpc29sYXRlZCBgb2JzaWRpYW4uanNvbmAgdGhhdCBmb3JjZS1vcGVucyB0aGUgb3duZWQgdmF1bHQgYWNyb3NzIGFsbFxuICogc3VwcG9ydGVkIE9ic2lkaWFuIHZlcnNpb25zIChzZWUgdGhlIGZpbGUgb3ZlcnZpZXcgZm9yIHRoZSBkdWFsLW1hcmtlclxuICogcmF0aW9uYWxlKS5cbiAqXG4gKiBAcGFyYW0gcGFyYW1zIC0gVGhlIHZhdWx0IGlkLCBwYXRoLCBhbmQgdGltZXN0YW1wIHRvIHNlZWQuXG4gKiBAcmV0dXJucyBUaGUgYG9ic2lkaWFuLmpzb25gIG9iamVjdCB0byB3cml0ZSBpbnRvIHRoZSBvd25lZCB1c2VyLWRhdGEgZGlyLlxuICovXG5leHBvcnQgZnVuY3Rpb24gYnVpbGRPd25lZE9ic2lkaWFuSnNvbihwYXJhbXM6IEJ1aWxkT3duZWRPYnNpZGlhbkpzb25QYXJhbXMpOiBPd25lZE9ic2lkaWFuSnNvbiB7XG4gIGNvbnN0IHNob3VsZEF1dG9PcGVuVmF1bHQgPSBwYXJhbXMuc2hvdWxkQXV0b09wZW5WYXVsdCA/PyB0cnVlO1xuICBjb25zdCBlbnRyeTogT3duZWRPYnNpZGlhblZhdWx0RW50cnkgPSBzaG91bGRBdXRvT3BlblZhdWx0XG4gICAgPyB7IG9wZW46IHRydWUsIHBhdGg6IHBhcmFtcy52YXVsdFBhdGgsIHRzOiBwYXJhbXMudHMgfVxuICAgIDogeyBwYXRoOiBwYXJhbXMudmF1bHRQYXRoLCB0czogcGFyYW1zLnRzIH07XG5cbiAgcmV0dXJuIHtcbiAgICAvLyBTcHJlYWQgcmF0aGVyIHRoYW4gYGxhc3Rfb3BlbjogdW5kZWZpbmVkYCwgc28gdGhlIGtleSBpcyBnZW51aW5lbHkgYWJzZW50IGZyb21cbiAgICAvLyBUaGUgd3JpdHRlbiBKU09OOiB0aGlzIHNlZWQgaXMgcmVhZCBieSBPYnNpZGlhbiB2ZXJzaW9ucyBzcGFubmluZyBhIGRlY2FkZSwgYW5kXG4gICAgLy8gQSBwcmVzZW50LWJ1dC11bmRlZmluZWQgYXV0by1vcGVuIG1hcmtlciBpcyBub3QgYSBzaGFwZSBhbnkgb2YgdGhlbSB3YXMgdGVzdGVkXG4gICAgLy8gQWdhaW5zdC5cbiAgICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgY2FtZWxjYXNlIC0tIE9ic2lkaWFuJ3Mgb3duIG9ic2lkaWFuLmpzb24gZmllbGQgbmFtZSAob2xkIHZlcnNpb25zJyBhdXRvLW9wZW4gbWFya2VyKS5cbiAgICAuLi5zaG91bGRBdXRvT3BlblZhdWx0ICYmIHsgbGFzdF9vcGVuOiBwYXJhbXMudmF1bHRJZCB9LFxuICAgIHVwZGF0ZURpc2FibGVkOiB0cnVlLFxuICAgIHZhdWx0czogeyBbcGFyYW1zLnZhdWx0SWRdOiBlbnRyeSB9XG4gIH07XG59XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBa0hPLFNBQVMsdUJBQXVCLFFBQXlEO0FBQzlGLFFBQU0sc0JBQXNCLE9BQU8sdUJBQXVCO0FBQzFELFFBQU0sUUFBaUMsc0JBQ25DLEVBQUUsTUFBTSxNQUFNLE1BQU0sT0FBTyxXQUFXLElBQUksT0FBTyxHQUFHLElBQ3BELEVBQUUsTUFBTSxPQUFPLFdBQVcsSUFBSSxPQUFPLEdBQUc7QUFFNUMsU0FBTztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSxJQU1MLEdBQUcsdUJBQXVCLEVBQUUsV0FBVyxPQUFPLFFBQVE7QUFBQSxJQUN0RCxnQkFBZ0I7QUFBQSxJQUNoQixRQUFRLEVBQUUsQ0FBQyxPQUFPLE9BQU8sR0FBRyxNQUFNO0FBQUEsRUFDcEM7QUFDRjsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/lib/cjs/owned-vault-seed.d.cts

@@ -19,11 +19,30 @@
  * Seeding both was verified to open the vault directly (no selector) on 0.6.4,
  * 0.9.20, 0.12.19, 0.13.19, 0.14.5 and 1.12.7. `updateDisabled` suppresses the
  * throwaway instance's self-update.
+ *
+ * Both markers can also be **withheld** — see
+ * {@link BuildOwnedObsidianJsonParams.shouldAutoOpenVault}. The one caller that
+ * does so wants the starter screen on purpose: a `configDirectory` override is a
+ * `localStorage` entry, and `localStorage` only exists once a renderer does, so
+ * the override has to be written in the starter screen's renderer before the
+ * vault's own window is created. The vault stays registered under the harness's
+ * id either way, and the later `vault-open` IPC reuses that id (verified on
+ * 1.13.7) rather than minting a second entry — which is what makes the
+ * `<vaultId>-config` key name knowable before launch.
  */
 /**
  * Parameters for {@link buildOwnedObsidianJson}.
  */
 export interface BuildOwnedObsidianJsonParams {
+    /**
+     * Whether to include the auto-open markers, so Obsidian opens the vault
+     * directly instead of showing the starter screen. Pass `false` to keep the
+     * vault registered but closed — the caller then opens it itself, over the
+     * `vault-open` IPC, once it has prepared the starter screen's renderer.
+     *
+     * @default `true`
+     */
+    readonly shouldAutoOpenVault?: boolean;
     /**
     Last-access timestamp to stamp on the vault entry.
      */
@@ -44,8 +63,9 @@ export interface OwnedObsidianJson {
     /**
      * Top-level auto-open marker (vault id) honored by old Obsidian versions;
      * ignored as an unknown key by newer versions that use the per-entry `open`.
+     * Omitted when the caller withheld the auto-open markers.
      */
-    readonly last_open: string;
+    readonly last_open?: string;
     /**
     Disables the throwaway instance's self-update.
      */
@@ -60,9 +80,10 @@ export interface OwnedObsidianJson {
  */
 export interface OwnedObsidianVaultEntry {
     /**
-    Per-entry auto-open flag honored by newer Obsidian versions.
+     * Per-entry auto-open flag honored by newer Obsidian versions. Omitted when
+     * the caller withheld the auto-open markers.
      */
-    readonly open: true;
+    readonly open?: true;
     /**
     Absolute path to the harness vault folder.
      */

package/dist/lib/cjs/parent-liveness.cjs

@@ -25,6 +25,8 @@ __export(parent_liveness_exports, {
 module.exports = __toCommonJS(parent_liveness_exports);
 var import_node_net = require("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';
@@ -39,20 +41,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() {
@@ -90,4 +127,4 @@ async function listenOnFreeLoopbackPort(server) {
   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": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAsCA,sBAA6B;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,aAAS,8BAAa,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": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgEA,sBAA6B;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,aAAS,8BAAa,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/cjs/parent-liveness.d.cts

@@ -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/cjs/port-owner.cjs

@@ -0,0 +1,61 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var port_owner_exports = {};
+__export(port_owner_exports, {
+  parsePosixLsofPids: () => parsePosixLsofPids,
+  parseWindowsNetstatPids: () => parseWindowsNetstatPids
+});
+module.exports = __toCommonJS(port_owner_exports);
+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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parsePosixLsofPids,
+  parseWindowsNetstatPids
+});
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -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/cjs/process-capture.cjs

@@ -0,0 +1,62 @@
+"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 process_capture_exports = {};
+__export(process_capture_exports, {
+  attachProcessCapture: () => attachProcessCapture
+});
+module.exports = __toCommonJS(process_capture_exports);
+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?.();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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.cjs';\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": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;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/cjs/process-capture.d.cts

@@ -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.cjs';
+/**
+ * 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/cjs/process-exit-message.cjs

@@ -18,18 +18,23 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var process_exit_message_exports = {};
 __export(process_exit_message_exports, {
+  appendProcessOutputTail: () => appendProcessOutputTail,
   buildProcessExitMessage: () => buildProcessExitMessage
 });
 module.exports = __toCommonJS(process_exit_message_exports);
+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) {
@@ -42,6 +47,7 @@ function resolveReason(exitInfo) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  appendProcessOutputTail,
   buildProcessExitMessage
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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