obsidian-integration-testing 9.2.1 → 10.0.0

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

@@ -0,0 +1,80 @@
+/**
+ * @file
+ *
+ * Ties a harness-owned Obsidian instance's lifetime to the harness process that
+ * launched it, in the one direction the operating system will not do for us.
+ *
+ * The owned instance is already a child of the harness process, but that link
+ * carries no lifetime guarantee. Windows never propagates a parent's death to
+ * its children — an orphan simply keeps running with a stale parent id — and on
+ * POSIX a `SIGKILL` aimed at a single pid never cascades either. The instance is
+ * additionally spawned `detached`, so it is not even in the harness's process
+ * group. Teardown therefore relies entirely on the harness running its own
+ * cleanup (`killProcessTree` from an `exit`/signal handler), which is exactly
+ * what a `SIGKILL`, a Task Manager kill, or an IDE stop button denies it. Every
+ * such kill leaks a hidden Obsidian holding a user-data dir and a CDP port, and
+ * they accumulate: the next run picks a fresh temp dir and a free port, so
+ * nothing collides and nothing complains.
+ *
+ * The guaranteed fix is an OS primitive — a Windows Job Object with
+ * `JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE`, or `prctl(PR_SET_PDEATHSIG)` on Linux —
+ * but neither is reachable from Node without a native addon, which is far too
+ * heavy a dependency for this harness.
+ *
+ * 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.
+ *
+ * Deliberately fail-open: the renderer only arms the destroy handler 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.
+ */
+/**
+ * A listening loopback server whose accepted connections act as liveness tokens
+ * for the harness process.
+ */
+export interface ParentLivenessServer {
+    /**
+    Stops listening and drops every accepted connection.
+     */
+    close(): void;
+    /**
+    The loopback port the renderer watchdog should connect back to.
+     */
+    readonly port: number;
+}
+/**
+ * Loopback host the liveness server binds to. Never exposed off-machine.
+ */
+export declare const PARENT_LIVENESS_HOST = "127.0.0.1";
+/**
+ * Builds the expression evaluated in the owned instance's renderer to arm the
+ * watchdog.
+ *
+ * Written in ES5 style (`var`, `function`) with no optional chaining, matching
+ * {@link DISMISS_TRUST_DIALOG_EXPR}: the same expression has to parse on the
+ * Chromium 80-era renderers of the oldest supported Obsidian versions (L26).
+ *
+ * Arming is idempotent — a second evaluation finds the stored socket and
+ * returns without opening another connection, so a retried readiness pass does
+ * not pile up sockets.
+ *
+ * @param port - The loopback port returned by {@link startParentLivenessServer}.
+ * @returns The expression to evaluate, yielding `'armed'`, `'already-armed'`, or `'unavailable'`.
+ */
+export declare function buildParentLivenessWatchdogExpression(port: number): string;
+/**
+ * Starts the loopback liveness server the owned instance's renderer connects
+ * back to.
+ *
+ * The server and every accepted socket are `unref`ed, so holding a watchdog
+ * connection open never keeps the harness process alive on its own — the
+ * connection is a token the kernel reclaims, not work to wait on.
+ *
+ * @returns A {@link Promise} resolving to the listening {@link ParentLivenessServer}.
+ */
+export declare function startParentLivenessServer(): Promise<ParentLivenessServer>;

package/dist/lib/cjs/poll-in-obsidian.cjs

@@ -29,8 +29,8 @@ const DEFAULT_POLL_INTERVAL_IN_MILLISECONDS = 500;
 const DEFAULT_POLL_TIMEOUT_IN_MILLISECONDS = 12e4;
 async function pollInObsidian(params) {
   const {
-    args,
     contextId,
+    input,
     intervalInMilliseconds = DEFAULT_POLL_INTERVAL_IN_MILLISECONDS,
     poll,
     start,
@@ -40,10 +40,10 @@ async function pollInObsidian(params) {
     until,
     vaultPath
   } = params;
-  async function runEval(fn) {
+  async function runEval(callback) {
     const evalParams = {
-      fn,
-      ...args !== void 0 && { args },
+      callback,
+      ...input !== void 0 && { input },
       ...contextId !== void 0 && { contextId },
       ...transport !== void 0 && { transport },
       ...vaultPath !== void 0 && { vaultPath }
@@ -69,4 +69,4 @@ async function pollInObsidian(params) {
 0 && (module.exports = {
   pollInObsidian
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/poll-in-obsidian.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Node-side \"kick off, then poll\" helper over {@link evalInObsidian}.\n *\n * A single `evalInObsidian` closure cannot run longer than CDP's ~30s\n * `Runtime.evaluate` cap, so a long-running in-Obsidian operation (e.g. a whole\n * plugin/vault bootstrap) cannot be awaited inside one closure. This helper does\n * it from Node instead: it optionally runs a short `start` closure once to kick\n * the work off, then repeatedly runs a short `poll` closure \u2014 each a separate,\n * well-under-30s eval \u2014 until the Node-side `until` predicate accepts a poll\n * result, or a Node-side timeout elapses. It removes the per-test hand-rolled\n * `evalInObsidian` + `sleep` loop.\n *\n * The timing loop lives in the pure, unit-tested {@link pollUntil}; this module is\n * the integration-only wiring (it drives a live Obsidian), covered by an\n * integration test.\n */\n\n/* v8 ignore start -- Integration-time code (drives a live Obsidian via evalInObsidian) covered by integration tests, not unit tests. */\n\nimport type { Promisable } from 'type-fest';\n\nimport { setTimeout as sleep } from 'node:timers/promises';\n\nimport type { ContextArgs } from './context-id.cjs';\nimport type {\n  CommonArgs,\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.cjs';\nimport type { ObsidianTransport } from './transport.cjs';\n\nimport { ContextId } from './context-id.cjs';\nimport { evalInObsidian } from './eval-in-obsidian.cjs';\nimport { pollUntil } from './poll-until.cjs';\n\nconst DEFAULT_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst DEFAULT_POLL_TIMEOUT_IN_MILLISECONDS = 120_000;\n\n/**\n * Parameters for {@link pollInObsidian}. Mirrors {@link EvalInObsidianParams} for\n * the shared forwarded fields (`args` / `contextId` / `transport` / `vaultPath`);\n * `start` / `poll` are the in-Obsidian closures and `until` is the Node-side\n * acceptance predicate.\n */\nexport interface PollInObsidianParams<Args extends GenericObject, PollResult, TContextId extends ContextId<unknown> | undefined = undefined> {\n  /**\n   * Additional arguments passed to both `start` and `poll` (serialized like\n   * {@link EvalInObsidianParams.args}).\n   */\n  readonly args?: Args;\n\n  /**\n   * A {@link ContextId} shared by `start` and `poll`, so `start` can stash\n   * non-serializable state that `poll` later reads. When omitted, each closure\n   * gets a fresh empty `context`.\n   */\n  readonly contextId?: TContextId;\n\n  /**\n   * Delay between `poll` attempts, in milliseconds.\n   *\n   * @default `500`\n   */\n  readonly intervalInMilliseconds?: number;\n\n  /**\n   * The closure polled repeatedly inside Obsidian. Keep it short (well under the\n   * ~30s CDP cap): it should read and return a JSON-serializable status, not\n   * await the long operation itself.\n   */\n  poll(this: void, args: Args & CommonArgs & ContextArgs<TContextId>): Promisable<PollResult>;\n\n  /**\n   * An optional closure run **once** before polling begins, to kick off the\n   * long-running work (fire-and-forget from Node's perspective). Keep it short \u2014\n   * start the work and return; do not await it to completion here.\n   */\n  start?(this: void, args: Args & CommonArgs & ContextArgs<TContextId>): Promisable<unknown>;\n\n  /**\n   * Total budget before the poll rejects, in milliseconds.\n   *\n   * @default `120000`\n   */\n  readonly timeoutInMilliseconds?: number;\n\n  /**\n   * Optional detail appended to the timeout error message.\n   */\n  readonly timeoutMessage?: string;\n\n  /**\n   * Override the transport (forwarded to every underlying `evalInObsidian`).\n   */\n  readonly transport?: ObsidianTransport;\n\n  /**\n   * Whether a given `poll` result is acceptable, evaluated in **Node**. Returning\n   * `true` resolves {@link pollInObsidian} with that result.\n   */\n  until(this: void, result: PollResult): boolean;\n\n  /**\n   * The vault path to evaluate against (forwarded to every underlying\n   * `evalInObsidian`).\n   */\n  readonly vaultPath?: string;\n}\n\n/**\n * Kicks off an optional `start` closure once, then polls `poll` from Node until\n * `until` accepts a result or the timeout elapses.\n *\n * @param params - The poll parameters.\n * @returns A {@link Promise} that resolves with the first accepted `poll` result.\n */\nexport async function pollInObsidian<Args extends GenericObject, PollResult, TContextId extends ContextId<unknown> | undefined = undefined>(\n  params: PollInObsidianParams<Args, PollResult, TContextId>\n): Promise<PollResult> {\n  const {\n    args,\n    contextId,\n    intervalInMilliseconds = DEFAULT_POLL_INTERVAL_IN_MILLISECONDS,\n    poll,\n    start,\n    timeoutInMilliseconds = DEFAULT_POLL_TIMEOUT_IN_MILLISECONDS,\n    timeoutMessage,\n    transport,\n    until,\n    vaultPath\n  } = params;\n\n  async function runEval<Result>(fn: (fnArgs: Args & CommonArgs & ContextArgs<TContextId>) => Promisable<Result>): Promise<Result> {\n    const evalParams: EvalInObsidianParams<Args, Result, TContextId> = {\n      fn,\n      ...(args !== undefined && { args }),\n      ...(contextId !== undefined && { contextId }),\n      ...(transport !== undefined && { transport }),\n      ...(vaultPath !== undefined && { vaultPath })\n    };\n    return evalInObsidian<Args, Result, TContextId>(evalParams);\n  }\n\n  if (start) {\n    await runEval(start);\n  }\n\n  return pollUntil<PollResult>({\n    attempt: async () => runEval(poll),\n    intervalInMilliseconds,\n    nowInMilliseconds: () => Date.now(),\n    sleep: async (milliseconds: number) => {\n      await sleep(milliseconds);\n    },\n    timeoutInMilliseconds,\n    until,\n    ...(timeoutMessage !== undefined && { timeoutMessage })\n  });\n}\n\n/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAuBA,sBAAoC;AAUpC,wBAA0B;AAC1B,8BAA+B;AAC/B,wBAA0B;AAE1B,MAAM,wCAAwC;AAC9C,MAAM,uCAAuC;AAgF7C,eAAsB,eACpB,QACqB;AACrB,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA,yBAAyB;AAAA,IACzB;AAAA,IACA;AAAA,IACA,wBAAwB;AAAA,IACxB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,iBAAe,QAAgB,IAAkG;AAC/H,UAAM,aAA6D;AAAA,MACjE;AAAA,MACA,GAAI,SAAS,UAAa,EAAE,KAAK;AAAA,MACjC,GAAI,cAAc,UAAa,EAAE,UAAU;AAAA,MAC3C,GAAI,cAAc,UAAa,EAAE,UAAU;AAAA,MAC3C,GAAI,cAAc,UAAa,EAAE,UAAU;AAAA,IAC7C;AACA,eAAO,wCAAyC,UAAU;AAAA,EAC5D;AAEA,MAAI,OAAO;AACT,UAAM,QAAQ,KAAK;AAAA,EACrB;AAEA,aAAO,6BAAsB;AAAA,IAC3B,SAAS,YAAY,QAAQ,IAAI;AAAA,IACjC;AAAA,IACA,mBAAmB,MAAM,KAAK,IAAI;AAAA,IAClC,OAAO,OAAO,iBAAyB;AACrC,gBAAM,gBAAAA,YAAM,YAAY;AAAA,IAC1B;AAAA,IACA;AAAA,IACA;AAAA,IACA,GAAI,mBAAmB,UAAa,EAAE,eAAe;AAAA,EACvD,CAAC;AACH;",
  "names": ["sleep"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/poll-in-obsidian.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Node-side \"kick off, then poll\" helper over {@link evalInObsidian}.\n *\n * A single `evalInObsidian` closure cannot run longer than CDP's ~30s\n * `Runtime.evaluate` cap, so a long-running in-Obsidian operation (e.g. a whole\n * plugin/vault bootstrap) cannot be awaited inside one closure. This helper does\n * it from Node instead: it optionally runs a short `start` closure once to kick\n * the work off, then repeatedly runs a short `poll` closure \u2014 each a separate,\n * well-under-30s eval \u2014 until the Node-side `until` predicate accepts a poll\n * result, or a Node-side timeout elapses. It removes the per-test hand-rolled\n * `evalInObsidian` + `sleep` loop.\n *\n * The timing loop lives in the pure, unit-tested {@link pollUntil}; this module is\n * the integration-only wiring (it drives a live Obsidian), covered by an\n * integration test.\n */\n\n/* v8 ignore start -- Integration-time code (drives a live Obsidian via evalInObsidian) covered by integration tests, not unit tests. */\n\nimport type { Promisable } from 'type-fest';\n\nimport { setTimeout as sleep } from 'node:timers/promises';\n\nimport type { ContextArguments } from './context-id.cjs';\nimport type {\n  CommonArguments,\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.cjs';\nimport type { ObsidianTransport } from './transport.cjs';\n\nimport { ContextId } from './context-id.cjs';\nimport { evalInObsidian } from './eval-in-obsidian.cjs';\nimport { pollUntil } from './poll-until.cjs';\n\nconst DEFAULT_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst DEFAULT_POLL_TIMEOUT_IN_MILLISECONDS = 120_000;\n\n/**\n * Parameters for {@link pollInObsidian}. Mirrors {@link EvalInObsidianParams} for\n * the shared forwarded fields (`input` / `contextId` / `transport` / `vaultPath`);\n * `start` / `poll` are the in-Obsidian closures and `until` is the Node-side\n * acceptance predicate.\n */\nexport interface PollInObsidianParams<Input extends GenericObject, PollResult, TContextId extends ContextId<unknown> | undefined = undefined> {\n  /**\n   * A {@link ContextId} shared by `start` and `poll`, so `start` can stash\n   * non-serializable state that `poll` later reads. When omitted, each closure\n   * gets a fresh empty `context`.\n   */\n  readonly contextId?: TContextId;\n\n  /**\n   * Additional arguments passed to both `start` and `poll` (serialized like\n   * {@link EvalInObsidianParams.input}).\n   */\n  readonly input?: Input;\n\n  /**\n   * Delay between `poll` attempts, in milliseconds.\n   *\n   * @default `500`\n   */\n  readonly intervalInMilliseconds?: number;\n\n  /**\n   * The closure polled repeatedly inside Obsidian. Keep it short (well under the\n   * ~30s CDP cap): it should read and return a JSON-serializable status, not\n   * await the long operation itself.\n   */\n  poll(this: void, input: CommonArguments & ContextArguments<TContextId> & Input): Promisable<PollResult>;\n\n  /**\n   * An optional closure run **once** before polling begins, to kick off the\n   * long-running work (fire-and-forget from Node's perspective). Keep it short \u2014\n   * start the work and return; do not await it to completion here.\n   */\n  start?(this: void, input: CommonArguments & ContextArguments<TContextId> & Input): Promisable<unknown>;\n\n  /**\n   * Total budget before the poll rejects, in milliseconds.\n   *\n   * @default `120000`\n   */\n  readonly timeoutInMilliseconds?: number;\n\n  /**\n   * Optional detail appended to the timeout error message.\n   */\n  readonly timeoutMessage?: string;\n\n  /**\n   * Override the transport (forwarded to every underlying `evalInObsidian`).\n   */\n  readonly transport?: ObsidianTransport;\n\n  /**\n   * Whether a given `poll` result is acceptable, evaluated in **Node**. Returning\n   * `true` resolves {@link pollInObsidian} with that result.\n   */\n  until(this: void, result: PollResult): boolean;\n\n  /**\n   * The vault path to evaluate against (forwarded to every underlying\n   * `evalInObsidian`).\n   */\n  readonly vaultPath?: string;\n}\n\n/**\n * Kicks off an optional `start` closure once, then polls `poll` from Node until\n * `until` accepts a result or the timeout elapses.\n *\n * @param params - The poll parameters.\n * @returns A {@link Promise} that resolves with the first accepted `poll` result.\n */\nexport async function pollInObsidian<Input extends GenericObject, PollResult, TContextId extends ContextId<unknown> | undefined = undefined>(\n  params: PollInObsidianParams<Input, PollResult, TContextId>\n): Promise<PollResult> {\n  const {\n    contextId,\n    input,\n    intervalInMilliseconds = DEFAULT_POLL_INTERVAL_IN_MILLISECONDS,\n    poll,\n    start,\n    timeoutInMilliseconds = DEFAULT_POLL_TIMEOUT_IN_MILLISECONDS,\n    timeoutMessage,\n    transport,\n    until,\n    vaultPath\n  } = params;\n\n  async function runEval<Result>(callback: (functionArguments: CommonArguments & ContextArguments<TContextId> & Input) => Promisable<Result>): Promise<Result> {\n    const evalParams: EvalInObsidianParams<Input, Result, TContextId> = {\n      callback,\n      ...(input !== undefined && { input }),\n      ...(contextId !== undefined && { contextId }),\n      ...(transport !== undefined && { transport }),\n      ...(vaultPath !== undefined && { vaultPath })\n    };\n    return evalInObsidian<Input, Result, TContextId>(evalParams);\n  }\n\n  if (start) {\n    await runEval(start);\n  }\n\n  return pollUntil<PollResult>({\n    attempt: async () => runEval(poll),\n    intervalInMilliseconds,\n    nowInMilliseconds: () => Date.now(),\n    sleep: async (milliseconds: number) => {\n      await sleep(milliseconds);\n    },\n    timeoutInMilliseconds,\n    until,\n    ...(timeoutMessage !== undefined && { timeoutMessage })\n  });\n}\n\n/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAuBA,sBAAoC;AAUpC,wBAA0B;AAC1B,8BAA+B;AAC/B,wBAA0B;AAE1B,MAAM,wCAAwC;AAC9C,MAAM,uCAAuC;AAgF7C,eAAsB,eACpB,QACqB;AACrB,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA,yBAAyB;AAAA,IACzB;AAAA,IACA;AAAA,IACA,wBAAwB;AAAA,IACxB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,iBAAe,QAAgB,UAA8H;AAC3J,UAAM,aAA8D;AAAA,MAClE;AAAA,MACA,GAAI,UAAU,UAAa,EAAE,MAAM;AAAA,MACnC,GAAI,cAAc,UAAa,EAAE,UAAU;AAAA,MAC3C,GAAI,cAAc,UAAa,EAAE,UAAU;AAAA,MAC3C,GAAI,cAAc,UAAa,EAAE,UAAU;AAAA,IAC7C;AACA,eAAO,wCAA0C,UAAU;AAAA,EAC7D;AAEA,MAAI,OAAO;AACT,UAAM,QAAQ,KAAK;AAAA,EACrB;AAEA,aAAO,6BAAsB;AAAA,IAC3B,SAAS,YAAY,QAAQ,IAAI;AAAA,IACjC;AAAA,IACA,mBAAmB,MAAM,KAAK,IAAI;AAAA,IAClC,OAAO,OAAO,iBAAyB;AACrC,gBAAM,gBAAAA,YAAM,YAAY;AAAA,IAC1B;AAAA,IACA;AAAA,IACA;AAAA,IACA,GAAI,mBAAmB,UAAa,EAAE,eAAe;AAAA,EACvD,CAAC;AACH;",
  "names": ["sleep"]
}


package/dist/lib/cjs/poll-in-obsidian.d.cts

@@ -17,28 +17,28 @@
  * integration test.
  */
 import type { Promisable } from 'type-fest';
-import type { ContextArgs } from './context-id.cjs';
-import type { CommonArgs, GenericObject } from './eval-in-obsidian.cjs';
+import type { ContextArguments } from './context-id.cjs';
+import type { CommonArguments, GenericObject } from './eval-in-obsidian.cjs';
 import type { ObsidianTransport } from './transport.cjs';
 import { ContextId } from './context-id.cjs';
 /**
  * Parameters for {@link pollInObsidian}. Mirrors {@link EvalInObsidianParams} for
- * the shared forwarded fields (`args` / `contextId` / `transport` / `vaultPath`);
+ * the shared forwarded fields (`input` / `contextId` / `transport` / `vaultPath`);
  * `start` / `poll` are the in-Obsidian closures and `until` is the Node-side
  * acceptance predicate.
  */
-export interface PollInObsidianParams<Args extends GenericObject, PollResult, TContextId extends ContextId<unknown> | undefined = undefined> {
-    /**
-     * Additional arguments passed to both `start` and `poll` (serialized like
-     * {@link EvalInObsidianParams.args}).
-     */
-    readonly args?: Args;
+export interface PollInObsidianParams<Input extends GenericObject, PollResult, TContextId extends ContextId<unknown> | undefined = undefined> {
     /**
      * A {@link ContextId} shared by `start` and `poll`, so `start` can stash
      * non-serializable state that `poll` later reads. When omitted, each closure
      * gets a fresh empty `context`.
      */
     readonly contextId?: TContextId;
+    /**
+     * Additional arguments passed to both `start` and `poll` (serialized like
+     * {@link EvalInObsidianParams.input}).
+     */
+    readonly input?: Input;
     /**
      * Delay between `poll` attempts, in milliseconds.
      *
@@ -50,13 +50,13 @@ export interface PollInObsidianParams<Args extends GenericObject, PollResult, TC
      * ~30s CDP cap): it should read and return a JSON-serializable status, not
      * await the long operation itself.
      */
-    poll(this: void, args: Args & CommonArgs & ContextArgs<TContextId>): Promisable<PollResult>;
+    poll(this: void, input: CommonArguments & ContextArguments<TContextId> & Input): Promisable<PollResult>;
     /**
      * An optional closure run **once** before polling begins, to kick off the
      * long-running work (fire-and-forget from Node's perspective). Keep it short —
      * start the work and return; do not await it to completion here.
      */
-    start?(this: void, args: Args & CommonArgs & ContextArgs<TContextId>): Promisable<unknown>;
+    start?(this: void, input: CommonArguments & ContextArguments<TContextId> & Input): Promisable<unknown>;
     /**
      * Total budget before the poll rejects, in milliseconds.
      *
@@ -89,4 +89,4 @@ export interface PollInObsidianParams<Args extends GenericObject, PollResult, TC
  * @param params - The poll parameters.
  * @returns A {@link Promise} that resolves with the first accepted `poll` result.
  */
-export declare function pollInObsidian<Args extends GenericObject, PollResult, TContextId extends ContextId<unknown> | undefined = undefined>(params: PollInObsidianParams<Args, PollResult, TContextId>): Promise<PollResult>;
+export declare function pollInObsidian<Input extends GenericObject, PollResult, TContextId extends ContextId<unknown> | undefined = undefined>(params: PollInObsidianParams<Input, PollResult, TContextId>): Promise<PollResult>;

package/dist/lib/cjs/poll-until.cjs

@@ -40,4 +40,4 @@ async function pollUntil(params) {
 0 && (module.exports = {
   pollUntil
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/poll-until.d.cts

@@ -13,19 +13,33 @@
  * Parameters for {@link pollUntil}.
  */
 export interface PollUntilParams<Result> {
-    /** Runs one attempt and resolves with its result. */
+    /**
+    Runs one attempt and resolves with its result.
+     */
     attempt(this: void): Promise<Result>;
-    /** Delay between attempts, in milliseconds. */
+    /**
+    Delay between attempts, in milliseconds.
+     */
     readonly intervalInMilliseconds: number;
-    /** Returns the current time in milliseconds (injected for deterministic tests). */
+    /**
+    Returns the current time in milliseconds (injected for deterministic tests).
+     */
     nowInMilliseconds(this: void): number;
-    /** Sleeps for the given number of milliseconds (injected for deterministic tests). */
+    /**
+    Sleeps for the given number of milliseconds (injected for deterministic tests).
+     */
     sleep(this: void, milliseconds: number): Promise<void>;
-    /** Total budget before the poll rejects, in milliseconds. */
+    /**
+    Total budget before the poll rejects, in milliseconds.
+     */
     readonly timeoutInMilliseconds: number;
-    /** Optional detail appended to the timeout error message. */
+    /**
+    Optional detail appended to the timeout error message.
+     */
     readonly timeoutMessage?: string;
-    /** Whether a given attempt result is acceptable (stops the poll). */
+    /**
+    Whether a given attempt result is acceptable (stops the poll).
+     */
     until(this: void, result: Result): boolean;
 }
 /**

package/dist/lib/cjs/process-exit-message.cjs

@@ -44,4 +44,4 @@ function resolveReason(exitInfo) {
 0 && (module.exports = {
   buildProcessExitMessage
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/process-exit-message.d.cts

@@ -13,13 +13,21 @@
  * Parameters for {@link buildProcessExitMessage}.
  */
 export interface BuildProcessExitMessageParams {
-    /** The process's exit / spawn-failure details. */
+    /**
+    The process's exit / spawn-failure details.
+     */
     readonly exitInfo: ProcessExitInfo;
-    /** The captured stdout+stderr tail (empty when none was captured). */
+    /**
+    The captured stdout+stderr tail (empty when none was captured).
+     */
     readonly output: string;
-    /** Label for the captured output section (e.g. `"Emulator output"`). */
+    /**
+    Label for the captured output section (e.g. `"Emulator output"`).
+     */
     readonly outputLabel: string;
-    /** Human-readable subject of the process (e.g. `"Android emulator"`). */
+    /**
+    Human-readable subject of the process (e.g. `"Android emulator"`).
+     */
     readonly subject: string;
 }
 /**
@@ -30,11 +38,17 @@ export interface BuildProcessExitMessageParams {
  * `spawnError` to the failure message.
  */
 export interface ProcessExitInfo {
-    /** Exit code, or `null` when terminated by a signal or when it failed to spawn. */
+    /**
+    Exit code, or `null` when terminated by a signal or when it failed to spawn.
+     */
     readonly code: null | number;
-    /** Terminating signal, or `null` when it exited normally or failed to spawn. */
+    /**
+    Terminating signal, or `null` when it exited normally or failed to spawn.
+     */
     readonly signal: NodeJS.Signals | null;
-    /** The spawn-failure message when the process never started (e.g. `ENOENT`), otherwise absent. */
+    /**
+    The spawn-failure message when the process never started (e.g. `ENOENT`), otherwise absent.
+     */
     readonly spawnError?: string;
 }
 /**

package/dist/lib/cjs/renderer-boot-detection.cjs

@@ -19,12 +19,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var renderer_boot_detection_exports = {};
 __export(renderer_boot_detection_exports, {
   DEFAULT_DEAD_BOOT_GRACE_IN_MILLISECONDS: () => DEFAULT_DEAD_BOOT_GRACE_IN_MILLISECONDS,
-  checkRendererBootState: () => checkRendererBootState,
-  resolveDeadBootGraceInMilliseconds: () => resolveDeadBootGraceInMilliseconds
+  resolveDeadBootGraceInMilliseconds: () => resolveDeadBootGraceInMilliseconds,
+  resolveRendererBootState: () => resolveRendererBootState
 });
 module.exports = __toCommonJS(renderer_boot_detection_exports);
 const DEFAULT_DEAD_BOOT_GRACE_IN_MILLISECONDS = 1e4;
-function checkRendererBootState(params) {
+function resolveDeadBootGraceInMilliseconds(options) {
+  return options?.deadBootGraceInMilliseconds ?? DEFAULT_DEAD_BOOT_GRACE_IN_MILLISECONDS;
+}
+function resolveRendererBootState(params) {
   const { bodyChildElementCount, hasGraceElapsed, hasWindowApp, isDocumentComplete } = params;
   if (hasWindowApp) {
     return "pending";
@@ -37,13 +40,10 @@ function checkRendererBootState(params) {
   }
   return "pending";
 }
-function resolveDeadBootGraceInMilliseconds(options) {
-  return options?.deadBootGraceInMilliseconds ?? DEFAULT_DEAD_BOOT_GRACE_IN_MILLISECONDS;
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DEFAULT_DEAD_BOOT_GRACE_IN_MILLISECONDS,
-  checkRendererBootState,
-  resolveDeadBootGraceInMilliseconds
+  resolveDeadBootGraceInMilliseconds,
+  resolveRendererBootState
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/renderer-boot-detection.d.cts

@@ -22,17 +22,6 @@ import type { ObsidianCdpTransportOptions } from './transport-options.cjs';
  * Default for {@link ObsidianCdpTransportOptions.deadBootGraceInMilliseconds}.
  */
 export declare const DEFAULT_DEAD_BOOT_GRACE_IN_MILLISECONDS = 10000;
-/**
- * Parameters for {@link checkRendererBootState}.
- */
-export interface CheckRendererBootStateParams extends RendererBootObservation {
-    /**
-     * Whether the bootstrap grace window has elapsed since the renderer first
-     * reached `document.readyState` `'complete'`. The `'dead'` verdict is withheld
-     * until this is `true` so a genuinely slow boot is never misjudged.
-     */
-    readonly hasGraceElapsed: boolean;
-}
 /**
  * A sample of the owned renderer's bootstrap state, taken from the vault page
  * target via a single CDP evaluation.
@@ -44,40 +33,55 @@ export interface RendererBootObservation {
      * least a loading shell.
      */
     readonly bodyChildElementCount: number;
-    /** Whether `window.app` is defined in the vault renderer. */
+    /**
+    Whether `window.app` is defined in the vault renderer.
+     */
     readonly hasWindowApp: boolean;
-    /** Whether the vault renderer's `document.readyState` is `'complete'`. */
+    /**
+    Whether the vault renderer's `document.readyState` is `'complete'`.
+     */
     readonly isDocumentComplete: boolean;
 }
 /**
- * Verdict from {@link checkRendererBootState}: `'dead'` when the renderer has
+ * Verdict from {@link resolveRendererBootState}: `'dead'` when the renderer has
  * terminally failed to initialize, `'pending'` when it may still be booting.
  */
 export type RendererBootVerdict = 'dead' | 'pending';
 /**
- * Decides whether the owned renderer has terminally failed to initialize.
- *
- * The verdict is `'dead'` only when all of the following hold: the grace window
- * has elapsed, `window.app` is still undefined, the document is `'complete'`,
- * and `<body>` is empty. This is exactly the observed incompatible-shell state
- * (an asar that cannot run on the launched Electron), and it cannot be reached
- * by a healthy boot — `window.app` is defined early, and a slow boot renders a
- * non-empty loading shell — so there is no false-positive path on a valid boot.
- *
- * @param params - The sampled observation plus whether the grace has elapsed.
- * @returns `'dead'` when the renderer is terminally dead, otherwise `'pending'`.
+ * Parameters for {@link resolveRendererBootState}.
  */
-export declare function checkRendererBootState(params: CheckRendererBootStateParams): RendererBootVerdict;
+export interface ResolveRendererBootStateParams extends RendererBootObservation {
+    /**
+     * Whether the bootstrap grace window has elapsed since the renderer first
+     * reached `document.readyState` `'complete'`. The `'dead'` verdict is withheld
+     * until this is `true` so a genuinely slow boot is never misjudged.
+     */
+    readonly hasGraceElapsed: boolean;
+}
 /**
  * Resolves the dead-boot fast-fail grace window, applying the default when the
  * option is omitted.
  *
  * This bounds how long the owned-vault readiness poll waits — after the renderer
  * first reaches `document.readyState` `'complete'` — before concluding the boot
- * is dead (see {@link checkRendererBootState}). A value of `0` disables fast-fail
+ * is dead (see {@link resolveRendererBootState}). A value of `0` disables fast-fail
  * entirely, restoring the plain wait-out-the-readiness-timeout behavior.
  *
  * @param options - The desktop CDP transport options (or the relevant slice).
  * @returns The grace window in milliseconds.
  */
 export declare function resolveDeadBootGraceInMilliseconds(options?: Pick<ObsidianCdpTransportOptions, 'deadBootGraceInMilliseconds'>): number;
+/**
+ * Decides whether the owned renderer has terminally failed to initialize.
+ *
+ * The verdict is `'dead'` only when all of the following hold: the grace window
+ * has elapsed, `window.app` is still undefined, the document is `'complete'`,
+ * and `<body>` is empty. This is exactly the observed incompatible-shell state
+ * (an asar that cannot run on the launched Electron), and it cannot be reached
+ * by a healthy boot — `window.app` is defined early, and a slow boot renders a
+ * non-empty loading shell — so there is no false-positive path on a valid boot.
+ *
+ * @param params - The sampled observation plus whether the grace has elapsed.
+ * @returns `'dead'` when the renderer is terminally dead, otherwise `'pending'`.
+ */
+export declare function resolveRendererBootState(params: ResolveRendererBootStateParams): RendererBootVerdict;

package/dist/lib/cjs/renderer-failed-to-initialize-error.cjs

@@ -38,4 +38,4 @@ class RendererFailedToInitializeError extends Error {
 0 && (module.exports = {
   RendererFailedToInitializeError
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/renderer-failed-to-initialize-error.d.cts

@@ -10,7 +10,7 @@
 /**
  * Thrown when the owned Obsidian renderer loads but never bootstraps the app —
  * an empty `<body>` with no `window.app` after the boot grace window (see
- * `checkRendererBootState`). The usual cause is an installer/Electron shell too
+ * `resolveRendererBootState`). The usual cause is an installer/Electron shell too
  * old for the pinned Obsidian app version.
  */
 export declare class RendererFailedToInitializeError extends Error {