obsidian-integration-testing 12.0.0 → 12.1.1

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": []
}


package/dist/lib/esm/owned-vault-seed.d.mts

@@ -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/esm/owned-vault-seed.mjs

@@ -1,14 +1,18 @@
 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 }
   };
 }
 export {
   buildOwnedObsidianJson
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL293bmVkLXZhdWx0LXNlZWQudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBCdWlsZHMgdGhlIGlzb2xhdGVkIGBvYnNpZGlhbi5qc29uYCB0aGUgaGFybmVzcyBwcmUtc2VlZHMgaW50byBhbiBvd25lZFxuICogaW5zdGFuY2UncyB0ZW1wIGAtLXVzZXItZGF0YS1kaXJgIHNvIE9ic2lkaWFuIG9wZW5zIHRoZSBoYXJuZXNzIHZhdWx0IGRpcmVjdGx5XG4gKiBpbnN0ZWFkIG9mIHNob3dpbmcgdGhlIGZpcnN0LXJ1biB2YXVsdC1zZWxlY3RvciAodGhlIGBzdGFydGVyLXNjcmVlbmApLlxuICpcbiAqIFRoZSBhdXRvLW9wZW4gbWFya2VyIGNoYW5nZWQgYWNyb3NzIE9ic2lkaWFuJ3MgaGlzdG9yeSwgc28gdGhlIHNlZWQgY2Fycmllc1xuICogQk9USCBmb3JtcyBhbmQgZWFjaCB2ZXJzaW9uIHJlYWRzIHRoZSBvbmUgaXQgdW5kZXJzdGFuZHMgKGlnbm9yaW5nIHRoZSBvdGhlclxuICogdW5rbm93biBrZXkpIFx1MjAxNCBubyBwZXItdmVyc2lvbiBicmFuY2hpbmc6XG4gKlxuICogLSAqKk9sZCB2ZXJzaW9ucyoqIChjb25maXJtZWQgMC42LjQpIGF1dG8tb3BlbiBmcm9tIGEgKip0b3AtbGV2ZWwgYGxhc3Rfb3BlbmAqKlxuICogICBob2xkaW5nIHRoZSB2YXVsdCBpZCAoYG1haW4uanNgOiBgaWYgKGlkICYmIHZhdWx0cy5oYXNPd25Qcm9wZXJ0eShpZCkpXG4gKiAgIGNyZWF0ZVdpbmRvdyhpZCk7IGVsc2Ugb3BlblN0YXJ0ZXIoKTtgKSwgYW5kIHN0b3JlIGVhY2ggdmF1bHQgZW50cnkgYXMganVzdFxuICogICBgeyBwYXRoLCB0cyB9YC4gV2l0aG91dCBgbGFzdF9vcGVuYCB0aGV5IGZhbGwgdGhyb3VnaCB0byB0aGUgdmF1bHQtc2VsZWN0b3IuXG4gKiAtICoqTmV3ZXIgdmVyc2lvbnMqKiAoY29uZmlybWVkIDAuMTQuNSspIGRyb3BwZWQgYGxhc3Rfb3BlbmAgYW5kIGF1dG8tb3BlbiBmcm9tXG4gKiAgIHRoZSBwZXItZW50cnkgKipgb3BlbjogdHJ1ZWAqKiBmbGFnLlxuICpcbiAqIFNlZWRpbmcgYm90aCB3YXMgdmVyaWZpZWQgdG8gb3BlbiB0aGUgdmF1bHQgZGlyZWN0bHkgKG5vIHNlbGVjdG9yKSBvbiAwLjYuNCxcbiAqIDAuOS4yMCwgMC4xMi4xOSwgMC4xMy4xOSwgMC4xNC41IGFuZCAxLjEyLjcuIGB1cGRhdGVEaXNhYmxlZGAgc3VwcHJlc3NlcyB0aGVcbiAqIHRocm93YXdheSBpbnN0YW5jZSdzIHNlbGYtdXBkYXRlLlxuICovXG5cbi8qKlxuICogUGFyYW1ldGVycyBmb3Ige0BsaW5rIGJ1aWxkT3duZWRPYnNpZGlhbkpzb259LlxuICovXG5leHBvcnQgaW50ZXJmYWNlIEJ1aWxkT3duZWRPYnNpZGlhbkpzb25QYXJhbXMge1xuICAvKipcbiAgTGFzdC1hY2Nlc3MgdGltZXN0YW1wIHRvIHN0YW1wIG9uIHRoZSB2YXVsdCBlbnRyeS5cbiAgICovXG4gIHJlYWRvbmx5IHRzOiBudW1iZXI7XG5cbiAgLyoqXG4gIFRoZSByYW5kb21seS1nZW5lcmF0ZWQgdmF1bHQgaWQgdXNlZCBhcyB0aGUgcmVnaXN0cnkga2V5IGFuZCBgbGFzdF9vcGVuYC5cbiAgICovXG4gIHJlYWRvbmx5IHZhdWx0SWQ6IHN0cmluZztcblxuICAvKipcbiAgQWJzb2x1dGUgcGF0aCB0byB0aGUgaGFybmVzcyB2YXVsdCBmb2xkZXIuXG4gICAqL1xuICByZWFkb25seSB2YXVsdFBhdGg6IHN0cmluZztcbn1cblxuLyoqXG4gKiBUaGUgYG9ic2lkaWFuLmpzb25gIHN0cnVjdHVyZSB0aGUgaGFybmVzcyBzZWVkcyBmb3IgYW4gb3duZWQgaW5zdGFuY2UuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgT3duZWRPYnNpZGlhbkpzb24ge1xuICAvKipcbiAgICogVG9wLWxldmVsIGF1dG8tb3BlbiBtYXJrZXIgKHZhdWx0IGlkKSBob25vcmVkIGJ5IG9sZCBPYnNpZGlhbiB2ZXJzaW9ucztcbiAgICogaWdub3JlZCBhcyBhbiB1bmtub3duIGtleSBieSBuZXdlciB2ZXJzaW9ucyB0aGF0IHVzZSB0aGUgcGVyLWVudHJ5IGBvcGVuYC5cbiAgICovXG4gIHJlYWRvbmx5IGxhc3Rfb3Blbjogc3RyaW5nO1xuXG4gIC8qKlxuICBEaXNhYmxlcyB0aGUgdGhyb3dhd2F5IGluc3RhbmNlJ3Mgc2VsZi11cGRhdGUuXG4gICAqL1xuICByZWFkb25seSB1cGRhdGVEaXNhYmxlZDogdHJ1ZTtcblxuICAvKipcbiAgVmF1bHQgcmVnaXN0cnkga2V5ZWQgYnkgdmF1bHQgaWQuXG4gICAqL1xuICByZWFkb25seSB2YXVsdHM6IFJlYWRvbmx5PFJlY29yZDxzdHJpbmcsIE93bmVkT2JzaWRpYW5WYXVsdEVudHJ5Pj47XG59XG5cbi8qKlxuICogQSBzaW5nbGUgdmF1bHQgZW50cnkgaW4gdGhlIHNlZWRlZCBgb2JzaWRpYW4uanNvbmAuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgT3duZWRPYnNpZGlhblZhdWx0RW50cnkge1xuICAvKipcbiAgUGVyLWVudHJ5IGF1dG8tb3BlbiBmbGFnIGhvbm9yZWQgYnkgbmV3ZXIgT2JzaWRpYW4gdmVyc2lvbnMuXG4gICAqL1xuICByZWFkb25seSBvcGVuOiB0cnVlO1xuXG4gIC8qKlxuICBBYnNvbHV0ZSBwYXRoIHRvIHRoZSBoYXJuZXNzIHZhdWx0IGZvbGRlci5cbiAgICovXG4gIHJlYWRvbmx5IHBhdGg6IHN0cmluZztcblxuICAvKipcbiAgTGFzdC1hY2Nlc3MgdGltZXN0YW1wLlxuICAgKi9cbiAgcmVhZG9ubHkgdHM6IG51bWJlcjtcbn1cblxuLyoqXG4gKiBCdWlsZHMgdGhlIGlzb2xhdGVkIGBvYnNpZGlhbi5qc29uYCB0aGF0IGZvcmNlLW9wZW5zIHRoZSBvd25lZCB2YXVsdCBhY3Jvc3MgYWxsXG4gKiBzdXBwb3J0ZWQgT2JzaWRpYW4gdmVyc2lvbnMgKHNlZSB0aGUgZmlsZSBvdmVydmlldyBmb3IgdGhlIGR1YWwtbWFya2VyXG4gKiByYXRpb25hbGUpLlxuICpcbiAqIEBwYXJhbSBwYXJhbXMgLSBUaGUgdmF1bHQgaWQsIHBhdGgsIGFuZCB0aW1lc3RhbXAgdG8gc2VlZC5cbiAqIEByZXR1cm5zIFRoZSBgb2JzaWRpYW4uanNvbmAgb2JqZWN0IHRvIHdyaXRlIGludG8gdGhlIG93bmVkIHVzZXItZGF0YSBkaXIuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBidWlsZE93bmVkT2JzaWRpYW5Kc29uKHBhcmFtczogQnVpbGRPd25lZE9ic2lkaWFuSnNvblBhcmFtcyk6IE93bmVkT2JzaWRpYW5Kc29uIHtcbiAgcmV0dXJuIHtcbiAgICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgY2FtZWxjYXNlIC0tIE9ic2lkaWFuJ3Mgb3duIG9ic2lkaWFuLmpzb24gZmllbGQgbmFtZSAob2xkIHZlcnNpb25zJyBhdXRvLW9wZW4gbWFya2VyKS5cbiAgICBsYXN0X29wZW46IHBhcmFtcy52YXVsdElkLFxuICAgIHVwZGF0ZURpc2FibGVkOiB0cnVlLFxuICAgIHZhdWx0czoge1xuICAgICAgW3BhcmFtcy52YXVsdElkXTogeyBvcGVuOiB0cnVlLCBwYXRoOiBwYXJhbXMudmF1bHRQYXRoLCB0czogcGFyYW1zLnRzIH1cbiAgICB9XG4gIH07XG59XG4iXSwKICAibWFwcGluZ3MiOiAiQUE0Rk8sU0FBUyx1QkFBdUIsUUFBeUQ7QUFDOUYsU0FBTztBQUFBO0FBQUEsSUFFTCxXQUFXLE9BQU87QUFBQSxJQUNsQixnQkFBZ0I7QUFBQSxJQUNoQixRQUFRO0FBQUEsTUFDTixDQUFDLE9BQU8sT0FBTyxHQUFHLEVBQUUsTUFBTSxNQUFNLE1BQU0sT0FBTyxXQUFXLElBQUksT0FBTyxHQUFHO0FBQUEsSUFDeEU7QUFBQSxFQUNGO0FBQ0Y7IiwKICAibmFtZXMiOiBbXQp9Cg==
+//# sourceMappingURL=data:application/json;base64,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

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

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