obsidian-integration-testing 12.2.0 → 13.0.0

package/dist/lib/cjs/webview-cdp.cjs

@@ -38,6 +38,18 @@ class WebViewCdpConnection {
   /**
    * Wraps an already-open debugger socket, plus what is needed to tear its port forward down.
    *
+   * ONE `message` listener for the socket's whole life, routing both halves of what
+   * arrives — CDP events to their subscribed handler, command replies to the
+   * {@link send} call waiting on the id. A listener per in-flight command instead
+   * would make the count scale with concurrency, so eleven commands in flight at
+   * once would cross Node's default `maxListeners` of 10 and report a memory leak
+   * that is not one (see the desktop transport's `getPendingCommands`, where the
+   * same shape was measured).
+   *
+   * The parse is guarded because a frame this connection cannot read belongs to
+   * nothing it sent: throwing here would throw out of the event dispatch, where
+   * nothing can catch it.
+   *
    * @param webSocket - The open debugger socket.
    * @param deviceId - The adb device id, needed to drop the port forward on dispose.
    * @param port - The forwarded local port.
@@ -47,11 +59,25 @@ class WebViewCdpConnection {
     this.deviceId = deviceId;
     this.port = port;
     this.webSocket.addEventListener("message", (event) => {
-      const message = JSON.parse(String(event.data));
-      if (message.method === void 0) {
+      let message;
+      try {
+        message = JSON.parse(String(event.data));
+      } catch {
+        return;
+      }
+      if (message.method !== void 0) {
+        this.eventHandlers.get(message.method)?.(message.params ?? {});
+        return;
+      }
+      if (message.id === void 0) {
+        return;
+      }
+      const pendingCommand = this.pendingCommands.get(message.id);
+      if (!pendingCommand) {
         return;
       }
-      this.eventHandlers.get(message.method)?.(message.params ?? {});
+      this.pendingCommands.delete(message.id);
+      pendingCommand(message);
     });
   }
   webSocket;
@@ -70,6 +96,11 @@ class WebViewCdpConnection {
   }
   eventHandlers = /* @__PURE__ */ new Map();
   messageId = 0;
+  /**
+   * The commands still waiting for a reply, keyed by the CDP message id each was
+   * sent with. Emptied by whichever of the reply and the timeout comes first.
+   */
+  pendingCommands = /* @__PURE__ */ new Map();
   /**
    * Closes the socket and drops the adb port forward.
    */
@@ -113,24 +144,24 @@ class WebViewCdpConnection {
     const id = ++this.messageId;
     return new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
-        this.webSocket.removeEventListener("message", handler);
+        this.pendingCommands.delete(id);
         reject(new Error(`WebView CDP command timed out after ${String(CDP_COMMAND_TIMEOUT_IN_MILLISECONDS)}ms: ${method}`));
       }, CDP_COMMAND_TIMEOUT_IN_MILLISECONDS);
-      const handler = (event) => {
-        const message = JSON.parse(String(event.data));
-        if (message.id !== id) {
-          return;
-        }
+      this.pendingCommands.set(id, (message) => {
         clearTimeout(timeout);
-        this.webSocket.removeEventListener("message", handler);
         if (message.error) {
           reject(new Error(`WebView CDP command ${method} failed: ${message.error.message ?? "unknown error"}`));
           return;
         }
         resolve(message.result ?? {});
-      };
-      this.webSocket.addEventListener("message", handler);
-      this.webSocket.send(JSON.stringify({ id, method, params }));
+      });
+      try {
+        this.webSocket.send(JSON.stringify({ id, method, params }));
+      } catch (error) {
+        clearTimeout(timeout);
+        this.pendingCommands.delete(id);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
     });
   }
   /**
@@ -260,4 +291,4 @@ async function removeForward(deviceId, port) {
   parseWebViewDevtoolsSocketName,
   selectWebViewPageTarget
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/webview-cdp.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * A second, independent Chrome DevTools Protocol connection to Obsidian Mobile's WebView, used to inject\n * **trusted** input on Android (see **L39**).\n *\n * It is deliberately separate from the Appium session rather than layered on it. `AppiumTransport.evaluate`\n * runs the whole `evalInObsidian` closure inside one W3C *Execute Script*, which awaits the returned\n * promise \u2014 so while a closure sits waiting on `lib.clickElement(...)`, the WebDriver session is busy and\n * cannot be asked to do anything else. CDP is id-multiplexed and Chromium accepts multiple debugger\n * clients, so this socket stays free exactly when the Appium one does not. That is what lets the renderer\n * call back out to the host mid-closure.\n *\n * Reaching the WebView's debugger is a two-step: the app publishes an abstract unix socket named\n * `webview_devtools_remote_<pid>`, `adb forward` maps it to a local TCP port, and the usual `/json`\n * endpoint then lists the page targets.\n */\n\nimport { execFileSync } from 'node:child_process';\n\nimport type { CdpInputCommand } from './mobile-input.cjs';\n\nimport { exec } from './exec.cjs';\nimport { log } from './log.cjs';\nimport { pickFreePort } from './obsidian-instance.cjs';\n\nconst ADB_TIMEOUT_IN_MILLISECONDS = 15_000;\n// `adb forward --list` prints three columns: `<deviceId> tcp:<port> localabstract:<socketName>`.\nconst FORWARD_LIST_COLUMN_COUNT = 3;\nconst DECIMAL_RADIX = 10;\nconst CDP_COMMAND_TIMEOUT_IN_MILLISECONDS = 30_000;\nconst CDP_HOST = '127.0.0.1';\n\n/**\n * One entry of the debugger's `/json` target list.\n */\nexport interface CdpTarget {\n  readonly title?: string;\n  readonly type?: string;\n  readonly url?: string;\n  readonly webSocketDebuggerUrl?: string;\n}\n\n/**\n * Parameters for {@link connectToWebViewCdp}.\n */\nexport interface ConnectToWebViewCdpParams {\n  /**\n   * The Android application id whose WebView to attach to, e.g. `md.obsidian`.\n   */\n  readonly appId: string;\n\n  /**\n   * The adb device id (`emulator-5554`, a serial) to run adb against.\n   */\n  readonly deviceId: string;\n}\n\n/**\n * The error half of a failed CDP command response.\n */\ninterface CdpError {\n  readonly message?: string;\n}\n\n/**\n * Handles a CDP event.\n */\ntype CdpEventHandler = (params: Record<string, unknown>) => void;\n\n/**\n * A CDP message: either a response to a command (`id`) or an event (`method`).\n */\ninterface CdpMessage {\n  readonly error?: CdpError;\n  readonly id?: number;\n  readonly method?: string;\n  readonly params?: Record<string, unknown>;\n  readonly result?: Record<string, unknown>;\n}\n\n/* v8 ignore start -- Integration-time code (a live WebSocket to a WebView, adb port forwarding). Covered by the Android integration tests, not by unit tests. It ends before `parseForwardedPort`: `perfectionist/sort-modules` places the pure, unit-tested helpers AFTER this class and `connectToWebViewCdp`, so they must stay measured. */\n\n/**\n * An open CDP connection to a WebView.\n *\n * Commands are id-multiplexed, so a command issued from inside an event handler completes while an earlier\n * `Runtime.evaluate` is still awaiting its promise \u2014 which is the whole reason this class exists.\n */\nexport class WebViewCdpConnection {\n  /**\n   * Whether the socket is still usable.\n   *\n   * Restarting the app tears its WebView down and takes the debugger target with it, so a cached\n   * connection has to be re-checked rather than assumed live.\n   *\n   * @returns `true` while the socket is open.\n   */\n  public get isOpen(): boolean {\n    return this.webSocket.readyState === WebSocket.OPEN;\n  }\n\n  private readonly eventHandlers = new Map<string, CdpEventHandler>();\n\n  private messageId = 0;\n\n  /**\n   * Wraps an already-open debugger socket, plus what is needed to tear its port forward down.\n   *\n   * @param webSocket - The open debugger socket.\n   * @param deviceId - The adb device id, needed to drop the port forward on dispose.\n   * @param port - The forwarded local port.\n   */\n  public constructor(private readonly webSocket: WebSocket, private readonly deviceId: string, private readonly port: number) {\n    this.webSocket.addEventListener('message', (event: MessageEvent) => {\n      const message = JSON.parse(String(event.data)) as CdpMessage;\n      if (message.method === undefined) {\n        return;\n      }\n\n      this.eventHandlers.get(message.method)?.(message.params ?? {});\n    });\n  }\n\n  /**\n   * Closes the socket and drops the adb port forward.\n   */\n  public async dispose(): Promise<void> {\n    this.closeSocket();\n    await removeForward(this.deviceId, this.port);\n  }\n\n  /**\n   * Synchronous disposal, for `process.on('exit')` handlers where async work cannot run.\n   *\n   * Without this an abrupt worker exit leaves the port forward behind \u2014 the async {@link dispose} above\n   * never gets a turn.\n   */\n  public disposeSync(): void {\n    this.closeSocket();\n    try {\n      execFileSync('adb', ['-s', this.deviceId, 'forward', '--remove', `tcp:${String(this.port)}`], {\n        stdio: 'ignore',\n        timeout: ADB_TIMEOUT_IN_MILLISECONDS\n      });\n    } catch {\n      // Best effort: adb drops every forward when the device disconnects anyway.\n    }\n  }\n\n  /**\n   * Subscribes to a CDP event. One handler per method; subscribing again replaces it.\n   *\n   * @param method - The CDP event name, e.g. `Runtime.bindingCalled`.\n   * @param handler - Called with the event parameters.\n   */\n  public on(method: string, handler: CdpEventHandler): void {\n    this.eventHandlers.set(method, handler);\n  }\n\n  /**\n   * Sends a CDP command and waits for its response.\n   *\n   * @param method - The CDP method name.\n   * @param params - The CDP method parameters.\n   * @returns The command result.\n   */\n  public send(method: string, params: Record<string, unknown> = {}): Promise<Record<string, unknown>> {\n    const id = ++this.messageId;\n\n    return new Promise<Record<string, unknown>>((resolve, reject) => {\n      const timeout = setTimeout(() => {\n        this.webSocket.removeEventListener('message', handler);\n        reject(new Error(`WebView CDP command timed out after ${String(CDP_COMMAND_TIMEOUT_IN_MILLISECONDS)}ms: ${method}`));\n      }, CDP_COMMAND_TIMEOUT_IN_MILLISECONDS);\n\n      const handler = (event: MessageEvent): void => {\n        const message = JSON.parse(String(event.data)) as CdpMessage;\n        if (message.id !== id) {\n          return;\n        }\n\n        clearTimeout(timeout);\n        this.webSocket.removeEventListener('message', handler);\n        if (message.error) {\n          reject(new Error(`WebView CDP command ${method} failed: ${message.error.message ?? 'unknown error'}`));\n          return;\n        }\n\n        resolve(message.result ?? {});\n      };\n\n      this.webSocket.addEventListener('message', handler);\n      this.webSocket.send(JSON.stringify({ id, method, params }));\n    });\n  }\n\n  /**\n   * Sends an ordered command sequence, one command at a time.\n   *\n   * Each command is awaited before the next is sent, which is the only ordering guarantee an input\n   * sequence needs \u2014 a long-press holds itself for its own `duration` rather than asking the host to\n   * sleep between two touches, so there is no inter-command delay to honor.\n   *\n   * @param commands - The commands to send, in order.\n   */\n  public async sendAll(commands: readonly CdpInputCommand[]): Promise<void> {\n    for (const command of commands) {\n      await this.send(command.method, command.params);\n    }\n  }\n\n  /**\n   * Closes the debugger socket and stops routing its events.\n   */\n  private closeSocket(): void {\n    this.eventHandlers.clear();\n    if (this.webSocket.readyState === WebSocket.OPEN) {\n      this.webSocket.close();\n    }\n  }\n}\n\n/**\n * Opens a CDP connection to the app's WebView.\n *\n * @param params - Which app on which device.\n * @returns The open connection. Dispose it to close the socket and drop the adb port forward.\n */\nexport async function connectToWebViewCdp(params: ConnectToWebViewCdpParams): Promise<WebViewCdpConnection> {\n  const { appId, deviceId } = params;\n\n  // `pidof` lists every matching process; the app's main one is first.\n  const pidofOutput = await adb(deviceId, ['shell', 'pidof', appId]);\n  const pid = pidofOutput.split(/\\s+/, 1)[0] ?? '';\n  if (!pid) {\n    throw new Error(`${appId} is not running on ${deviceId}, so its WebView has no debugger to attach to.`);\n  }\n\n  const procNetUnix = await adb(deviceId, ['shell', 'cat', '/proc/net/unix']);\n  const socketName = parseWebViewDevtoolsSocketName(procNetUnix, pid);\n\n  const forwardList = await adb(deviceId, ['forward', '--list']);\n  const existingPort = parseForwardedPort(forwardList, deviceId, socketName);\n  const port = existingPort ?? await pickFreePort();\n  if (existingPort === undefined) {\n    await adb(deviceId, ['forward', `tcp:${String(port)}`, `localabstract:${socketName}`]);\n    log(`[webview-cdp] Forwarded tcp:${String(port)} -> localabstract:${socketName} (${appId} pid ${pid})`);\n  } else {\n    log(`[webview-cdp] Reusing forward tcp:${String(port)} -> localabstract:${socketName} (${appId} pid ${pid})`);\n  }\n\n  try {\n    const response = await fetch(`http://${CDP_HOST}:${String(port)}/json`);\n    const target = selectWebViewPageTarget(await response.json() as CdpTarget[]);\n    const webSocket = new WebSocket(target.webSocketDebuggerUrl ?? '');\n    await new Promise<void>((resolve, reject) => {\n      webSocket.addEventListener('open', () => {\n        resolve();\n      }, { once: true });\n      webSocket.addEventListener('error', () => {\n        reject(new Error(`Could not open the WebView CDP socket at ${target.webSocketDebuggerUrl ?? ''}.`));\n      }, { once: true });\n    });\n    log(`[webview-cdp] Attached to WebView target \"${target.title ?? ''}\"`);\n\n    return new WebViewCdpConnection(webSocket, deviceId, port);\n  } catch (error: unknown) {\n    await removeForward(deviceId, port);\n    throw error;\n  }\n}\n\n/* v8 ignore stop */\n\n/**\n * Finds a port already forwarded to this device socket, so repeated runs reuse one forward.\n *\n * Without this every run allocates a fresh port, and any run that exits without the async\n * {@link WebViewCdpConnection.dispose} \u2014 an abrupt worker exit, where only the synchronous teardown\n * path runs \u2014 leaves its forward behind forever. Reuse bounds that to a single forward per socket\n * rather than one per run.\n *\n * @param forwardList - The output of `adb forward --list`.\n * @param deviceId - The adb device id to match.\n * @param socketName - The abstract socket name to match.\n * @returns The already-forwarded local port, or `undefined` when there is none.\n */\nexport function parseForwardedPort(forwardList: string, deviceId: string, socketName: string): number | undefined {\n  for (const line of forwardList.split('\\n')) {\n    // `adb forward --list` prints `<deviceId> tcp:<port> localabstract:<socketName>`.\n    const [lineDeviceId, local, remote] = line.trim().split(/\\s+/, FORWARD_LIST_COLUMN_COUNT);\n    if (lineDeviceId !== deviceId || remote !== `localabstract:${socketName}` || !local?.startsWith('tcp:')) {\n      continue;\n    }\n\n    const port = Number.parseInt(local.slice('tcp:'.length), DECIMAL_RADIX);\n    if (Number.isSafeInteger(port)) {\n      return port;\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Picks the WebView's devtools socket name out of `/proc/net/unix`.\n *\n * A device can host several debuggable WebViews (other apps, a leftover process), so the app's own pid is\n * what disambiguates them. When no socket matches that pid the sole remaining candidate is used \u2014 a\n * WebView whose socket is named after a child process rather than the one `pidof` reported still has to be\n * reachable \u2014 but two unattributable candidates is ambiguous enough to refuse.\n *\n * @param procNetUnix - The contents of `/proc/net/unix`.\n * @param pid - The application's process id.\n * @returns The socket name, e.g. `webview_devtools_remote_18056`.\n */\nexport function parseWebViewDevtoolsSocketName(procNetUnix: string, pid: string): string {\n  // The whole match minus its leading `@`, rather than a named capture group: a mandatory group is always\n  // Present once the pattern has matched, so `match.groups?.['name'] ?? ''` would leave behind two branches\n  // No input can ever reach \u2014 and this file is measured against a 100% branch gate.\n  const names = [\n    ...new Set([...procNetUnix.matchAll(/@webview_devtools_remote_\\w+/g)]\n      .map((match) => match[0].slice('@'.length)))\n  ];\n\n  // Destructured rather than indexed for the same reason: `soleName` carries the \"there is at least one\"\n  // Fact in the type, so neither the empty check below nor the single-candidate one leaves a dead branch.\n  const [soleName, ...otherNames] = names;\n\n  if (soleName === undefined) {\n    throw new Error(\n      'No `webview_devtools_remote_*` socket on the device. Obsidian Mobile is not running, or its WebView '\n        + 'debugger is disabled.'\n    );\n  }\n\n  const exactName = `webview_devtools_remote_${pid}`;\n  if (names.includes(exactName)) {\n    return exactName;\n  }\n\n  if (otherNames.length === 0) {\n    return soleName;\n  }\n\n  throw new Error(\n    `No \\`${exactName}\\` socket, and ${String(names.length)} other debuggable WebViews are present `\n      + `(${names.join(', ')}), so the right one cannot be chosen.`\n  );\n}\n\n/**\n * Picks the Obsidian page target out of the debugger's `/json` list.\n *\n * @param targets - The `/json` response.\n * @returns The page target to attach to.\n */\nexport function selectWebViewPageTarget(targets: readonly CdpTarget[]): CdpTarget {\n  const target = targets.find((candidate) => candidate.type === 'page' && Boolean(candidate.webSocketDebuggerUrl))\n    ?? targets.find((candidate) => Boolean(candidate.webSocketDebuggerUrl));\n\n  if (!target) {\n    throw new Error('The WebView debugger listed no target with a WebSocket endpoint.');\n  }\n\n  return target;\n}\n\n/* v8 ignore start -- Integration-time code (adb shell-outs). Covered by the Android integration tests, not by unit tests. */\n\n/**\n * Runs an adb command against one device.\n *\n * @param deviceId - The adb device id.\n * @param commandArguments - The adb arguments after `-s <deviceId>`.\n * @returns Trimmed stdout.\n */\nasync function adb(deviceId: string, commandArguments: string[]): Promise<string> {\n  const stdout = await exec(['adb', '-s', deviceId, ...commandArguments], {\n    isQuiet: true,\n    timeoutInMilliseconds: ADB_TIMEOUT_IN_MILLISECONDS\n  });\n\n  return stdout.trim();\n}\n\n/**\n * Drops an adb port forward, ignoring the \"not found\" case.\n *\n * @param deviceId - The adb device id.\n * @param port - The forwarded local port.\n */\nasync function removeForward(deviceId: string, port: number): Promise<void> {\n  try {\n    await exec(['adb', '-s', deviceId, 'forward', '--remove', `tcp:${String(port)}`], {\n      isQuiet: true,\n      shouldIgnoreExitCode: true,\n      timeoutInMilliseconds: ADB_TIMEOUT_IN_MILLISECONDS\n    });\n  } catch {\n    // Best effort: the forward is per-run and adb drops it when the device disconnects anyway.\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/webview-cdp.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * A second, independent Chrome DevTools Protocol connection to Obsidian Mobile's WebView, used to inject\n * **trusted** input on Android (see **L39**).\n *\n * It is deliberately separate from the Appium session rather than layered on it. `AppiumTransport.evaluate`\n * runs the whole `evalInObsidian` closure inside one W3C *Execute Script*, which awaits the returned\n * promise \u2014 so while a closure sits waiting on `lib.clickElement(...)`, the WebDriver session is busy and\n * cannot be asked to do anything else. CDP is id-multiplexed and Chromium accepts multiple debugger\n * clients, so this socket stays free exactly when the Appium one does not. That is what lets the renderer\n * call back out to the host mid-closure.\n *\n * Reaching the WebView's debugger is a two-step: the app publishes an abstract unix socket named\n * `webview_devtools_remote_<pid>`, `adb forward` maps it to a local TCP port, and the usual `/json`\n * endpoint then lists the page targets.\n */\n\nimport { execFileSync } from 'node:child_process';\n\nimport type { CdpInputCommand } from './mobile-input.cjs';\n\nimport { exec } from './exec.cjs';\nimport { log } from './log.cjs';\nimport { pickFreePort } from './obsidian-instance.cjs';\n\nconst ADB_TIMEOUT_IN_MILLISECONDS = 15_000;\n// `adb forward --list` prints three columns: `<deviceId> tcp:<port> localabstract:<socketName>`.\nconst FORWARD_LIST_COLUMN_COUNT = 3;\nconst DECIMAL_RADIX = 10;\n/*\n * Bounds one command on THIS side channel \u2014 an `Input.dispatchMouseEvent`, a target list. It is not the\n * per-eval cap and must not be derived from `DEFAULT_EVAL_CAP_IN_MILLISECONDS`: no test closure travels\n * this socket, and the whole point of the second connection is that it stays free while the Appium session\n * is busy running one. The shared value is a coincidence.\n */\nconst CDP_COMMAND_TIMEOUT_IN_MILLISECONDS = 30_000;\nconst CDP_HOST = '127.0.0.1';\n\n/**\n * One entry of the debugger's `/json` target list.\n */\nexport interface CdpTarget {\n  readonly title?: string;\n  readonly type?: string;\n  readonly url?: string;\n  readonly webSocketDebuggerUrl?: string;\n}\n\n/**\n * Parameters for {@link connectToWebViewCdp}.\n */\nexport interface ConnectToWebViewCdpParams {\n  /**\n   * The Android application id whose WebView to attach to, e.g. `md.obsidian`.\n   */\n  readonly appId: string;\n\n  /**\n   * The adb device id (`emulator-5554`, a serial) to run adb against.\n   */\n  readonly deviceId: string;\n}\n\n/**\n * The error half of a failed CDP command response.\n */\ninterface CdpError {\n  readonly message?: string;\n}\n\n/**\n * Handles a CDP event.\n */\ntype CdpEventHandler = (params: Record<string, unknown>) => void;\n\n/**\n * A CDP message: either a response to a command (`id`) or an event (`method`).\n */\ninterface CdpMessage {\n  readonly error?: CdpError;\n  readonly id?: number;\n  readonly method?: string;\n  readonly params?: Record<string, unknown>;\n  readonly result?: Record<string, unknown>;\n}\n\n/**\n * A command waiting for its reply: settles the {@link WebViewCdpConnection.send}\n * call's promise and cancels the timeout that would otherwise fail it.\n */\ntype PendingCommand = (message: CdpMessage) => void;\n\n/* v8 ignore start -- Integration-time code (a live WebSocket to a WebView, adb port forwarding). Covered by the Android integration tests, not by unit tests. It ends before `parseForwardedPort`: `perfectionist/sort-modules` places the pure, unit-tested helpers AFTER this class and `connectToWebViewCdp`, so they must stay measured. */\n\n/**\n * An open CDP connection to a WebView.\n *\n * Commands are id-multiplexed, so a command issued from inside an event handler completes while an earlier\n * `Runtime.evaluate` is still awaiting its promise \u2014 which is the whole reason this class exists.\n */\nexport class WebViewCdpConnection {\n  /**\n   * Whether the socket is still usable.\n   *\n   * Restarting the app tears its WebView down and takes the debugger target with it, so a cached\n   * connection has to be re-checked rather than assumed live.\n   *\n   * @returns `true` while the socket is open.\n   */\n  public get isOpen(): boolean {\n    return this.webSocket.readyState === WebSocket.OPEN;\n  }\n\n  private readonly eventHandlers = new Map<string, CdpEventHandler>();\n\n  private messageId = 0;\n\n  /**\n   * The commands still waiting for a reply, keyed by the CDP message id each was\n   * sent with. Emptied by whichever of the reply and the timeout comes first.\n   */\n  private readonly pendingCommands = new Map<number, PendingCommand>();\n\n  /**\n   * Wraps an already-open debugger socket, plus what is needed to tear its port forward down.\n   *\n   * ONE `message` listener for the socket's whole life, routing both halves of what\n   * arrives \u2014 CDP events to their subscribed handler, command replies to the\n   * {@link send} call waiting on the id. A listener per in-flight command instead\n   * would make the count scale with concurrency, so eleven commands in flight at\n   * once would cross Node's default `maxListeners` of 10 and report a memory leak\n   * that is not one (see the desktop transport's `getPendingCommands`, where the\n   * same shape was measured).\n   *\n   * The parse is guarded because a frame this connection cannot read belongs to\n   * nothing it sent: throwing here would throw out of the event dispatch, where\n   * nothing can catch it.\n   *\n   * @param webSocket - The open debugger socket.\n   * @param deviceId - The adb device id, needed to drop the port forward on dispose.\n   * @param port - The forwarded local port.\n   */\n  public constructor(private readonly webSocket: WebSocket, private readonly deviceId: string, private readonly port: number) {\n    this.webSocket.addEventListener('message', (event: MessageEvent) => {\n      let message: CdpMessage;\n      try {\n        message = JSON.parse(String(event.data)) as CdpMessage;\n      } catch {\n        return;\n      }\n\n      if (message.method !== undefined) {\n        this.eventHandlers.get(message.method)?.(message.params ?? {});\n        return;\n      }\n\n      if (message.id === undefined) {\n        return;\n      }\n\n      const pendingCommand = this.pendingCommands.get(message.id);\n      if (!pendingCommand) {\n        return;\n      }\n\n      this.pendingCommands.delete(message.id);\n      pendingCommand(message);\n    });\n  }\n\n  /**\n   * Closes the socket and drops the adb port forward.\n   */\n  public async dispose(): Promise<void> {\n    this.closeSocket();\n    await removeForward(this.deviceId, this.port);\n  }\n\n  /**\n   * Synchronous disposal, for `process.on('exit')` handlers where async work cannot run.\n   *\n   * Without this an abrupt worker exit leaves the port forward behind \u2014 the async {@link dispose} above\n   * never gets a turn.\n   */\n  public disposeSync(): void {\n    this.closeSocket();\n    try {\n      execFileSync('adb', ['-s', this.deviceId, 'forward', '--remove', `tcp:${String(this.port)}`], {\n        stdio: 'ignore',\n        timeout: ADB_TIMEOUT_IN_MILLISECONDS\n      });\n    } catch {\n      // Best effort: adb drops every forward when the device disconnects anyway.\n    }\n  }\n\n  /**\n   * Subscribes to a CDP event. One handler per method; subscribing again replaces it.\n   *\n   * @param method - The CDP event name, e.g. `Runtime.bindingCalled`.\n   * @param handler - Called with the event parameters.\n   */\n  public on(method: string, handler: CdpEventHandler): void {\n    this.eventHandlers.set(method, handler);\n  }\n\n  /**\n   * Sends a CDP command and waits for its response.\n   *\n   * @param method - The CDP method name.\n   * @param params - The CDP method parameters.\n   * @returns The command result.\n   */\n  public send(method: string, params: Record<string, unknown> = {}): Promise<Record<string, unknown>> {\n    const id = ++this.messageId;\n\n    return new Promise<Record<string, unknown>>((resolve, reject) => {\n      const timeout = setTimeout(() => {\n        this.pendingCommands.delete(id);\n        reject(new Error(`WebView CDP command timed out after ${String(CDP_COMMAND_TIMEOUT_IN_MILLISECONDS)}ms: ${method}`));\n      }, CDP_COMMAND_TIMEOUT_IN_MILLISECONDS);\n\n      this.pendingCommands.set(id, (message) => {\n        clearTimeout(timeout);\n        if (message.error) {\n          reject(new Error(`WebView CDP command ${method} failed: ${message.error.message ?? 'unknown error'}`));\n          return;\n        }\n\n        resolve(message.result ?? {});\n      });\n\n      try {\n        this.webSocket.send(JSON.stringify({ id, method, params }));\n      } catch (error: unknown) {\n        // Nothing will answer a send that threw, so holding the entry for the full timeout would only delay the failure and then misname it.\n        clearTimeout(timeout);\n        this.pendingCommands.delete(id);\n        reject(error instanceof Error ? error : new Error(String(error)));\n      }\n    });\n  }\n\n  /**\n   * Sends an ordered command sequence, one command at a time.\n   *\n   * Each command is awaited before the next is sent, which is the only ordering guarantee an input\n   * sequence needs \u2014 a long-press holds itself for its own `duration` rather than asking the host to\n   * sleep between two touches, so there is no inter-command delay to honor.\n   *\n   * @param commands - The commands to send, in order.\n   */\n  public async sendAll(commands: readonly CdpInputCommand[]): Promise<void> {\n    for (const command of commands) {\n      await this.send(command.method, command.params);\n    }\n  }\n\n  /**\n   * Closes the debugger socket and stops routing its events.\n   */\n  private closeSocket(): void {\n    this.eventHandlers.clear();\n    if (this.webSocket.readyState === WebSocket.OPEN) {\n      this.webSocket.close();\n    }\n  }\n}\n\n/**\n * Opens a CDP connection to the app's WebView.\n *\n * @param params - Which app on which device.\n * @returns The open connection. Dispose it to close the socket and drop the adb port forward.\n */\nexport async function connectToWebViewCdp(params: ConnectToWebViewCdpParams): Promise<WebViewCdpConnection> {\n  const { appId, deviceId } = params;\n\n  // `pidof` lists every matching process; the app's main one is first.\n  const pidofOutput = await adb(deviceId, ['shell', 'pidof', appId]);\n  const pid = pidofOutput.split(/\\s+/, 1)[0] ?? '';\n  if (!pid) {\n    throw new Error(`${appId} is not running on ${deviceId}, so its WebView has no debugger to attach to.`);\n  }\n\n  const procNetUnix = await adb(deviceId, ['shell', 'cat', '/proc/net/unix']);\n  const socketName = parseWebViewDevtoolsSocketName(procNetUnix, pid);\n\n  const forwardList = await adb(deviceId, ['forward', '--list']);\n  const existingPort = parseForwardedPort(forwardList, deviceId, socketName);\n  const port = existingPort ?? await pickFreePort();\n  if (existingPort === undefined) {\n    await adb(deviceId, ['forward', `tcp:${String(port)}`, `localabstract:${socketName}`]);\n    log(`[webview-cdp] Forwarded tcp:${String(port)} -> localabstract:${socketName} (${appId} pid ${pid})`);\n  } else {\n    log(`[webview-cdp] Reusing forward tcp:${String(port)} -> localabstract:${socketName} (${appId} pid ${pid})`);\n  }\n\n  try {\n    const response = await fetch(`http://${CDP_HOST}:${String(port)}/json`);\n    const target = selectWebViewPageTarget(await response.json() as CdpTarget[]);\n    const webSocket = new WebSocket(target.webSocketDebuggerUrl ?? '');\n    await new Promise<void>((resolve, reject) => {\n      webSocket.addEventListener('open', () => {\n        resolve();\n      }, { once: true });\n      webSocket.addEventListener('error', () => {\n        reject(new Error(`Could not open the WebView CDP socket at ${target.webSocketDebuggerUrl ?? ''}.`));\n      }, { once: true });\n    });\n    log(`[webview-cdp] Attached to WebView target \"${target.title ?? ''}\"`);\n\n    return new WebViewCdpConnection(webSocket, deviceId, port);\n  } catch (error: unknown) {\n    await removeForward(deviceId, port);\n    throw error;\n  }\n}\n\n/* v8 ignore stop */\n\n/**\n * Finds a port already forwarded to this device socket, so repeated runs reuse one forward.\n *\n * Without this every run allocates a fresh port, and any run that exits without the async\n * {@link WebViewCdpConnection.dispose} \u2014 an abrupt worker exit, where only the synchronous teardown\n * path runs \u2014 leaves its forward behind forever. Reuse bounds that to a single forward per socket\n * rather than one per run.\n *\n * @param forwardList - The output of `adb forward --list`.\n * @param deviceId - The adb device id to match.\n * @param socketName - The abstract socket name to match.\n * @returns The already-forwarded local port, or `undefined` when there is none.\n */\nexport function parseForwardedPort(forwardList: string, deviceId: string, socketName: string): number | undefined {\n  for (const line of forwardList.split('\\n')) {\n    // `adb forward --list` prints `<deviceId> tcp:<port> localabstract:<socketName>`.\n    const [lineDeviceId, local, remote] = line.trim().split(/\\s+/, FORWARD_LIST_COLUMN_COUNT);\n    if (lineDeviceId !== deviceId || remote !== `localabstract:${socketName}` || !local?.startsWith('tcp:')) {\n      continue;\n    }\n\n    const port = Number.parseInt(local.slice('tcp:'.length), DECIMAL_RADIX);\n    if (Number.isSafeInteger(port)) {\n      return port;\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Picks the WebView's devtools socket name out of `/proc/net/unix`.\n *\n * A device can host several debuggable WebViews (other apps, a leftover process), so the app's own pid is\n * what disambiguates them. When no socket matches that pid the sole remaining candidate is used \u2014 a\n * WebView whose socket is named after a child process rather than the one `pidof` reported still has to be\n * reachable \u2014 but two unattributable candidates is ambiguous enough to refuse.\n *\n * @param procNetUnix - The contents of `/proc/net/unix`.\n * @param pid - The application's process id.\n * @returns The socket name, e.g. `webview_devtools_remote_18056`.\n */\nexport function parseWebViewDevtoolsSocketName(procNetUnix: string, pid: string): string {\n  // The whole match minus its leading `@`, rather than a named capture group: a mandatory group is always\n  // present once the pattern has matched, so `match.groups?.['name'] ?? ''` would leave behind two branches\n  // no input can ever reach \u2014 and this file is measured against a 100% branch gate.\n  const names = [\n    ...new Set([...procNetUnix.matchAll(/@webview_devtools_remote_\\w+/g)]\n      .map((match) => match[0].slice('@'.length)))\n  ];\n\n  // Destructured rather than indexed for the same reason: `soleName` carries the \"there is at least one\"\n  // fact in the type, so neither the empty check below nor the single-candidate one leaves a dead branch.\n  const [soleName, ...otherNames] = names;\n\n  if (soleName === undefined) {\n    throw new Error(\n      'No `webview_devtools_remote_*` socket on the device. Obsidian Mobile is not running, or its WebView '\n        + 'debugger is disabled.'\n    );\n  }\n\n  const exactName = `webview_devtools_remote_${pid}`;\n  if (names.includes(exactName)) {\n    return exactName;\n  }\n\n  if (otherNames.length === 0) {\n    return soleName;\n  }\n\n  throw new Error(\n    `No \\`${exactName}\\` socket, and ${String(names.length)} other debuggable WebViews are present `\n      + `(${names.join(', ')}), so the right one cannot be chosen.`\n  );\n}\n\n/**\n * Picks the Obsidian page target out of the debugger's `/json` list.\n *\n * @param targets - The `/json` response.\n * @returns The page target to attach to.\n */\nexport function selectWebViewPageTarget(targets: readonly CdpTarget[]): CdpTarget {\n  const target = targets.find((candidate) => candidate.type === 'page' && Boolean(candidate.webSocketDebuggerUrl))\n    ?? targets.find((candidate) => Boolean(candidate.webSocketDebuggerUrl));\n\n  if (!target) {\n    throw new Error('The WebView debugger listed no target with a WebSocket endpoint.');\n  }\n\n  return target;\n}\n\n/* v8 ignore start -- Integration-time code (adb shell-outs). Covered by the Android integration tests, not by unit tests. */\n\n/**\n * Runs an adb command against one device.\n *\n * @param deviceId - The adb device id.\n * @param commandArguments - The adb arguments after `-s <deviceId>`.\n * @returns Trimmed stdout.\n */\nasync function adb(deviceId: string, commandArguments: string[]): Promise<string> {\n  const stdout = await exec(['adb', '-s', deviceId, ...commandArguments], {\n    isQuiet: true,\n    timeoutInMilliseconds: ADB_TIMEOUT_IN_MILLISECONDS\n  });\n\n  return stdout.trim();\n}\n\n/**\n * Drops an adb port forward, ignoring the \"not found\" case.\n *\n * @param deviceId - The adb device id.\n * @param port - The forwarded local port.\n */\nasync function removeForward(deviceId: string, port: number): Promise<void> {\n  try {\n    await exec(['adb', '-s', deviceId, 'forward', '--remove', `tcp:${String(port)}`], {\n      isQuiet: true,\n      shouldIgnoreExitCode: true,\n      timeoutInMilliseconds: ADB_TIMEOUT_IN_MILLISECONDS\n    });\n  } catch {\n    // Best effort: the forward is per-run and adb drops it when the device disconnects anyway.\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/cjs/webview-cdp.d.cts

@@ -63,9 +63,26 @@ export declare class WebViewCdpConnection {
     get isOpen(): boolean;
     private readonly eventHandlers;
     private messageId;
+    /**
+     * The commands still waiting for a reply, keyed by the CDP message id each was
+     * sent with. Emptied by whichever of the reply and the timeout comes first.
+     */
+    private readonly pendingCommands;
     /**
      * Wraps an already-open debugger socket, plus what is needed to tear its port forward down.
      *
+     * ONE `message` listener for the socket's whole life, routing both halves of what
+     * arrives — CDP events to their subscribed handler, command replies to the
+     * {@link send} call waiting on the id. A listener per in-flight command instead
+     * would make the count scale with concurrency, so eleven commands in flight at
+     * once would cross Node's default `maxListeners` of 10 and report a memory leak
+     * that is not one (see the desktop transport's `getPendingCommands`, where the
+     * same shape was measured).
+     *
+     * The parse is guarded because a frame this connection cannot read belongs to
+     * nothing it sent: throwing here would throw out of the event dispatch, where
+     * nothing can catch it.
+     *
      * @param webSocket - The open debugger socket.
      * @param deviceId - The adb device id, needed to drop the port forward on dispose.
      * @param port - The forwarded local port.

package/dist/lib/esm/adb.mjs

@@ -32,4 +32,4 @@ export {
   runAdbText,
   runAdbTextWithoutDevice
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/app-config.d.mts

@@ -120,7 +120,7 @@ export interface WithAppConfigParams<T> extends SetAppConfigParams {
     /**
      * The work to run while the key holds {@link SetAppConfigParams.value}.
      */
-    readonly callback: (this: void) => Promise<T>;
+    callback(this: void): Promise<T>;
 }
 /**
  * Reads a vault config key, resolving the transport and vault from the current

package/dist/lib/esm/app-config.mjs

@@ -107,4 +107,4 @@ export {
   setAppConfig,
   withAppConfig
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/app-config.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Node-side read/write/restore seam for one of Obsidian's **vault config** keys,\n * for the few tests that need a different value than the harness's headless\n * default.\n *\n * `ensureHeadlessVaultConfig` writes `alwaysUpdateLinks: true` and\n * `settingsPopoutWindow: false` into every vault the harness provisions, before\n * that vault is ever opened, and neither is a knob a consumer configures \u2014 see\n * the project `AGENTS.md` (**L48**). That is right for almost every test, and\n * wrong for the few whose **subject is** the second Electron window the popout\n * creates: a test that waits on `activeWindow !== window`, or reads\n * `app.setting.popout`, never observes the thing it asserts and simply times out.\n *\n * Those tests opt back in through here rather than by hand, which buys three\n * things over an inline `setConfig` inside an `evalInObsidian` closure:\n *\n * - **The value is restored**, including deleting a key that had never been\n *   written. An inline setter writes into a vault shared with the rest of the\n *   run, so every later test in that instance inherits the change \u2014 the\n *   cross-test contamination the unconditional default exists to end.\n * - **The cast lives in one place.** `obsidian-typings`' `ConfigItem` union omits\n *   `settingsPopoutWindow`, so the key cannot be passed to `getConfig` /\n *   `setConfig` without widening them; every consumer that wrote the setter\n *   inline repeated that cast.\n * - **Per-test granularity.** A parameter on the provisioning write would be\n *   per-vault, and a project whose tests share one vault \u2014 the usual shape \u2014\n *   cannot have it both ways.\n *\n * Everything here runs on the **Node** side. An `evalInObsidian` callback is\n * serialized into the driven Obsidian and can import nothing, so a helper\n * callable from inside one is not expressible; each function below is its own\n * short eval instead.\n *\n * ### Why presence is read off `app.vault.config`, not from `getConfig`\n *\n * Both facts were verified in the shipped 1.14.1 bundle rather than assumed:\n *\n * - `Vault.setConfig(key, value)` **deletes** the key when `value` is\n *   `undefined`, and does nothing at all when the value is unchanged (no save,\n *   no `config-changed` event). So an exact restore of a key that was never\n *   written is expressible.\n * - `Vault.getConfig(key)` falls back to Obsidian's defaults table when the key\n *   is absent, so it cannot tell *unset* from *set to the shipped default* \u2014\n *   restoring from it would leave the key written where it had not been.\n *   `app.vault.config` holds only the keys changed from their default, so\n *   `Object.hasOwn` on it is the signal a restore needs.\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 {\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.mjs';\nimport type { ObsidianTransport } from './transport.mjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.mjs';\nimport { normalizeOptionalProperties } from './normalize-optional-properties.mjs';\n\n/**\n * Parameters for {@link getAppConfig}, and the shared shape of the writers below.\n */\nexport interface AppConfigParams {\n  /**\n   * The vault config key, e.g. `settingsPopoutWindow`. Not narrowed to\n   * `obsidian-typings`' `ConfigItem`: that union omits keys Obsidian really\n   * reads, `settingsPopoutWindow` among them, which is the whole reason a\n   * consumer had to widen the setter by hand.\n   */\n  readonly configKey: string;\n\n  /**\n   * Override the transport. When omitted, the transport the current test\n   * context is driving is used.\n   */\n  readonly transport?: ObsidianTransport;\n\n  /**\n   * The vault whose Obsidian instance to read or write. When omitted, the\n   * current test context's vault is used.\n   */\n  readonly vaultPath?: string;\n}\n\n/**\n * What {@link setAppConfig} captured before it wrote, and all\n * {@link restoreAppConfig} needs to put the key back exactly as it was \u2014\n * including putting it back to *absent*.\n */\nexport interface AppConfigRestore {\n  /**\n   * The key that was written.\n   */\n  readonly configKey: string;\n\n  /**\n   * Whether the vault's config carried the key at all before the write. `false`\n   * means the vault was running on Obsidian's own default, and restoring is a\n   * delete rather than a write.\n   */\n  readonly isPresent: boolean;\n\n  /**\n   * The transport the capture was made against, so the restore lands in the\n   * same instance.\n   */\n  readonly transport?: ObsidianTransport;\n\n  /**\n   * The value the key held, or `undefined` when {@link isPresent} is `false`.\n   */\n  readonly value: unknown;\n\n  /**\n   * The vault the capture was made against, so the restore lands in the same\n   * instance.\n   */\n  readonly vaultPath?: string;\n}\n\n/**\n * Parameters for {@link setAppConfig}.\n */\nexport interface SetAppConfigParams extends AppConfigParams {\n  /**\n   * The value to write. `undefined` deletes the key, leaving Obsidian's own\n   * default in force.\n   */\n  readonly value: unknown;\n}\n\n/**\n * Parameters for {@link withAppConfig}.\n *\n * @typeParam T - What the wrapped work returns.\n */\nexport interface WithAppConfigParams<T> extends SetAppConfigParams {\n  /**\n   * The work to run while the key holds {@link SetAppConfigParams.value}.\n   */\n  readonly callback: (this: void) => Promise<T>;\n}\n\n/**\n * What a write captured about the key's state before it wrote.\n */\ninterface CapturedValue {\n  isPresent: boolean;\n  value: unknown;\n}\n\n/**\n * The serialized payload of a read.\n */\ninterface ReadInput extends GenericObject {\n  configKey: string;\n}\n\n/**\n * The serialized payload of a restore.\n */\ninterface RestoreInput extends GenericObject {\n  configKey: string;\n  isPresent: boolean;\n  value: unknown;\n}\n\n/**\n * The serialized payload of a write.\n */\ninterface WriteInput extends GenericObject {\n  configKey: string;\n  value: unknown;\n}\n\n/**\n * Reads a vault config key, resolving the transport and vault from the current\n * test context.\n *\n * This is Obsidian's own `Vault.getConfig`, so an absent key reads back as\n * Obsidian's **default** for it rather than as `undefined` \u2014 see this file's\n * header. Use {@link setAppConfig}'s {@link AppConfigRestore.isPresent} when the\n * difference matters.\n *\n * @param params - The key to read, and transport / vault overrides.\n * @returns A {@link Promise} resolving to the key's effective value.\n */\nexport async function getAppConfig(params: AppConfigParams): Promise<unknown> {\n  const {\n    configKey,\n    transport,\n    vaultPath\n  } = params;\n\n  return await evalInObsidian(normalizeOptionalProperties<EvalInObsidianParams<ReadInput, unknown>>({\n    callback({ app, configKey: key }): unknown {\n      const getConfig = app.vault.getConfig.bind(app.vault) as (configKey: string) => unknown;\n      return getConfig(key);\n    },\n    input: { configKey },\n    transport,\n    vaultPath\n  }));\n}\n\n/**\n * Puts a key back exactly as {@link setAppConfig} found it \u2014 writing the captured\n * value back, or **deleting** the key when the vault had never carried it.\n *\n * The `beforeAll` / `afterAll` half of the seam. A test that scopes the change\n * to one callback wants {@link withAppConfig} instead, which cannot forget the\n * restore.\n *\n * @param restore - The token {@link setAppConfig} returned.\n * @returns A {@link Promise} that resolves once the key is back as it was.\n */\nexport async function restoreAppConfig(restore: AppConfigRestore): Promise<void> {\n  const {\n    configKey,\n    isPresent,\n    transport,\n    value,\n    vaultPath\n  } = restore;\n\n  await evalInObsidian(normalizeOptionalProperties<EvalInObsidianParams<RestoreInput, undefined>>({\n    callback({\n      app,\n      configKey: key,\n      isPresent: wasPresent,\n      value: previousValue\n    }): undefined {\n      const setConfig = app.vault.setConfig.bind(app.vault) as (configKey: string, value: unknown) => void;\n\n      // `undefined` is not a no-op here: `setConfig` deletes the key for it,\n      // Which is the only way to restore one the vault never carried.\n      setConfig(key, wasPresent ? previousValue : undefined);\n    },\n    input: {\n      configKey,\n      isPresent,\n      value\n    },\n    transport,\n    vaultPath\n  }));\n}\n\n/**\n * Writes a vault config key, capturing what it held first so the write can be\n * undone exactly.\n *\n * Obsidian persists the change (`requestSaveConfig`) and fires its\n * `config-changed` event, both of which the app's own settings UI does too \u2014 so\n * anything listening reacts as it would to a user flipping the toggle. A write\n * of the value the key already holds is a no-op in Obsidian itself, and the\n * returned token still describes the state that preceded it.\n *\n * @param params - The key, the value, and transport / vault overrides.\n * @returns A {@link Promise} resolving to the {@link AppConfigRestore} token to\n *   hand {@link restoreAppConfig}.\n */\nexport async function setAppConfig(params: SetAppConfigParams): Promise<AppConfigRestore> {\n  const {\n    configKey,\n    transport,\n    value,\n    vaultPath\n  } = params;\n\n  const captured = await evalInObsidian(normalizeOptionalProperties<EvalInObsidianParams<WriteInput, CapturedValue>>({\n    callback({\n      app,\n      configKey: key,\n      value: newValue\n    }): CapturedValue {\n      // `config` carries ONLY the keys changed from their default, which is what\n      // Makes it the presence signal; `getConfig` substitutes the default and so\n      // Cannot tell an unset key from one set to that default. The value itself\n      // Still comes from `getConfig`, which returns the stored one whenever\n      // There is one \u2014 so the read needs no cast of the config object.\n      const isPresent = Object.hasOwn(app.vault.config, key);\n\n      const getConfig = app.vault.getConfig.bind(app.vault) as (configKey: string) => unknown;\n      const previousValue = isPresent ? getConfig(key) : undefined;\n\n      const setConfig = app.vault.setConfig.bind(app.vault) as (configKey: string, value: unknown) => void;\n      setConfig(key, newValue);\n\n      return {\n        isPresent,\n        value: previousValue\n      };\n    },\n    input: {\n      configKey,\n      value\n    },\n    transport,\n    vaultPath\n  }));\n\n  return normalizeOptionalProperties<AppConfigRestore>({\n    configKey,\n    isPresent: captured.isPresent,\n    transport,\n    value: captured.value,\n    vaultPath\n  });\n}\n\n/**\n * Runs work with a vault config key temporarily set, and puts the key back\n * afterwards \u2014 on a throw as much as on a return.\n *\n * The shape a popout-subject test wants:\n *\n * ```ts\n * await withAppConfig({\n *   async callback() {\n *     await evalInObsidian({ ... }); // the settings window is a popout in here\n *   },\n *   configKey: 'settingsPopoutWindow',\n *   value: true,\n *   vaultPath\n * });\n * ```\n *\n * The callback runs on the **Node** side, so it is free to make several evals,\n * take a screenshot, or assert between them.\n *\n * @typeParam T - What the wrapped work returns.\n * @param params - The key, the value to hold it at, the work, and transport /\n *   vault overrides.\n * @returns A {@link Promise} resolving to whatever the callback returned.\n */\nexport async function withAppConfig<T>(params: WithAppConfigParams<T>): Promise<T> {\n  const {\n    callback,\n    configKey,\n    transport,\n    value,\n    vaultPath\n  } = params;\n\n  const restore = await setAppConfig(normalizeOptionalProperties<SetAppConfigParams>({\n    configKey,\n    transport,\n    value,\n    vaultPath\n  }));\n\n  try {\n    return await callback();\n  } finally {\n    await restoreAppConfig(restore);\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AA0DA,SAAS,sBAAsB;AAC/B,SAAS,mCAAmC;AAkI5C,eAAsB,aAAa,QAA2C;AAC5E,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,SAAO,MAAM,eAAe,4BAAsE;AAAA,IAChG,SAAS,EAAE,KAAK,WAAW,IAAI,GAAY;AACzC,YAAM,YAAY,IAAI,MAAM,UAAU,KAAK,IAAI,KAAK;AACpD,aAAO,UAAU,GAAG;AAAA,IACtB;AAAA,IACA,OAAO,EAAE,UAAU;AAAA,IACnB;AAAA,IACA;AAAA,EACF,CAAC,CAAC;AACJ;AAaA,eAAsB,iBAAiB,SAA0C;AAC/E,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,eAAe,4BAA2E;AAAA,IAC9F,SAAS;AAAA,MACP;AAAA,MACA,WAAW;AAAA,MACX,WAAW;AAAA,MACX,OAAO;AAAA,IACT,GAAc;AACZ,YAAM,YAAY,IAAI,MAAM,UAAU,KAAK,IAAI,KAAK;AAIpD,gBAAU,KAAK,aAAa,gBAAgB,MAAS;AAAA,IACvD;AAAA,IACA,OAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC,CAAC;AACJ;AAgBA,eAAsB,aAAa,QAAuD;AACxF,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,WAAW,MAAM,eAAe,4BAA6E;AAAA,IACjH,SAAS;AAAA,MACP;AAAA,MACA,WAAW;AAAA,MACX,OAAO;AAAA,IACT,GAAkB;AAMhB,YAAM,YAAY,OAAO,OAAO,IAAI,MAAM,QAAQ,GAAG;AAErD,YAAM,YAAY,IAAI,MAAM,UAAU,KAAK,IAAI,KAAK;AACpD,YAAM,gBAAgB,YAAY,UAAU,GAAG,IAAI;AAEnD,YAAM,YAAY,IAAI,MAAM,UAAU,KAAK,IAAI,KAAK;AACpD,gBAAU,KAAK,QAAQ;AAEvB,aAAO;AAAA,QACL;AAAA,QACA,OAAO;AAAA,MACT;AAAA,IACF;AAAA,IACA,OAAO;AAAA,MACL;AAAA,MACA;AAAA,IACF;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC,CAAC;AAEF,SAAO,4BAA8C;AAAA,IACnD;AAAA,IACA,WAAW,SAAS;AAAA,IACpB;AAAA,IACA,OAAO,SAAS;AAAA,IAChB;AAAA,EACF,CAAC;AACH;AA2BA,eAAsB,cAAiB,QAA4C;AACjF,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,UAAU,MAAM,aAAa,4BAAgD;AAAA,IACjF;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC,CAAC;AAEF,MAAI;AACF,WAAO,MAAM,SAAS;AAAA,EACxB,UAAE;AACA,UAAM,iBAAiB,OAAO;AAAA,EAChC;AACF;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/app-config.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Node-side read/write/restore seam for one of Obsidian's **vault config** keys,\n * for the few tests that need a different value than the harness's headless\n * default.\n *\n * `ensureHeadlessVaultConfig` writes `alwaysUpdateLinks: true` and\n * `settingsPopoutWindow: false` into every vault the harness provisions, before\n * that vault is ever opened, and neither is a knob a consumer configures \u2014 see\n * the project `AGENTS.md` (**L48**). That is right for almost every test, and\n * wrong for the few whose **subject is** the second Electron window the popout\n * creates: a test that waits on `activeWindow !== window`, or reads\n * `app.setting.popout`, never observes the thing it asserts and simply times out.\n *\n * Those tests opt back in through here rather than by hand, which buys three\n * things over an inline `setConfig` inside an `evalInObsidian` closure:\n *\n * - **The value is restored**, including deleting a key that had never been\n *   written. An inline setter writes into a vault shared with the rest of the\n *   run, so every later test in that instance inherits the change \u2014 the\n *   cross-test contamination the unconditional default exists to end.\n * - **The cast lives in one place.** `obsidian-typings`' `ConfigItem` union omits\n *   `settingsPopoutWindow`, so the key cannot be passed to `getConfig` /\n *   `setConfig` without widening them; every consumer that wrote the setter\n *   inline repeated that cast.\n * - **Per-test granularity.** A parameter on the provisioning write would be\n *   per-vault, and a project whose tests share one vault \u2014 the usual shape \u2014\n *   cannot have it both ways.\n *\n * Everything here runs on the **Node** side. An `evalInObsidian` callback is\n * serialized into the driven Obsidian and can import nothing, so a helper\n * callable from inside one is not expressible; each function below is its own\n * short eval instead.\n *\n * ### Why presence is read off `app.vault.config`, not from `getConfig`\n *\n * Both facts were verified in the shipped 1.14.1 bundle rather than assumed:\n *\n * - `Vault.setConfig(key, value)` **deletes** the key when `value` is\n *   `undefined`, and does nothing at all when the value is unchanged (no save,\n *   no `config-changed` event). So an exact restore of a key that was never\n *   written is expressible.\n * - `Vault.getConfig(key)` falls back to Obsidian's defaults table when the key\n *   is absent, so it cannot tell *unset* from *set to the shipped default* \u2014\n *   restoring from it would leave the key written where it had not been.\n *   `app.vault.config` holds only the keys changed from their default, so\n *   `Object.hasOwn` on it is the signal a restore needs.\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 {\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.mjs';\nimport type { ObsidianTransport } from './transport.mjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.mjs';\nimport { normalizeOptionalProperties } from './normalize-optional-properties.mjs';\n\n/**\n * Parameters for {@link getAppConfig}, and the shared shape of the writers below.\n */\nexport interface AppConfigParams {\n  /**\n   * The vault config key, e.g. `settingsPopoutWindow`. Not narrowed to\n   * `obsidian-typings`' `ConfigItem`: that union omits keys Obsidian really\n   * reads, `settingsPopoutWindow` among them, which is the whole reason a\n   * consumer had to widen the setter by hand.\n   */\n  readonly configKey: string;\n\n  /**\n   * Override the transport. When omitted, the transport the current test\n   * context is driving is used.\n   */\n  readonly transport?: ObsidianTransport;\n\n  /**\n   * The vault whose Obsidian instance to read or write. When omitted, the\n   * current test context's vault is used.\n   */\n  readonly vaultPath?: string;\n}\n\n/**\n * What {@link setAppConfig} captured before it wrote, and all\n * {@link restoreAppConfig} needs to put the key back exactly as it was \u2014\n * including putting it back to *absent*.\n */\nexport interface AppConfigRestore {\n  /**\n   * The key that was written.\n   */\n  readonly configKey: string;\n\n  /**\n   * Whether the vault's config carried the key at all before the write. `false`\n   * means the vault was running on Obsidian's own default, and restoring is a\n   * delete rather than a write.\n   */\n  readonly isPresent: boolean;\n\n  /**\n   * The transport the capture was made against, so the restore lands in the\n   * same instance.\n   */\n  readonly transport?: ObsidianTransport;\n\n  /**\n   * The value the key held, or `undefined` when {@link isPresent} is `false`.\n   */\n  readonly value: unknown;\n\n  /**\n   * The vault the capture was made against, so the restore lands in the same\n   * instance.\n   */\n  readonly vaultPath?: string;\n}\n\n/**\n * Parameters for {@link setAppConfig}.\n */\nexport interface SetAppConfigParams extends AppConfigParams {\n  /**\n   * The value to write. `undefined` deletes the key, leaving Obsidian's own\n   * default in force.\n   */\n  readonly value: unknown;\n}\n\n/**\n * Parameters for {@link withAppConfig}.\n *\n * @typeParam T - What the wrapped work returns.\n */\nexport interface WithAppConfigParams<T> extends SetAppConfigParams {\n  /**\n   * The work to run while the key holds {@link SetAppConfigParams.value}.\n   */\n  callback(this: void): Promise<T>;\n}\n\n/**\n * What a write captured about the key's state before it wrote.\n */\ninterface CapturedValue {\n  isPresent: boolean;\n  value: unknown;\n}\n\n/**\n * The serialized payload of a read.\n */\ninterface ReadInput extends GenericObject {\n  configKey: string;\n}\n\n/**\n * The serialized payload of a restore.\n */\ninterface RestoreInput extends GenericObject {\n  configKey: string;\n  isPresent: boolean;\n  value: unknown;\n}\n\n/**\n * The serialized payload of a write.\n */\ninterface WriteInput extends GenericObject {\n  configKey: string;\n  value: unknown;\n}\n\n/**\n * Reads a vault config key, resolving the transport and vault from the current\n * test context.\n *\n * This is Obsidian's own `Vault.getConfig`, so an absent key reads back as\n * Obsidian's **default** for it rather than as `undefined` \u2014 see this file's\n * header. Use {@link setAppConfig}'s {@link AppConfigRestore.isPresent} when the\n * difference matters.\n *\n * @param params - The key to read, and transport / vault overrides.\n * @returns A {@link Promise} resolving to the key's effective value.\n */\n// eslint-disable-next-line obsidian-dev-utils/params-options-name-match -- Temporary: `AppConfigParams` is re-exported from `index.ts`, so renaming it to `GetAppConfigParams` is a breaking change held for the next major.\nexport async function getAppConfig(params: AppConfigParams): Promise<unknown> {\n  const {\n    configKey,\n    transport,\n    vaultPath\n  } = params;\n\n  return await evalInObsidian(normalizeOptionalProperties<EvalInObsidianParams<ReadInput, unknown>>({\n    callback({ app, configKey: key }): unknown {\n      const getConfig = app.vault.getConfig.bind(app.vault) as (configKey: string) => unknown;\n      return getConfig(key);\n    },\n    input: { configKey },\n    transport,\n    vaultPath\n  }));\n}\n\n/**\n * Puts a key back exactly as {@link setAppConfig} found it \u2014 writing the captured\n * value back, or **deleting** the key when the vault had never carried it.\n *\n * The `beforeAll` / `afterAll` half of the seam. A test that scopes the change\n * to one callback wants {@link withAppConfig} instead, which cannot forget the\n * restore.\n *\n * @param restore - The token {@link setAppConfig} returned.\n * @returns A {@link Promise} that resolves once the key is back as it was.\n */\nexport async function restoreAppConfig(restore: AppConfigRestore): Promise<void> {\n  const {\n    configKey,\n    isPresent,\n    transport,\n    value,\n    vaultPath\n  } = restore;\n\n  await evalInObsidian(normalizeOptionalProperties<EvalInObsidianParams<RestoreInput, undefined>>({\n    callback({\n      app,\n      configKey: key,\n      isPresent: wasPresent,\n      value: previousValue\n    }): undefined {\n      const setConfig = app.vault.setConfig.bind(app.vault) as (configKey: string, value: unknown) => void;\n\n      // `undefined` is not a no-op here: `setConfig` deletes the key for it,\n      // which is the only way to restore one the vault never carried.\n      setConfig(key, wasPresent ? previousValue : undefined);\n    },\n    input: {\n      configKey,\n      isPresent,\n      value\n    },\n    transport,\n    vaultPath\n  }));\n}\n\n/**\n * Writes a vault config key, capturing what it held first so the write can be\n * undone exactly.\n *\n * Obsidian persists the change (`requestSaveConfig`) and fires its\n * `config-changed` event, both of which the app's own settings UI does too \u2014 so\n * anything listening reacts as it would to a user flipping the toggle. A write\n * of the value the key already holds is a no-op in Obsidian itself, and the\n * returned token still describes the state that preceded it.\n *\n * @param params - The key, the value, and transport / vault overrides.\n * @returns A {@link Promise} resolving to the {@link AppConfigRestore} token to\n *   hand {@link restoreAppConfig}.\n */\nexport async function setAppConfig(params: SetAppConfigParams): Promise<AppConfigRestore> {\n  const {\n    configKey,\n    transport,\n    value,\n    vaultPath\n  } = params;\n\n  const captured = await evalInObsidian(normalizeOptionalProperties<EvalInObsidianParams<WriteInput, CapturedValue>>({\n    callback({\n      app,\n      configKey: key,\n      value: newValue\n    }): CapturedValue {\n      // `config` carries ONLY the keys changed from their default, which is what\n      // makes it the presence signal; `getConfig` substitutes the default and so\n      // cannot tell an unset key from one set to that default. The value itself\n      // still comes from `getConfig`, which returns the stored one whenever\n      // there is one \u2014 so the read needs no cast of the config object.\n      const isPresent = Object.hasOwn(app.vault.config, key);\n\n      const getConfig = app.vault.getConfig.bind(app.vault) as (configKey: string) => unknown;\n      const previousValue = isPresent ? getConfig(key) : undefined;\n\n      const setConfig = app.vault.setConfig.bind(app.vault) as (configKey: string, value: unknown) => void;\n      setConfig(key, newValue);\n\n      return {\n        isPresent,\n        value: previousValue\n      };\n    },\n    input: {\n      configKey,\n      value\n    },\n    transport,\n    vaultPath\n  }));\n\n  return normalizeOptionalProperties<AppConfigRestore>({\n    configKey,\n    isPresent: captured.isPresent,\n    transport,\n    value: captured.value,\n    vaultPath\n  });\n}\n\n/**\n * Runs work with a vault config key temporarily set, and puts the key back\n * afterwards \u2014 on a throw as much as on a return.\n *\n * The shape a popout-subject test wants:\n *\n * ```ts\n * await withAppConfig({\n *   async callback() {\n *     await evalInObsidian({ ... }); // the settings window is a popout in here\n *   },\n *   configKey: 'settingsPopoutWindow',\n *   value: true,\n *   vaultPath\n * });\n * ```\n *\n * The callback runs on the **Node** side, so it is free to make several evals,\n * take a screenshot, or assert between them.\n *\n * @typeParam T - What the wrapped work returns.\n * @param params - The key, the value to hold it at, the work, and transport /\n *   vault overrides.\n * @returns A {@link Promise} resolving to whatever the callback returned.\n */\nexport async function withAppConfig<T>(params: WithAppConfigParams<T>): Promise<T> {\n  const {\n    callback,\n    configKey,\n    transport,\n    value,\n    vaultPath\n  } = params;\n\n  const restore = await setAppConfig(normalizeOptionalProperties<SetAppConfigParams>({\n    configKey,\n    transport,\n    value,\n    vaultPath\n  }));\n\n  try {\n    return await callback();\n  } finally {\n    await restoreAppConfig(restore);\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AA0DA,SAAS,sBAAsB;AAC/B,SAAS,mCAAmC;AAmI5C,eAAsB,aAAa,QAA2C;AAC5E,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,SAAO,MAAM,eAAe,4BAAsE;AAAA,IAChG,SAAS,EAAE,KAAK,WAAW,IAAI,GAAY;AACzC,YAAM,YAAY,IAAI,MAAM,UAAU,KAAK,IAAI,KAAK;AACpD,aAAO,UAAU,GAAG;AAAA,IACtB;AAAA,IACA,OAAO,EAAE,UAAU;AAAA,IACnB;AAAA,IACA;AAAA,EACF,CAAC,CAAC;AACJ;AAaA,eAAsB,iBAAiB,SAA0C;AAC/E,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,eAAe,4BAA2E;AAAA,IAC9F,SAAS;AAAA,MACP;AAAA,MACA,WAAW;AAAA,MACX,WAAW;AAAA,MACX,OAAO;AAAA,IACT,GAAc;AACZ,YAAM,YAAY,IAAI,MAAM,UAAU,KAAK,IAAI,KAAK;AAIpD,gBAAU,KAAK,aAAa,gBAAgB,MAAS;AAAA,IACvD;AAAA,IACA,OAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC,CAAC;AACJ;AAgBA,eAAsB,aAAa,QAAuD;AACxF,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,WAAW,MAAM,eAAe,4BAA6E;AAAA,IACjH,SAAS;AAAA,MACP;AAAA,MACA,WAAW;AAAA,MACX,OAAO;AAAA,IACT,GAAkB;AAMhB,YAAM,YAAY,OAAO,OAAO,IAAI,MAAM,QAAQ,GAAG;AAErD,YAAM,YAAY,IAAI,MAAM,UAAU,KAAK,IAAI,KAAK;AACpD,YAAM,gBAAgB,YAAY,UAAU,GAAG,IAAI;AAEnD,YAAM,YAAY,IAAI,MAAM,UAAU,KAAK,IAAI,KAAK;AACpD,gBAAU,KAAK,QAAQ;AAEvB,aAAO;AAAA,QACL;AAAA,QACA,OAAO;AAAA,MACT;AAAA,IACF;AAAA,IACA,OAAO;AAAA,MACL;AAAA,MACA;AAAA,IACF;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC,CAAC;AAEF,SAAO,4BAA8C;AAAA,IACnD;AAAA,IACA,WAAW,SAAS;AAAA,IACpB;AAAA,IACA,OAAO,SAAS;AAAA,IAChB;AAAA,EACF,CAAC;AACH;AA2BA,eAAsB,cAAiB,QAA4C;AACjF,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,UAAU,MAAM,aAAa,4BAAgD;AAAA,IACjF;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC,CAAC;AAEF,MAAI;AACF,WAAO,MAAM,SAAS;AAAA,EACxB,UAAE;AACA,UAAM,iBAAiB,OAAO;AAAA,EAChC;AACF;",
  "names": []
}


package/dist/lib/esm/appium-dependencies.mjs

@@ -19,4 +19,4 @@ export {
   checkIsAppiumDriverInstalled,
   willAutoInstallAppiumDependencies
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/appium-session-config.d.mts

@@ -12,15 +12,6 @@ import type { ObsidianAndroidAppiumTransportOptions } from './transport-options.
  * Default for {@link ObsidianAndroidAppiumTransportOptions.appiumStartTimeoutInMilliseconds}.
  */
 export declare const DEFAULT_APPIUM_START_TIMEOUT_IN_MILLISECONDS = 180000;
-/**
- * Default for {@link ObsidianAndroidAppiumTransportOptions.scriptTimeoutInMilliseconds}.
- *
- * The same 30s WebDriver would nominally apply, stated here so the cap is a
- * declared number rather than an invisible protocol default — and, since the
- * protocol default was measured not to be applied at all on this driver, the
- * only number that actually bounds an Android eval.
- */
-export declare const DEFAULT_SCRIPT_TIMEOUT_IN_MILLISECONDS = 30000;
 /**
  * Default for {@link ObsidianAndroidAppiumTransportOptions.sessionConnectionRetryTimeoutInMilliseconds}.
  */
@@ -48,6 +39,12 @@ export declare function resolveAppiumStartTimeoutInMilliseconds(options: Obsidia
  * a closure times out: the closure is what should get shorter, with the waiting
  * moved to Node via `pollInObsidian`.
  *
+ * The default is {@link DEFAULT_EVAL_CAP_IN_MILLISECONDS}, the shared per-eval
+ * cap, rather than an Android-specific number: the protocol default WebDriver
+ * would nominally apply was measured not to be applied at all on this driver, so
+ * this is the only number that actually bounds an Android eval — which makes it
+ * the same policy the desktop transport enforces, not a coincidence.
+ *
  * @param options - The Android Appium transport options.
  * @returns The timeout in milliseconds.
  */

package/dist/lib/esm/appium-session-config.mjs

@@ -1,21 +1,20 @@
+import { DEFAULT_EVAL_CAP_IN_MILLISECONDS } from "./eval-cap.mjs";
 const DEFAULT_APPIUM_START_TIMEOUT_IN_MILLISECONDS = 18e4;
-const DEFAULT_SCRIPT_TIMEOUT_IN_MILLISECONDS = 3e4;
 const DEFAULT_SESSION_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS = 18e4;
 function resolveAppiumStartTimeoutInMilliseconds(options) {
   return options.appiumStartTimeoutInMilliseconds ?? DEFAULT_APPIUM_START_TIMEOUT_IN_MILLISECONDS;
 }
 function resolveScriptTimeoutInMilliseconds(options) {
-  return options.scriptTimeoutInMilliseconds ?? DEFAULT_SCRIPT_TIMEOUT_IN_MILLISECONDS;
+  return options.scriptTimeoutInMilliseconds ?? DEFAULT_EVAL_CAP_IN_MILLISECONDS;
 }
 function resolveSessionConnectionRetryTimeoutInMilliseconds(options) {
   return options.sessionConnectionRetryTimeoutInMilliseconds ?? DEFAULT_SESSION_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS;
 }
 export {
   DEFAULT_APPIUM_START_TIMEOUT_IN_MILLISECONDS,
-  DEFAULT_SCRIPT_TIMEOUT_IN_MILLISECONDS,
   DEFAULT_SESSION_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS,
   resolveAppiumStartTimeoutInMilliseconds,
   resolveScriptTimeoutInMilliseconds,
   resolveSessionConnectionRetryTimeoutInMilliseconds
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/connect-to-cdp.d.mts

@@ -117,6 +117,11 @@ export interface ConnectToCdpOptions {
     /**
      * Timeout in milliseconds for individual CDP commands.
      *
+     * A test's closure travels as one `Runtime.evaluate` command, so this is also
+     * the desktop per-eval cap. The default is `DEFAULT_EVAL_CAP_IN_MILLISECONDS`,
+     * exported from the package root — import it rather than restating the number,
+     * so a closure sized against the cap follows it if it ever moves.
+     *
      * @default `30000`
      */
     readonly commandTimeoutInMilliseconds?: number;