obsidian-integration-testing 12.0.0 → 12.1.0

package/dist/lib/esm/obsidian-instance.d.mts

@@ -9,6 +9,7 @@
  * is keyed to the user-data dir, the owned instance runs in parallel with the
  * user's own Obsidian. Confirmed by the Phase 0 spike (see the project plan).
  */
+import type { ProcessExitInfo } from './process-exit-message.mjs';
 /**
  * Parameters for {@link launchOwnedObsidianInstance}.
  */
@@ -57,6 +58,17 @@ export interface OwnedObsidianInstance {
     The CDP remote-debugging port the instance was launched with.
      */
     readonly port: number;
+    /**
+     * Returns how the instance died once it is no longer running, otherwise
+     * `undefined`. This is the in-process half of the answer; a test worker in
+     * another process reads the same facts from the exit marker
+     * (`owned-instance-exit-marker.ts`).
+     */
+    readExitInfo(): ProcessExitInfo | undefined;
+    /**
+    Returns the tail of everything the instance wrote to stdout/stderr.
+     */
+    readOutput(): string;
 }
 /**
  * Launches an isolated, harness-owned Obsidian instance and waits until its CDP

package/dist/lib/esm/obsidian-instance.mjs

@@ -2,31 +2,83 @@ import { spawn } from "node:child_process";
 import { createServer } from "node:net";
 import { killProcessTree } from "./kill-process-tree.mjs";
 import { log } from "./log.mjs";
+import {
+  clearOwnedInstanceExitMarker,
+  writeOwnedInstanceExitMarker
+} from "./owned-instance-exit-marker.mjs";
+import { OwnedInstanceExitedError } from "./owned-instance-exited-error.mjs";
 import { startParentLivenessServer } from "./parent-liveness.mjs";
+import { attachProcessCapture } from "./process-capture.mjs";
 const DEFAULT_CDP_HOST = "127.0.0.1";
 const CDP_READY_POLL_INTERVAL_IN_MILLISECONDS = 1e3;
 const CDP_READY_TIMEOUT_IN_MILLISECONDS = 6e4;
+const OBSIDIAN_OUTPUT_TAIL_MAX_LENGTH = 8e3;
 async function launchOwnedObsidianInstance(params) {
   const cdpHost = params.cdpHost ?? DEFAULT_CDP_HOST;
   const port = await pickFreePort();
   const cdpUrl = `http://${cdpHost}:${String(port)}`;
   const livenessServer = await startParentLivenessServer();
+  clearOwnedInstanceExitMarker(port);
   log(`[obsidian-instance] Launching owned Obsidian: userData=${params.userDataDirectory}, cdpPort=${String(port)}`);
   const child = spawn(
     params.exePath,
     [`--user-data-dir=${params.userDataDirectory}`, `--remote-debugging-port=${String(port)}`, ...params.extraArguments ?? []],
-    { detached: true, stdio: "ignore" }
+    { detached: true, stdio: ["ignore", "pipe", "pipe"] }
   );
+  const capture = attachProcessCapture(child, {
+    maxOutputLengthInCharacters: OBSIDIAN_OUTPUT_TAIL_MAX_LENGTH,
+    onChunk: (chunk) => {
+      const text = chunk.text.trimEnd();
+      if (text.length > 0) {
+        log(`[obsidian-instance:${chunk.stream}] ${text}`);
+      }
+    }
+  });
+  let isKillExpected = false;
+  child.once("exit", (code, signal) => {
+    if (isKillExpected) {
+      log(`[obsidian-instance] Owned Obsidian exited as asked: pid=${String(child.pid)} code=${String(code)} signal=${String(signal)}`);
+      return;
+    }
+    log(`[obsidian-instance] !!! OWNED OBSIDIAN EXITED: pid=${String(child.pid)} code=${String(code)} signal=${String(signal)}`);
+    writeOwnedInstanceExitMarker({
+      code,
+      outputTail: capture.readOutput(),
+      pid: child.pid,
+      port,
+      signal
+    });
+  });
   child.unref();
   try {
     await waitForCdpReady(cdpUrl);
     log(`[obsidian-instance] Owned Obsidian is serving CDP at ${cdpUrl}.`);
-    return { cdpUrl, kill, parentLivenessPort: livenessServer.port, port };
+    return {
+      cdpUrl,
+      kill,
+      parentLivenessPort: livenessServer.port,
+      port,
+      readExitInfo: () => capture.readExitInfo(),
+      readOutput: () => capture.readOutput()
+    };
   } catch (error) {
+    const exitInfo = capture.readExitInfo();
     kill();
+    if (exitInfo) {
+      throw new OwnedInstanceExitedError({
+        cdpUrl,
+        code: exitInfo.code,
+        outputTail: capture.readOutput(),
+        pid: child.pid,
+        signal: exitInfo.signal,
+        spawnError: exitInfo.spawnError
+      });
+    }
     throw error;
   }
   function kill() {
+    isKillExpected = true;
+    clearOwnedInstanceExitMarker(port);
     livenessServer.close();
     killProcessTree(child);
   }
@@ -75,4 +127,4 @@ export {
   launchOwnedObsidianInstance,
   pickFreePort
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/obsidian-instance.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Launches and manages a harness-owned, isolated Obsidian desktop instance.\n *\n * The instance runs against a dedicated `--user-data-dir` (so it never touches\n * the user's Obsidian config, registry, or running window) and exposes CDP on a\n * dedicated `--remote-debugging-port`. Because Electron's single-instance lock\n * is keyed to the user-data dir, the owned instance runs in parallel with the\n * user's own Obsidian. Confirmed by the Phase 0 spike (see the project plan).\n */\n\n/* v8 ignore start -- Integration-time process management covered by integration tests, not unit tests. */\n\nimport { spawn } from 'node:child_process';\nimport { createServer } from 'node:net';\n\nimport { killProcessTree } from './kill-process-tree.mjs';\nimport { log } from './log.mjs';\nimport { startParentLivenessServer } from './parent-liveness.mjs';\n\n/**\n * Parameters for {@link launchOwnedObsidianInstance}.\n */\nexport interface LaunchOwnedObsidianInstanceParams {\n  /**\n   * CDP host to bind/poll.\n   *\n   * @default `'127.0.0.1'`\n   */\n  readonly cdpHost?: string;\n\n  /**\n  Absolute path to the Obsidian executable (shell) to launch.\n   */\n  readonly exePath: string;\n\n  /**\n   * Extra command-line arguments appended after `--user-data-dir` and\n   * `--remote-debugging-port` \u2014 used to pass the keep-alive Chromium flags when\n   * the instance is launched hidden (off-screen). Empty by default.\n   */\n  readonly extraArguments?: readonly string[];\n\n  /**\n  Absolute path to the isolated user-data dir to pass via `--user-data-dir`.\n   */\n\n  readonly userDataDirectory: string;\n}\n\n/**\n * A running, harness-owned Obsidian instance.\n */\nexport interface OwnedObsidianInstance {\n  /**\n  Base CDP URL, e.g. `http://127.0.0.1:51888`.\n   */\n  readonly cdpUrl: string;\n\n  /**\n  Kills the instance and its entire process tree.\n   */\n  kill(): void;\n\n  /**\n   * Loopback port the instance's renderer connects back to so it destroys\n   * itself if this harness process dies without cleaning up. See\n   * `parent-liveness.ts` for why the parent/child relationship alone is not\n   * enough.\n   */\n  readonly parentLivenessPort: number;\n\n  /**\n  The CDP remote-debugging port the instance was launched with.\n   */\n  readonly port: number;\n}\n\nconst DEFAULT_CDP_HOST = '127.0.0.1';\nconst CDP_READY_POLL_INTERVAL_IN_MILLISECONDS = 1000;\nconst CDP_READY_TIMEOUT_IN_MILLISECONDS = 60_000;\n\ninterface CdpTarget {\n  type: string;\n}\n\n/**\n * Launches an isolated, harness-owned Obsidian instance and waits until its CDP\n * endpoint is serving page targets.\n *\n * @param params - Launch parameters.\n * @returns The running owned instance.\n * @throws Error if CDP does not become reachable within the timeout.\n */\nexport async function launchOwnedObsidianInstance(\n  params: LaunchOwnedObsidianInstanceParams\n): Promise<OwnedObsidianInstance> {\n  const cdpHost = params.cdpHost ?? DEFAULT_CDP_HOST;\n  const port = await pickFreePort();\n  const cdpUrl = `http://${cdpHost}:${String(port)}`;\n\n  // Listen BEFORE spawning, so the renderer watchdog can never race the server\n  // Into a failed connect (which it treats as \"no watchdog\", leaving the instance alive).\n  const livenessServer = await startParentLivenessServer();\n\n  log(`[obsidian-instance] Launching owned Obsidian: userData=${params.userDataDirectory}, cdpPort=${String(port)}`);\n  const child = spawn(\n    params.exePath,\n    [`--user-data-dir=${params.userDataDirectory}`, `--remote-debugging-port=${String(port)}`, ...(params.extraArguments ?? [])],\n    { detached: true, stdio: 'ignore' }\n  );\n  child.unref();\n\n  try {\n    await waitForCdpReady(cdpUrl);\n    log(`[obsidian-instance] Owned Obsidian is serving CDP at ${cdpUrl}.`);\n    return { cdpUrl, kill, parentLivenessPort: livenessServer.port, port };\n  } catch (error: unknown) {\n    kill();\n    throw error;\n  }\n\n  function kill(): void {\n    livenessServer.close();\n    killProcessTree(child);\n  }\n}\n\n/**\n * Picks a free TCP port by binding to port `0` and reading the assigned port.\n *\n * There is a small time-of-check/time-of-use window between releasing the port\n * here and Obsidian binding it; in practice it is negligible for test runs.\n *\n * @returns A free TCP port.\n */\nexport function pickFreePort(): Promise<number> {\n  return new Promise((resolve, reject) => {\n    const server = createServer();\n    server.once('error', reject);\n    server.listen(0, DEFAULT_CDP_HOST, () => {\n      const address = server.address();\n      if (address === null || typeof address === 'string') {\n        server.close();\n        reject(new Error('Failed to determine a free port.'));\n        return;\n      }\n      const { port } = address;\n      server.close(() => {\n        resolve(port);\n      });\n    });\n  });\n}\n\n/**\n * Returns a promise that resolves after the given delay.\n *\n * @param ms - The delay in milliseconds.\n * @returns A promise that resolves after the delay.\n */\nfunction delay(ms: number): Promise<void> {\n  return new Promise((resolve) => {\n    setTimeout(resolve, ms);\n  });\n}\n\n/**\n * Polls the CDP `/json` endpoint until at least one page target appears.\n *\n * @param cdpUrl - The base CDP URL.\n */\nasync function waitForCdpReady(cdpUrl: string): Promise<void> {\n  const deadline = Date.now() + CDP_READY_TIMEOUT_IN_MILLISECONDS;\n  while (Date.now() < deadline) {\n    try {\n      const response = await fetch(`${cdpUrl}/json`);\n      const targets = await response.json() as CdpTarget[];\n      if (targets.some((target) => target.type === 'page')) {\n        return;\n      }\n    } catch {\n      // Endpoint not up yet \u2014 keep polling.\n    }\n    await delay(CDP_READY_POLL_INTERVAL_IN_MILLISECONDS);\n  }\n  throw new Error(\n    `Owned Obsidian instance did not expose CDP at ${cdpUrl} within ${String(CDP_READY_TIMEOUT_IN_MILLISECONDS)}ms.`\n  );\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AAcA,SAAS,aAAa;AACtB,SAAS,oBAAoB;AAE7B,SAAS,uBAAuB;AAChC,SAAS,WAAW;AACpB,SAAS,iCAAiC;AA4D1C,MAAM,mBAAmB;AACzB,MAAM,0CAA0C;AAChD,MAAM,oCAAoC;AAc1C,eAAsB,4BACpB,QACgC;AAChC,QAAM,UAAU,OAAO,WAAW;AAClC,QAAM,OAAO,MAAM,aAAa;AAChC,QAAM,SAAS,UAAU,OAAO,IAAI,OAAO,IAAI,CAAC;AAIhD,QAAM,iBAAiB,MAAM,0BAA0B;AAEvD,MAAI,0DAA0D,OAAO,iBAAiB,aAAa,OAAO,IAAI,CAAC,EAAE;AACjH,QAAM,QAAQ;AAAA,IACZ,OAAO;AAAA,IACP,CAAC,mBAAmB,OAAO,iBAAiB,IAAI,2BAA2B,OAAO,IAAI,CAAC,IAAI,GAAI,OAAO,kBAAkB,CAAC,CAAE;AAAA,IAC3H,EAAE,UAAU,MAAM,OAAO,SAAS;AAAA,EACpC;AACA,QAAM,MAAM;AAEZ,MAAI;AACF,UAAM,gBAAgB,MAAM;AAC5B,QAAI,wDAAwD,MAAM,GAAG;AACrE,WAAO,EAAE,QAAQ,MAAM,oBAAoB,eAAe,MAAM,KAAK;AAAA,EACvE,SAAS,OAAgB;AACvB,SAAK;AACL,UAAM;AAAA,EACR;AAEA,WAAS,OAAa;AACpB,mBAAe,MAAM;AACrB,oBAAgB,KAAK;AAAA,EACvB;AACF;AAUO,SAAS,eAAgC;AAC9C,SAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,UAAM,SAAS,aAAa;AAC5B,WAAO,KAAK,SAAS,MAAM;AAC3B,WAAO,OAAO,GAAG,kBAAkB,MAAM;AACvC,YAAM,UAAU,OAAO,QAAQ;AAC/B,UAAI,YAAY,QAAQ,OAAO,YAAY,UAAU;AACnD,eAAO,MAAM;AACb,eAAO,IAAI,MAAM,kCAAkC,CAAC;AACpD;AAAA,MACF;AACA,YAAM,EAAE,KAAK,IAAI;AACjB,aAAO,MAAM,MAAM;AACjB,gBAAQ,IAAI;AAAA,MACd,CAAC;AAAA,IACH,CAAC;AAAA,EACH,CAAC;AACH;AAQA,SAAS,MAAM,IAA2B;AACxC,SAAO,IAAI,QAAQ,CAAC,YAAY;AAC9B,eAAW,SAAS,EAAE;AAAA,EACxB,CAAC;AACH;AAOA,eAAe,gBAAgB,QAA+B;AAC5D,QAAM,WAAW,KAAK,IAAI,IAAI;AAC9B,SAAO,KAAK,IAAI,IAAI,UAAU;AAC5B,QAAI;AACF,YAAM,WAAW,MAAM,MAAM,GAAG,MAAM,OAAO;AAC7C,YAAM,UAAU,MAAM,SAAS,KAAK;AACpC,UAAI,QAAQ,KAAK,CAAC,WAAW,OAAO,SAAS,MAAM,GAAG;AACpD;AAAA,MACF;AAAA,IACF,QAAQ;AAAA,IAER;AACA,UAAM,MAAM,uCAAuC;AAAA,EACrD;AACA,QAAM,IAAI;AAAA,IACR,iDAAiD,MAAM,WAAW,OAAO,iCAAiC,CAAC;AAAA,EAC7G;AACF;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/obsidian-instance.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Launches and manages a harness-owned, isolated Obsidian desktop instance.\n *\n * The instance runs against a dedicated `--user-data-dir` (so it never touches\n * the user's Obsidian config, registry, or running window) and exposes CDP on a\n * dedicated `--remote-debugging-port`. Because Electron's single-instance lock\n * is keyed to the user-data dir, the owned instance runs in parallel with the\n * user's own Obsidian. Confirmed by the Phase 0 spike (see the project plan).\n */\n\n/* v8 ignore start -- Integration-time process management covered by integration tests, not unit tests. */\n\nimport { spawn } from 'node:child_process';\nimport { createServer } from 'node:net';\n\nimport type { ProcessExitInfo } from './process-exit-message.mjs';\n\nimport { killProcessTree } from './kill-process-tree.mjs';\nimport { log } from './log.mjs';\nimport {\n  clearOwnedInstanceExitMarker,\n  writeOwnedInstanceExitMarker\n} from './owned-instance-exit-marker.mjs';\nimport { OwnedInstanceExitedError } from './owned-instance-exited-error.mjs';\nimport { startParentLivenessServer } from './parent-liveness.mjs';\nimport { attachProcessCapture } from './process-capture.mjs';\n\n/**\n * Parameters for {@link launchOwnedObsidianInstance}.\n */\nexport interface LaunchOwnedObsidianInstanceParams {\n  /**\n   * CDP host to bind/poll.\n   *\n   * @default `'127.0.0.1'`\n   */\n  readonly cdpHost?: string;\n\n  /**\n  Absolute path to the Obsidian executable (shell) to launch.\n   */\n  readonly exePath: string;\n\n  /**\n   * Extra command-line arguments appended after `--user-data-dir` and\n   * `--remote-debugging-port` \u2014 used to pass the keep-alive Chromium flags when\n   * the instance is launched hidden (off-screen). Empty by default.\n   */\n  readonly extraArguments?: readonly string[];\n\n  /**\n  Absolute path to the isolated user-data dir to pass via `--user-data-dir`.\n   */\n\n  readonly userDataDirectory: string;\n}\n\n/**\n * A running, harness-owned Obsidian instance.\n */\nexport interface OwnedObsidianInstance {\n  /**\n  Base CDP URL, e.g. `http://127.0.0.1:51888`.\n   */\n  readonly cdpUrl: string;\n\n  /**\n  Kills the instance and its entire process tree.\n   */\n  kill(): void;\n\n  /**\n   * Loopback port the instance's renderer connects back to so it destroys\n   * itself if this harness process dies without cleaning up. See\n   * `parent-liveness.ts` for why the parent/child relationship alone is not\n   * enough.\n   */\n  readonly parentLivenessPort: number;\n\n  /**\n  The CDP remote-debugging port the instance was launched with.\n   */\n  readonly port: number;\n\n  /**\n   * Returns how the instance died once it is no longer running, otherwise\n   * `undefined`. This is the in-process half of the answer; a test worker in\n   * another process reads the same facts from the exit marker\n   * (`owned-instance-exit-marker.ts`).\n   */\n  readExitInfo(): ProcessExitInfo | undefined;\n\n  /**\n  Returns the tail of everything the instance wrote to stdout/stderr.\n   */\n  readOutput(): string;\n}\n\nconst DEFAULT_CDP_HOST = '127.0.0.1';\nconst CDP_READY_POLL_INTERVAL_IN_MILLISECONDS = 1000;\nconst CDP_READY_TIMEOUT_IN_MILLISECONDS = 60_000;\nconst OBSIDIAN_OUTPUT_TAIL_MAX_LENGTH = 8000;\n\ninterface CdpTarget {\n  type: string;\n}\n\n/**\n * Launches an isolated, harness-owned Obsidian instance and waits until its CDP\n * endpoint is serving page targets.\n *\n * @param params - Launch parameters.\n * @returns The running owned instance.\n * @throws Error if CDP does not become reachable within the timeout.\n */\nexport async function launchOwnedObsidianInstance(\n  params: LaunchOwnedObsidianInstanceParams\n): Promise<OwnedObsidianInstance> {\n  const cdpHost = params.cdpHost ?? DEFAULT_CDP_HOST;\n  const port = await pickFreePort();\n  const cdpUrl = `http://${cdpHost}:${String(port)}`;\n\n  // Listen BEFORE spawning, so the renderer watchdog can never race the server\n  // Into a failed connect (which it treats as \"no watchdog\", leaving the instance alive).\n  const livenessServer = await startParentLivenessServer();\n\n  // Ports are recycled by the OS, so an older instance's death recorded on this\n  // Port would otherwise be read as this one's.\n  clearOwnedInstanceExitMarker(port);\n\n  log(`[obsidian-instance] Launching owned Obsidian: userData=${params.userDataDirectory}, cdpPort=${String(port)}`);\n  /*\n   * Piped rather than `'ignore'`: an Electron/Chromium fatal is written to\n   * stderr and nowhere else, and discarding it is why a dying instance used to\n   * be indistinguishable from a healthy one. The capture drains both pipes for\n   * the process's whole life (a full pipe buffer would block the app itself) and\n   * keeps only a bounded tail.\n   */\n  const child = spawn(\n    params.exePath,\n    [`--user-data-dir=${params.userDataDirectory}`, `--remote-debugging-port=${String(port)}`, ...(params.extraArguments ?? [])],\n    { detached: true, stdio: ['ignore', 'pipe', 'pipe'] }\n  );\n  const capture = attachProcessCapture(child, {\n    maxOutputLengthInCharacters: OBSIDIAN_OUTPUT_TAIL_MAX_LENGTH,\n    onChunk: (chunk) => {\n      const text = chunk.text.trimEnd();\n      if (text.length > 0) {\n        log(`[obsidian-instance:${chunk.stream}] ${text}`);\n      }\n    }\n  });\n\n  // Set by `kill()`, so a death the harness ordered is never reported as one it\n  // Suffered \u2014 a marker left by a clean teardown would convict the next run's\n  // Healthy instance of an exit that never happened.\n  let isKillExpected = false;\n\n  child.once('exit', (code: null | number, signal: NodeJS.Signals | null) => {\n    if (isKillExpected) {\n      log(`[obsidian-instance] Owned Obsidian exited as asked: pid=${String(child.pid)} code=${String(code)} signal=${String(signal)}`);\n      return;\n    }\n\n    // Loud on purpose. This one line is what separates a clean quit from a\n    // Crash, and its absence once cost a day of guessing.\n    log(`[obsidian-instance] !!! OWNED OBSIDIAN EXITED: pid=${String(child.pid)} code=${String(code)} signal=${String(signal)}`);\n    writeOwnedInstanceExitMarker({\n      code,\n      outputTail: capture.readOutput(),\n      pid: child.pid,\n      port,\n      signal\n    });\n  });\n\n  child.unref();\n\n  try {\n    await waitForCdpReady(cdpUrl);\n    log(`[obsidian-instance] Owned Obsidian is serving CDP at ${cdpUrl}.`);\n    return {\n      cdpUrl,\n      kill,\n      parentLivenessPort: livenessServer.port,\n      port,\n      readExitInfo: () => capture.readExitInfo(),\n      readOutput: () => capture.readOutput()\n    };\n  } catch (error: unknown) {\n    /*\n     * Read before killing, so the verdict is the instance's own. A CDP timeout\n     * whose process is already gone is not a slow boot \u2014 it is a boot that\n     * ended \u2014 and saying so beats reporting only the budget it blew.\n     *\n     * Deliberately NOT a fast-fail inside the poll: on some installs the\n     * launched executable is a shim that exits once it has handed off to the\n     * real app, so a dead child mid-poll does not imply a dead instance. Only a\n     * dead child that also never served CDP does.\n     */\n    const exitInfo = capture.readExitInfo();\n    kill();\n    if (exitInfo) {\n      throw new OwnedInstanceExitedError({\n        cdpUrl,\n        code: exitInfo.code,\n        outputTail: capture.readOutput(),\n        pid: child.pid,\n        signal: exitInfo.signal,\n        spawnError: exitInfo.spawnError\n      });\n    }\n    throw error;\n  }\n\n  function kill(): void {\n    isKillExpected = true;\n    clearOwnedInstanceExitMarker(port);\n    livenessServer.close();\n    killProcessTree(child);\n  }\n}\n\n/**\n * Picks a free TCP port by binding to port `0` and reading the assigned port.\n *\n * There is a small time-of-check/time-of-use window between releasing the port\n * here and Obsidian binding it; in practice it is negligible for test runs.\n *\n * @returns A free TCP port.\n */\nexport function pickFreePort(): Promise<number> {\n  return new Promise((resolve, reject) => {\n    const server = createServer();\n    server.once('error', reject);\n    server.listen(0, DEFAULT_CDP_HOST, () => {\n      const address = server.address();\n      if (address === null || typeof address === 'string') {\n        server.close();\n        reject(new Error('Failed to determine a free port.'));\n        return;\n      }\n      const { port } = address;\n      server.close(() => {\n        resolve(port);\n      });\n    });\n  });\n}\n\n/**\n * Returns a promise that resolves after the given delay.\n *\n * @param ms - The delay in milliseconds.\n * @returns A promise that resolves after the delay.\n */\nfunction delay(ms: number): Promise<void> {\n  return new Promise((resolve) => {\n    setTimeout(resolve, ms);\n  });\n}\n\n/**\n * Polls the CDP `/json` endpoint until at least one page target appears.\n *\n * @param cdpUrl - The base CDP URL.\n */\nasync function waitForCdpReady(cdpUrl: string): Promise<void> {\n  const deadline = Date.now() + CDP_READY_TIMEOUT_IN_MILLISECONDS;\n  while (Date.now() < deadline) {\n    try {\n      const response = await fetch(`${cdpUrl}/json`);\n      const targets = await response.json() as CdpTarget[];\n      if (targets.some((target) => target.type === 'page')) {\n        return;\n      }\n    } catch {\n      // Endpoint not up yet \u2014 keep polling.\n    }\n    await delay(CDP_READY_POLL_INTERVAL_IN_MILLISECONDS);\n  }\n  throw new Error(\n    `Owned Obsidian instance did not expose CDP at ${cdpUrl} within ${String(CDP_READY_TIMEOUT_IN_MILLISECONDS)}ms.`\n  );\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AAcA,SAAS,aAAa;AACtB,SAAS,oBAAoB;AAI7B,SAAS,uBAAuB;AAChC,SAAS,WAAW;AACpB;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,gCAAgC;AACzC,SAAS,iCAAiC;AAC1C,SAAS,4BAA4B;AAyErC,MAAM,mBAAmB;AACzB,MAAM,0CAA0C;AAChD,MAAM,oCAAoC;AAC1C,MAAM,kCAAkC;AAcxC,eAAsB,4BACpB,QACgC;AAChC,QAAM,UAAU,OAAO,WAAW;AAClC,QAAM,OAAO,MAAM,aAAa;AAChC,QAAM,SAAS,UAAU,OAAO,IAAI,OAAO,IAAI,CAAC;AAIhD,QAAM,iBAAiB,MAAM,0BAA0B;AAIvD,+BAA6B,IAAI;AAEjC,MAAI,0DAA0D,OAAO,iBAAiB,aAAa,OAAO,IAAI,CAAC,EAAE;AAQjH,QAAM,QAAQ;AAAA,IACZ,OAAO;AAAA,IACP,CAAC,mBAAmB,OAAO,iBAAiB,IAAI,2BAA2B,OAAO,IAAI,CAAC,IAAI,GAAI,OAAO,kBAAkB,CAAC,CAAE;AAAA,IAC3H,EAAE,UAAU,MAAM,OAAO,CAAC,UAAU,QAAQ,MAAM,EAAE;AAAA,EACtD;AACA,QAAM,UAAU,qBAAqB,OAAO;AAAA,IAC1C,6BAA6B;AAAA,IAC7B,SAAS,CAAC,UAAU;AAClB,YAAM,OAAO,MAAM,KAAK,QAAQ;AAChC,UAAI,KAAK,SAAS,GAAG;AACnB,YAAI,sBAAsB,MAAM,MAAM,KAAK,IAAI,EAAE;AAAA,MACnD;AAAA,IACF;AAAA,EACF,CAAC;AAKD,MAAI,iBAAiB;AAErB,QAAM,KAAK,QAAQ,CAAC,MAAqB,WAAkC;AACzE,QAAI,gBAAgB;AAClB,UAAI,2DAA2D,OAAO,MAAM,GAAG,CAAC,SAAS,OAAO,IAAI,CAAC,WAAW,OAAO,MAAM,CAAC,EAAE;AAChI;AAAA,IACF;AAIA,QAAI,sDAAsD,OAAO,MAAM,GAAG,CAAC,SAAS,OAAO,IAAI,CAAC,WAAW,OAAO,MAAM,CAAC,EAAE;AAC3H,iCAA6B;AAAA,MAC3B;AAAA,MACA,YAAY,QAAQ,WAAW;AAAA,MAC/B,KAAK,MAAM;AAAA,MACX;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH,CAAC;AAED,QAAM,MAAM;AAEZ,MAAI;AACF,UAAM,gBAAgB,MAAM;AAC5B,QAAI,wDAAwD,MAAM,GAAG;AACrE,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA,oBAAoB,eAAe;AAAA,MACnC;AAAA,MACA,cAAc,MAAM,QAAQ,aAAa;AAAA,MACzC,YAAY,MAAM,QAAQ,WAAW;AAAA,IACvC;AAAA,EACF,SAAS,OAAgB;AAWvB,UAAM,WAAW,QAAQ,aAAa;AACtC,SAAK;AACL,QAAI,UAAU;AACZ,YAAM,IAAI,yBAAyB;AAAA,QACjC;AAAA,QACA,MAAM,SAAS;AAAA,QACf,YAAY,QAAQ,WAAW;AAAA,QAC/B,KAAK,MAAM;AAAA,QACX,QAAQ,SAAS;AAAA,QACjB,YAAY,SAAS;AAAA,MACvB,CAAC;AAAA,IACH;AACA,UAAM;AAAA,EACR;AAEA,WAAS,OAAa;AACpB,qBAAiB;AACjB,iCAA6B,IAAI;AACjC,mBAAe,MAAM;AACrB,oBAAgB,KAAK;AAAA,EACvB;AACF;AAUO,SAAS,eAAgC;AAC9C,SAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,UAAM,SAAS,aAAa;AAC5B,WAAO,KAAK,SAAS,MAAM;AAC3B,WAAO,OAAO,GAAG,kBAAkB,MAAM;AACvC,YAAM,UAAU,OAAO,QAAQ;AAC/B,UAAI,YAAY,QAAQ,OAAO,YAAY,UAAU;AACnD,eAAO,MAAM;AACb,eAAO,IAAI,MAAM,kCAAkC,CAAC;AACpD;AAAA,MACF;AACA,YAAM,EAAE,KAAK,IAAI;AACjB,aAAO,MAAM,MAAM;AACjB,gBAAQ,IAAI;AAAA,MACd,CAAC;AAAA,IACH,CAAC;AAAA,EACH,CAAC;AACH;AAQA,SAAS,MAAM,IAA2B;AACxC,SAAO,IAAI,QAAQ,CAAC,YAAY;AAC9B,eAAW,SAAS,EAAE;AAAA,EACxB,CAAC;AACH;AAOA,eAAe,gBAAgB,QAA+B;AAC5D,QAAM,WAAW,KAAK,IAAI,IAAI;AAC9B,SAAO,KAAK,IAAI,IAAI,UAAU;AAC5B,QAAI;AACF,YAAM,WAAW,MAAM,MAAM,GAAG,MAAM,OAAO;AAC7C,YAAM,UAAU,MAAM,SAAS,KAAK;AACpC,UAAI,QAAQ,KAAK,CAAC,WAAW,OAAO,SAAS,MAAM,GAAG;AACpD;AAAA,MACF;AAAA,IACF,QAAQ;AAAA,IAER;AACA,UAAM,MAAM,uCAAuC;AAAA,EACrD;AACA,QAAM,IAAI;AAAA,IACR,iDAAiD,MAAM,WAAW,OAAO,iCAAiC,CAAC;AAAA,EAC7G;AACF;",
  "names": []
}


package/dist/lib/esm/open-obsidian-settings-tab.d.mts

@@ -33,8 +33,9 @@ export interface OpenObsidianSettingsTabOptions extends OpenSettingsTabParams {
  * actually rendered, resolving the transport and vault from the current test
  * context.
  *
- * See {@link Lib.openSettingsTab} for why simply calling `app.setting.open()`
- * renders nothing, and why the container must be attached **before** it.
+ * See {@link Lib.openSettingsTab} for why `app.setting.open()` can put the modal
+ * in a second Electron window, and why the container is attached **before** it on
+ * a vault that lacks the harness's `settingsPopoutWindow: false` default.
  *
  * Close it again from a callback with `app.setting.close()`; re-opening works,
  * because the attach is idempotent.

package/dist/lib/esm/open-obsidian-settings-tab.mjs

@@ -24,4 +24,4 @@ async function openObsidianSettingsTab(options) {
 export {
   openObsidianSettingsTab
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/owned-instance-exit-marker.d.mts

@@ -0,0 +1,106 @@
+/**
+ * @file
+ *
+ * Records that the harness-owned Obsidian instance on a CDP port died, so a
+ * process that did not spawn it can still say **why** it is unreachable.
+ *
+ * Only the process that launched the instance holds the child handle and sees
+ * `exit`; the test workers get nothing but the port (see the repo's L9). So the
+ * one fact worth having — the exit code — has to cross a process boundary, and
+ * this is the channel: a small JSON sentinel next to the setup lock
+ * (`setup-lock.ts`) and the Appium server marker (`appium-server-marker.ts`),
+ * keyed by port.
+ *
+ * Written **only for a death the harness did not order.** A deliberate kill
+ * (teardown, or the relaunch loop killing an instance before starting the next)
+ * clears the marker instead, because a marker left behind by a clean run would
+ * convict the next run's healthy instance of an exit that never happened.
+ *
+ * Reads are deliberately tolerant, exactly as the Appium marker's are: missing,
+ * unreadable, or describing another port all read as "no marker", and the
+ * caller falls back to saying only that the instance is gone.
+ */
+/**
+ * Records the death of the owned instance that was serving CDP on a port.
+ */
+export interface OwnedInstanceExitMarker {
+    /**
+    Exit code, or `null` when terminated by a signal or when it failed to spawn.
+     */
+    readonly code: null | number;
+    /**
+    When the instance exited (`Date.now()` epoch milliseconds).
+     */
+    readonly exitedAtInMilliseconds: number;
+    /**
+    The tail of everything the instance wrote to stdout/stderr (empty when it wrote nothing).
+     */
+    readonly outputTail: string;
+    /**
+    PID of the instance's process, or `undefined` when it never got one.
+     */
+    readonly pid: number | undefined;
+    /**
+    The CDP port the dead instance was serving.
+     */
+    readonly port: number;
+    /**
+    Terminating signal, or `null` when it exited normally or failed to spawn.
+     */
+    readonly signal: NodeJS.Signals | null;
+    /**
+    The spawn-failure message when the instance never started (e.g. `ENOENT`), otherwise absent.
+     */
+    readonly spawnError?: string | undefined;
+}
+/**
+ * Parameters for {@link writeOwnedInstanceExitMarker}.
+ */
+export interface WriteOwnedInstanceExitMarkerParams {
+    /**
+    Exit code, or `null` when terminated by a signal or when it failed to spawn.
+     */
+    readonly code: null | number;
+    /**
+    The tail of everything the instance wrote to stdout/stderr.
+     */
+    readonly outputTail: string;
+    /**
+    PID of the instance's process, or `undefined` when it never got one.
+     */
+    readonly pid: number | undefined;
+    /**
+    The CDP port the dead instance was serving.
+     */
+    readonly port: number;
+    /**
+    Terminating signal, or `null` when it exited normally or failed to spawn.
+     */
+    readonly signal: NodeJS.Signals | null;
+    /**
+    The spawn-failure message when the instance never started, otherwise absent.
+     */
+    readonly spawnError?: string | undefined;
+}
+/**
+ * Removes the marker for a port. Called when an instance is launched on it (a
+ * recycled port must not inherit an older instance's death) and whenever the
+ * harness kills an instance on purpose.
+ *
+ * @param port - The CDP port.
+ */
+export declare function clearOwnedInstanceExitMarker(port: number): void;
+/**
+ * Reads the marker for a port.
+ *
+ * @param port - The CDP port.
+ * @returns The marker, or `undefined` when there is none, it is unreadable, or it does not describe this port.
+ */
+export declare function readOwnedInstanceExitMarker(port: number): OwnedInstanceExitMarker | undefined;
+/**
+ * Records that the instance serving a port has died, stamping it with the
+ * current time so a reader can report how long ago it happened.
+ *
+ * @param params - The dead instance's port, exit details, and output tail.
+ */
+export declare function writeOwnedInstanceExitMarker(params: WriteOwnedInstanceExitMarkerParams): void;

package/dist/lib/esm/owned-instance-exit-marker.mjs

@@ -0,0 +1,78 @@
+import {
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { log } from "./log.mjs";
+const MARKER_DIR_NAME = "obsidian-integration-testing";
+const MARKER_FILE_SUFFIX = ".owned-instance-exit.json";
+function clearOwnedInstanceExitMarker(port) {
+  try {
+    rmSync(getMarkerFilePath(port), { force: true });
+  } catch (error) {
+    log(`[owned-instance-exit-marker] Could not remove the marker for port ${String(port)}: ${getErrorMessage(error)}`);
+  }
+}
+function readOwnedInstanceExitMarker(port) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(getMarkerFilePath(port), "utf-8"));
+  } catch {
+    return void 0;
+  }
+  return parseMarker(parsed, port);
+}
+function writeOwnedInstanceExitMarker(params) {
+  const marker = {
+    code: params.code,
+    exitedAtInMilliseconds: Date.now(),
+    outputTail: params.outputTail,
+    pid: params.pid,
+    port: params.port,
+    signal: params.signal,
+    ...params.spawnError !== void 0 && { spawnError: params.spawnError }
+  };
+  try {
+    mkdirSync(getMarkerDirectory(), { recursive: true });
+    writeFileSync(getMarkerFilePath(marker.port), JSON.stringify(marker));
+  } catch (error) {
+    log(`[owned-instance-exit-marker] Could not record the exit on port ${String(marker.port)}: ${getErrorMessage(error)}`);
+  }
+}
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function getMarkerDirectory() {
+  return join(tmpdir(), MARKER_DIR_NAME);
+}
+function getMarkerFilePath(port) {
+  return join(getMarkerDirectory(), `${String(port)}${MARKER_FILE_SUFFIX}`);
+}
+function parseMarker(parsed, port) {
+  if (typeof parsed !== "object" || parsed === null) {
+    return void 0;
+  }
+  const record = parsed;
+  const { code, exitedAtInMilliseconds, outputTail, pid, port: markedPort, signal, spawnError } = record;
+  if (typeof exitedAtInMilliseconds !== "number" || markedPort !== port) {
+    return void 0;
+  }
+  return {
+    code: typeof code === "number" ? code : null,
+    exitedAtInMilliseconds,
+    outputTail: typeof outputTail === "string" ? outputTail : "",
+    pid: typeof pid === "number" ? pid : void 0,
+    port,
+    signal: typeof signal === "string" ? signal : null,
+    ...typeof spawnError === "string" && { spawnError }
+  };
+}
+export {
+  clearOwnedInstanceExitMarker,
+  readOwnedInstanceExitMarker,
+  writeOwnedInstanceExitMarker
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/owned-instance-exit-marker.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Records that the harness-owned Obsidian instance on a CDP port died, so a\n * process that did not spawn it can still say **why** it is unreachable.\n *\n * Only the process that launched the instance holds the child handle and sees\n * `exit`; the test workers get nothing but the port (see the repo's L9). So the\n * one fact worth having \u2014 the exit code \u2014 has to cross a process boundary, and\n * this is the channel: a small JSON sentinel next to the setup lock\n * (`setup-lock.ts`) and the Appium server marker (`appium-server-marker.ts`),\n * keyed by port.\n *\n * Written **only for a death the harness did not order.** A deliberate kill\n * (teardown, or the relaunch loop killing an instance before starting the next)\n * clears the marker instead, because a marker left behind by a clean run would\n * convict the next run's healthy instance of an exit that never happened.\n *\n * Reads are deliberately tolerant, exactly as the Appium marker's are: missing,\n * unreadable, or describing another port all read as \"no marker\", and the\n * caller falls back to saying only that the instance is gone.\n */\n\nimport {\n  mkdirSync,\n  readFileSync,\n  rmSync,\n  writeFileSync\n} from 'node:fs';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\n\nimport { log } from './log.mjs';\n\nconst MARKER_DIR_NAME = 'obsidian-integration-testing';\nconst MARKER_FILE_SUFFIX = '.owned-instance-exit.json';\n\n/**\n * Records the death of the owned instance that was serving CDP on a port.\n */\nexport interface OwnedInstanceExitMarker {\n  /**\n  Exit code, or `null` when terminated by a signal or when it failed to spawn.\n   */\n  readonly code: null | number;\n\n  /**\n  When the instance exited (`Date.now()` epoch milliseconds).\n   */\n  readonly exitedAtInMilliseconds: number;\n\n  /**\n  The tail of everything the instance wrote to stdout/stderr (empty when it wrote nothing).\n   */\n  readonly outputTail: string;\n\n  /**\n  PID of the instance's process, or `undefined` when it never got one.\n   */\n  readonly pid: number | undefined;\n\n  /**\n  The CDP port the dead instance was serving.\n   */\n  readonly port: number;\n\n  /**\n  Terminating signal, or `null` when it exited normally or failed to spawn.\n   */\n  readonly signal: NodeJS.Signals | null;\n\n  /**\n  The spawn-failure message when the instance never started (e.g. `ENOENT`), otherwise absent.\n   */\n  readonly spawnError?: string | undefined;\n}\n\n/**\n * Parameters for {@link writeOwnedInstanceExitMarker}.\n */\nexport interface WriteOwnedInstanceExitMarkerParams {\n  /**\n  Exit code, or `null` when terminated by a signal or when it failed to spawn.\n   */\n  readonly code: null | number;\n\n  /**\n  The tail of everything the instance wrote to stdout/stderr.\n   */\n  readonly outputTail: string;\n\n  /**\n  PID of the instance's process, or `undefined` when it never got one.\n   */\n  readonly pid: number | undefined;\n\n  /**\n  The CDP port the dead instance was serving.\n   */\n  readonly port: number;\n\n  /**\n  Terminating signal, or `null` when it exited normally or failed to spawn.\n   */\n  readonly signal: NodeJS.Signals | null;\n\n  /**\n  The spawn-failure message when the instance never started, otherwise absent.\n   */\n  readonly spawnError?: string | undefined;\n}\n\n/**\n * Removes the marker for a port. Called when an instance is launched on it (a\n * recycled port must not inherit an older instance's death) and whenever the\n * harness kills an instance on purpose.\n *\n * @param port - The CDP port.\n */\nexport function clearOwnedInstanceExitMarker(port: number): void {\n  try {\n    rmSync(getMarkerFilePath(port), { force: true });\n  } catch (error: unknown) {\n    log(`[owned-instance-exit-marker] Could not remove the marker for port ${String(port)}: ${getErrorMessage(error)}`);\n  }\n}\n\n/**\n * Reads the marker for a port.\n *\n * @param port - The CDP port.\n * @returns The marker, or `undefined` when there is none, it is unreadable, or it does not describe this port.\n */\nexport function readOwnedInstanceExitMarker(port: number): OwnedInstanceExitMarker | undefined {\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(readFileSync(getMarkerFilePath(port), 'utf-8'));\n  } catch {\n    return undefined;\n  }\n\n  return parseMarker(parsed, port);\n}\n\n/**\n * Records that the instance serving a port has died, stamping it with the\n * current time so a reader can report how long ago it happened.\n *\n * @param params - The dead instance's port, exit details, and output tail.\n */\nexport function writeOwnedInstanceExitMarker(params: WriteOwnedInstanceExitMarkerParams): void {\n  const marker: OwnedInstanceExitMarker = {\n    code: params.code,\n    exitedAtInMilliseconds: Date.now(),\n    outputTail: params.outputTail,\n    pid: params.pid,\n    port: params.port,\n    signal: params.signal,\n    ...(params.spawnError !== undefined && { spawnError: params.spawnError })\n  };\n\n  try {\n    mkdirSync(getMarkerDirectory(), { recursive: true });\n    writeFileSync(getMarkerFilePath(marker.port), JSON.stringify(marker));\n  } catch (error: unknown) {\n    log(`[owned-instance-exit-marker] Could not record the exit on port ${String(marker.port)}: ${getErrorMessage(error)}`);\n  }\n}\n\nfunction getErrorMessage(error: unknown): string {\n  return error instanceof Error ? error.message : String(error);\n}\n\nfunction getMarkerDirectory(): string {\n  return join(tmpdir(), MARKER_DIR_NAME);\n}\n\nfunction getMarkerFilePath(port: number): string {\n  return join(getMarkerDirectory(), `${String(port)}${MARKER_FILE_SUFFIX}`);\n}\n\nfunction parseMarker(parsed: unknown, port: number): OwnedInstanceExitMarker | undefined {\n  if (typeof parsed !== 'object' || parsed === null) {\n    return undefined;\n  }\n\n  const record = parsed as Record<string, unknown>;\n  const { code, exitedAtInMilliseconds, outputTail, pid, port: markedPort, signal, spawnError } = record;\n\n  if (typeof exitedAtInMilliseconds !== 'number' || markedPort !== port) {\n    return undefined;\n  }\n\n  return {\n    code: typeof code === 'number' ? code : null,\n    exitedAtInMilliseconds,\n    outputTail: typeof outputTail === 'string' ? outputTail : '',\n    pid: typeof pid === 'number' ? pid : undefined,\n    port,\n    signal: typeof signal === 'string' ? signal as NodeJS.Signals : null,\n    ...(typeof spawnError === 'string' && { spawnError })\n  };\n}\n"],
  "mappings": "AAuBA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,cAAc;AACvB,SAAS,YAAY;AAErB,SAAS,WAAW;AAEpB,MAAM,kBAAkB;AACxB,MAAM,qBAAqB;AAoFpB,SAAS,6BAA6B,MAAoB;AAC/D,MAAI;AACF,WAAO,kBAAkB,IAAI,GAAG,EAAE,OAAO,KAAK,CAAC;AAAA,EACjD,SAAS,OAAgB;AACvB,QAAI,qEAAqE,OAAO,IAAI,CAAC,KAAK,gBAAgB,KAAK,CAAC,EAAE;AAAA,EACpH;AACF;AAQO,SAAS,4BAA4B,MAAmD;AAC7F,MAAI;AACJ,MAAI;AACF,aAAS,KAAK,MAAM,aAAa,kBAAkB,IAAI,GAAG,OAAO,CAAC;AAAA,EACpE,QAAQ;AACN,WAAO;AAAA,EACT;AAEA,SAAO,YAAY,QAAQ,IAAI;AACjC;AAQO,SAAS,6BAA6B,QAAkD;AAC7F,QAAM,SAAkC;AAAA,IACtC,MAAM,OAAO;AAAA,IACb,wBAAwB,KAAK,IAAI;AAAA,IACjC,YAAY,OAAO;AAAA,IACnB,KAAK,OAAO;AAAA,IACZ,MAAM,OAAO;AAAA,IACb,QAAQ,OAAO;AAAA,IACf,GAAI,OAAO,eAAe,UAAa,EAAE,YAAY,OAAO,WAAW;AAAA,EACzE;AAEA,MAAI;AACF,cAAU,mBAAmB,GAAG,EAAE,WAAW,KAAK,CAAC;AACnD,kBAAc,kBAAkB,OAAO,IAAI,GAAG,KAAK,UAAU,MAAM,CAAC;AAAA,EACtE,SAAS,OAAgB;AACvB,QAAI,kEAAkE,OAAO,OAAO,IAAI,CAAC,KAAK,gBAAgB,KAAK,CAAC,EAAE;AAAA,EACxH;AACF;AAEA,SAAS,gBAAgB,OAAwB;AAC/C,SAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AAC9D;AAEA,SAAS,qBAA6B;AACpC,SAAO,KAAK,OAAO,GAAG,eAAe;AACvC;AAEA,SAAS,kBAAkB,MAAsB;AAC/C,SAAO,KAAK,mBAAmB,GAAG,GAAG,OAAO,IAAI,CAAC,GAAG,kBAAkB,EAAE;AAC1E;AAEA,SAAS,YAAY,QAAiB,MAAmD;AACvF,MAAI,OAAO,WAAW,YAAY,WAAW,MAAM;AACjD,WAAO;AAAA,EACT;AAEA,QAAM,SAAS;AACf,QAAM,EAAE,MAAM,wBAAwB,YAAY,KAAK,MAAM,YAAY,QAAQ,WAAW,IAAI;AAEhG,MAAI,OAAO,2BAA2B,YAAY,eAAe,MAAM;AACrE,WAAO;AAAA,EACT;AAEA,SAAO;AAAA,IACL,MAAM,OAAO,SAAS,WAAW,OAAO;AAAA,IACxC;AAAA,IACA,YAAY,OAAO,eAAe,WAAW,aAAa;AAAA,IAC1D,KAAK,OAAO,QAAQ,WAAW,MAAM;AAAA,IACrC;AAAA,IACA,QAAQ,OAAO,WAAW,WAAW,SAA2B;AAAA,IAChE,GAAI,OAAO,eAAe,YAAY,EAAE,WAAW;AAAA,EACrD;AACF;",
  "names": []
}


package/dist/lib/esm/owned-instance-exited-error.d.mts

@@ -0,0 +1,98 @@
+/**
+ * @file
+ *
+ * The distinct error thrown when the harness-owned Obsidian instance is gone —
+ * it exited, and the CDP endpoint it was serving answers nothing.
+ *
+ * It exists to replace an anonymous cascade with one named cause. Before it,
+ * every test file scheduled after a mid-run death failed in ~60–90 ms with
+ * `TypeError: fetch failed` wrapping `connect ECONNREFUSED 127.0.0.1:<port>` —
+ * measured at **156 such failures across 21 files** in `obsidian-patterns` on
+ * 2026-09-05, not one of them a test result. The absence of an app is not a test
+ * outcome, and this error says so in the words a reader needs: the instance
+ * died, here is its exit code, and these failures are not about your code.
+ *
+ * Exported so callers can `instanceof`-match it, like `SilentAsarFallbackError`
+ * and `RendererFailedToInitializeError`.
+ */
+import type { OwnedInstanceExitMarker } from './owned-instance-exit-marker.mjs';
+/**
+ * Parameters for the {@link OwnedInstanceExitedError} constructor.
+ *
+ * Everything but the URL is optional: the exit details come from the process
+ * that launched the instance, and a caller in another process has them only
+ * when the exit marker survived (see `owned-instance-exit-marker.ts`).
+ */
+export interface OwnedInstanceExitedErrorConstructorParams {
+    /**
+    The CDP URL the dead instance was serving.
+     */
+    readonly cdpUrl: string;
+    /**
+    Exit code, when known.
+     */
+    readonly code?: null | number | undefined;
+    /**
+    When the instance exited (`Date.now()` epoch milliseconds), when known.
+     */
+    readonly exitedAtInMilliseconds?: number | undefined;
+    /**
+    The tail of what the instance wrote to stdout/stderr, when any was captured.
+     */
+    readonly outputTail?: string | undefined;
+    /**
+    PID of the dead instance, when known.
+     */
+    readonly pid?: number | undefined;
+    /**
+    Terminating signal, when known.
+     */
+    readonly signal?: NodeJS.Signals | null | undefined;
+    /**
+    The spawn-failure message when the instance never started, otherwise absent.
+     */
+    readonly spawnError?: string | undefined;
+}
+/**
+ * Thrown when the harness-owned Obsidian instance has exited and its CDP
+ * endpoint is therefore unreachable. Carries whatever is known about the death
+ * — exit code, signal, when it happened, and the output tail — so the failure
+ * names its own cause instead of a refused connection.
+ */
+export declare class OwnedInstanceExitedError extends Error {
+    /**
+    The CDP URL the dead instance was serving.
+     */
+    readonly cdpUrl: string;
+    /**
+    Exit code, when known.
+     */
+    readonly code: null | number | undefined;
+    /**
+    When the instance exited (`Date.now()` epoch milliseconds), when known.
+     */
+    readonly exitedAtInMilliseconds: number | undefined;
+    /**
+    Terminating signal, when known.
+     */
+    readonly signal: NodeJS.Signals | null | undefined;
+    /**
+     * Creates the error from whatever is known about the instance's death.
+     *
+     * @param params - The CDP URL, and the exit details when they are available.
+     */
+    constructor(params: OwnedInstanceExitedErrorConstructorParams);
+}
+/**
+ * Builds the error from an exit marker, for a process that did not launch the
+ * instance and so has nothing else to go on.
+ *
+ * A missing marker is expected rather than exceptional — it is cleared on every
+ * deliberate kill, and a hard enough kill records nothing — so the error is
+ * still built, naming the instance without claiming to know how it died.
+ *
+ * @param cdpUrl - The CDP URL the dead instance was serving.
+ * @param marker - The exit marker read for its port, or `undefined` when there is none.
+ * @returns The error to throw in place of a refused connection.
+ */
+export declare function buildOwnedInstanceExitedErrorFromMarker(cdpUrl: string, marker: OwnedInstanceExitMarker | undefined): OwnedInstanceExitedError;

package/dist/lib/esm/owned-instance-exited-error.mjs

@@ -0,0 +1,81 @@
+import { appendProcessOutputTail } from "./process-exit-message.mjs";
+const MILLISECONDS_PER_SECOND = 1e3;
+class OwnedInstanceExitedError extends Error {
+  /**
+  The CDP URL the dead instance was serving.
+   */
+  cdpUrl;
+  /**
+  Exit code, when known.
+   */
+  code;
+  /**
+  When the instance exited (`Date.now()` epoch milliseconds), when known.
+   */
+  exitedAtInMilliseconds;
+  /**
+  Terminating signal, when known.
+   */
+  signal;
+  /**
+   * Creates the error from whatever is known about the instance's death.
+   *
+   * @param params - The CDP URL, and the exit details when they are available.
+   */
+  constructor(params) {
+    super(buildMessage(params));
+    this.name = "OwnedInstanceExitedError";
+    this.cdpUrl = params.cdpUrl;
+    this.code = params.code;
+    this.exitedAtInMilliseconds = params.exitedAtInMilliseconds;
+    this.signal = params.signal;
+  }
+}
+function buildOwnedInstanceExitedErrorFromMarker(cdpUrl, marker) {
+  if (!marker) {
+    return new OwnedInstanceExitedError({ cdpUrl });
+  }
+  return new OwnedInstanceExitedError({
+    cdpUrl,
+    code: marker.code,
+    exitedAtInMilliseconds: marker.exitedAtInMilliseconds,
+    outputTail: marker.outputTail,
+    pid: marker.pid,
+    signal: marker.signal,
+    spawnError: marker.spawnError
+  });
+}
+function buildMessage(params) {
+  const message = `The harness-owned Obsidian instance at ${params.cdpUrl} is gone: ${describeExit(params)}. Whatever ran after it had no app to talk to, so these failures are not test results \u2014 look for the \`!!! OWNED OBSIDIAN EXITED\` line in the run log for the moment it happened.`;
+  return appendProcessOutputTail(message, { output: params.outputTail ?? "", outputLabel: "Obsidian output" });
+}
+function describeExit(params) {
+  if (params.spawnError !== void 0) {
+    return `it failed to start (${params.spawnError})`;
+  }
+  if (params.code === void 0 && params.signal === void 0) {
+    return "it exited at some point during this run, and the harness recorded nothing about how (the run that owns it logs the exit code; a worker sees only what the exit marker preserved)";
+  }
+  return `${describeProcess(params)} ${describeReason(params)}${describeWhen(params.exitedAtInMilliseconds)}`;
+}
+function describeProcess(params) {
+  return params.pid === void 0 ? "it" : `its process (pid ${String(params.pid)})`;
+}
+function describeReason(params) {
+  if (params.signal !== void 0 && params.signal !== null) {
+    return `was terminated by signal ${params.signal}`;
+  }
+  return params.code === void 0 || params.code === null ? "exited with no exit code" : `exited with code ${String(params.code)}`;
+}
+function describeWhen(exitedAtInMilliseconds) {
+  if (exitedAtInMilliseconds === void 0) {
+    return "";
+  }
+  const elapsedInSeconds = Math.max(0, Math.round((Date.now() - exitedAtInMilliseconds) / MILLISECONDS_PER_SECOND));
+  return ` ${String(elapsedInSeconds)}s ago, at ${new Date(exitedAtInMilliseconds).toISOString()}`;
+}
+export {
+  OwnedInstanceExitedError,
+  buildOwnedInstanceExitedErrorFromMarker
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/owned-instance-exited-error.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * The distinct error thrown when the harness-owned Obsidian instance is gone \u2014\n * it exited, and the CDP endpoint it was serving answers nothing.\n *\n * It exists to replace an anonymous cascade with one named cause. Before it,\n * every test file scheduled after a mid-run death failed in ~60\u201390 ms with\n * `TypeError: fetch failed` wrapping `connect ECONNREFUSED 127.0.0.1:<port>` \u2014\n * measured at **156 such failures across 21 files** in `obsidian-patterns` on\n * 2026-09-05, not one of them a test result. The absence of an app is not a test\n * outcome, and this error says so in the words a reader needs: the instance\n * died, here is its exit code, and these failures are not about your code.\n *\n * Exported so callers can `instanceof`-match it, like `SilentAsarFallbackError`\n * and `RendererFailedToInitializeError`.\n */\n\nimport type { OwnedInstanceExitMarker } from './owned-instance-exit-marker.mjs';\n\nimport { appendProcessOutputTail } from './process-exit-message.mjs';\n\nconst MILLISECONDS_PER_SECOND = 1000;\n\n/**\n * Parameters for the {@link OwnedInstanceExitedError} constructor.\n *\n * Everything but the URL is optional: the exit details come from the process\n * that launched the instance, and a caller in another process has them only\n * when the exit marker survived (see `owned-instance-exit-marker.ts`).\n */\nexport interface OwnedInstanceExitedErrorConstructorParams {\n  /**\n  The CDP URL the dead instance was serving.\n   */\n  readonly cdpUrl: string;\n\n  /**\n  Exit code, when known.\n   */\n  readonly code?: null | number | undefined;\n\n  /**\n  When the instance exited (`Date.now()` epoch milliseconds), when known.\n   */\n  readonly exitedAtInMilliseconds?: number | undefined;\n\n  /**\n  The tail of what the instance wrote to stdout/stderr, when any was captured.\n   */\n  readonly outputTail?: string | undefined;\n\n  /**\n  PID of the dead instance, when known.\n   */\n  readonly pid?: number | undefined;\n\n  /**\n  Terminating signal, when known.\n   */\n  readonly signal?: NodeJS.Signals | null | undefined;\n\n  /**\n  The spawn-failure message when the instance never started, otherwise absent.\n   */\n  readonly spawnError?: string | undefined;\n}\n\n/**\n * Thrown when the harness-owned Obsidian instance has exited and its CDP\n * endpoint is therefore unreachable. Carries whatever is known about the death\n * \u2014 exit code, signal, when it happened, and the output tail \u2014 so the failure\n * names its own cause instead of a refused connection.\n */\nexport class OwnedInstanceExitedError extends Error {\n  /**\n  The CDP URL the dead instance was serving.\n   */\n  public readonly cdpUrl: string;\n\n  /**\n  Exit code, when known.\n   */\n  public readonly code: null | number | undefined;\n\n  /**\n  When the instance exited (`Date.now()` epoch milliseconds), when known.\n   */\n  public readonly exitedAtInMilliseconds: number | undefined;\n\n  /**\n  Terminating signal, when known.\n   */\n  public readonly signal: NodeJS.Signals | null | undefined;\n\n  /**\n   * Creates the error from whatever is known about the instance's death.\n   *\n   * @param params - The CDP URL, and the exit details when they are available.\n   */\n  public constructor(params: OwnedInstanceExitedErrorConstructorParams) {\n    super(buildMessage(params));\n    this.name = 'OwnedInstanceExitedError';\n    this.cdpUrl = params.cdpUrl;\n    this.code = params.code;\n    this.exitedAtInMilliseconds = params.exitedAtInMilliseconds;\n    this.signal = params.signal;\n  }\n}\n\n/**\n * Builds the error from an exit marker, for a process that did not launch the\n * instance and so has nothing else to go on.\n *\n * A missing marker is expected rather than exceptional \u2014 it is cleared on every\n * deliberate kill, and a hard enough kill records nothing \u2014 so the error is\n * still built, naming the instance without claiming to know how it died.\n *\n * @param cdpUrl - The CDP URL the dead instance was serving.\n * @param marker - The exit marker read for its port, or `undefined` when there is none.\n * @returns The error to throw in place of a refused connection.\n */\nexport function buildOwnedInstanceExitedErrorFromMarker(cdpUrl: string, marker: OwnedInstanceExitMarker | undefined): OwnedInstanceExitedError {\n  if (!marker) {\n    return new OwnedInstanceExitedError({ cdpUrl });\n  }\n\n  return new OwnedInstanceExitedError({\n    cdpUrl,\n    code: marker.code,\n    exitedAtInMilliseconds: marker.exitedAtInMilliseconds,\n    outputTail: marker.outputTail,\n    pid: marker.pid,\n    signal: marker.signal,\n    spawnError: marker.spawnError\n  });\n}\n\nfunction buildMessage(params: OwnedInstanceExitedErrorConstructorParams): string {\n  const message = `The harness-owned Obsidian instance at ${params.cdpUrl} is gone: ${describeExit(params)}. `\n    + 'Whatever ran after it had no app to talk to, so these failures are not test results \u2014 '\n    + 'look for the `!!! OWNED OBSIDIAN EXITED` line in the run log for the moment it happened.';\n\n  return appendProcessOutputTail(message, { output: params.outputTail ?? '', outputLabel: 'Obsidian output' });\n}\n\nfunction describeExit(params: OwnedInstanceExitedErrorConstructorParams): string {\n  if (params.spawnError !== undefined) {\n    return `it failed to start (${params.spawnError})`;\n  }\n\n  if (params.code === undefined && params.signal === undefined) {\n    return 'it exited at some point during this run, and the harness recorded nothing about how '\n      + '(the run that owns it logs the exit code; a worker sees only what the exit marker preserved)';\n  }\n\n  return `${describeProcess(params)} ${describeReason(params)}${describeWhen(params.exitedAtInMilliseconds)}`;\n}\n\nfunction describeProcess(params: OwnedInstanceExitedErrorConstructorParams): string {\n  return params.pid === undefined ? 'it' : `its process (pid ${String(params.pid)})`;\n}\n\nfunction describeReason(params: OwnedInstanceExitedErrorConstructorParams): string {\n  if (params.signal !== undefined && params.signal !== null) {\n    return `was terminated by signal ${params.signal}`;\n  }\n\n  return params.code === undefined || params.code === null ? 'exited with no exit code' : `exited with code ${String(params.code)}`;\n}\n\nfunction describeWhen(exitedAtInMilliseconds: number | undefined): string {\n  if (exitedAtInMilliseconds === undefined) {\n    return '';\n  }\n\n  const elapsedInSeconds = Math.max(0, Math.round((Date.now() - exitedAtInMilliseconds) / MILLISECONDS_PER_SECOND));\n  return ` ${String(elapsedInSeconds)}s ago, at ${new Date(exitedAtInMilliseconds).toISOString()}`;\n}\n"],
  "mappings": "AAoBA,SAAS,+BAA+B;AAExC,MAAM,0BAA0B;AAoDzB,MAAM,iCAAiC,MAAM;AAAA;AAAA;AAAA;AAAA,EAIlC;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOT,YAAY,QAAmD;AACpE,UAAM,aAAa,MAAM,CAAC;AAC1B,SAAK,OAAO;AACZ,SAAK,SAAS,OAAO;AACrB,SAAK,OAAO,OAAO;AACnB,SAAK,yBAAyB,OAAO;AACrC,SAAK,SAAS,OAAO;AAAA,EACvB;AACF;AAcO,SAAS,wCAAwC,QAAgB,QAAuE;AAC7I,MAAI,CAAC,QAAQ;AACX,WAAO,IAAI,yBAAyB,EAAE,OAAO,CAAC;AAAA,EAChD;AAEA,SAAO,IAAI,yBAAyB;AAAA,IAClC;AAAA,IACA,MAAM,OAAO;AAAA,IACb,wBAAwB,OAAO;AAAA,IAC/B,YAAY,OAAO;AAAA,IACnB,KAAK,OAAO;AAAA,IACZ,QAAQ,OAAO;AAAA,IACf,YAAY,OAAO;AAAA,EACrB,CAAC;AACH;AAEA,SAAS,aAAa,QAA2D;AAC/E,QAAM,UAAU,0CAA0C,OAAO,MAAM,aAAa,aAAa,MAAM,CAAC;AAIxG,SAAO,wBAAwB,SAAS,EAAE,QAAQ,OAAO,cAAc,IAAI,aAAa,kBAAkB,CAAC;AAC7G;AAEA,SAAS,aAAa,QAA2D;AAC/E,MAAI,OAAO,eAAe,QAAW;AACnC,WAAO,uBAAuB,OAAO,UAAU;AAAA,EACjD;AAEA,MAAI,OAAO,SAAS,UAAa,OAAO,WAAW,QAAW;AAC5D,WAAO;AAAA,EAET;AAEA,SAAO,GAAG,gBAAgB,MAAM,CAAC,IAAI,eAAe,MAAM,CAAC,GAAG,aAAa,OAAO,sBAAsB,CAAC;AAC3G;AAEA,SAAS,gBAAgB,QAA2D;AAClF,SAAO,OAAO,QAAQ,SAAY,OAAO,oBAAoB,OAAO,OAAO,GAAG,CAAC;AACjF;AAEA,SAAS,eAAe,QAA2D;AACjF,MAAI,OAAO,WAAW,UAAa,OAAO,WAAW,MAAM;AACzD,WAAO,4BAA4B,OAAO,MAAM;AAAA,EAClD;AAEA,SAAO,OAAO,SAAS,UAAa,OAAO,SAAS,OAAO,6BAA6B,oBAAoB,OAAO,OAAO,IAAI,CAAC;AACjI;AAEA,SAAS,aAAa,wBAAoD;AACxE,MAAI,2BAA2B,QAAW;AACxC,WAAO;AAAA,EACT;AAEA,QAAM,mBAAmB,KAAK,IAAI,GAAG,KAAK,OAAO,KAAK,IAAI,IAAI,0BAA0B,uBAAuB,CAAC;AAChH,SAAO,IAAI,OAAO,gBAAgB,CAAC,aAAa,IAAI,KAAK,sBAAsB,EAAE,YAAY,CAAC;AAChG;",
  "names": []
}
