obsidian-integration-testing 6.0.0 → 7.0.0

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

@@ -1,16 +1,34 @@
 /**
  * @file
  *
- * Resolves tunable Appium session-establishment timeouts from the transport
- * options, applying defaults. Kept separate from the integration-only
- * `transport-factory` so the default resolution stays unit-testable (the
- * factory itself needs a real Appium server and is excluded from unit tests).
+ * Resolves tunable Appium server-start and session-establishment timeouts from
+ * the transport options, applying defaults. Kept separate from the
+ * integration-only `transport-factory` so the default resolution stays
+ * unit-testable (the factory itself needs a real Appium server and is excluded
+ * from unit tests).
  */
 import type { ObsidianAndroidAppiumTransportOptions } from './transport-options.mjs';
+/**
+ * Default for {@link ObsidianAndroidAppiumTransportOptions.appiumStartTimeoutInMilliseconds}.
+ */
+export declare const DEFAULT_APPIUM_START_TIMEOUT_IN_MILLISECONDS = 180000;
 /**
  * Default for {@link ObsidianAndroidAppiumTransportOptions.sessionConnectionRetryTimeoutInMilliseconds}.
  */
 export declare const DEFAULT_SESSION_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS = 180000;
+/**
+ * Resolves the auto-started Appium server readiness timeout, applying the
+ * default when the option is omitted.
+ *
+ * This governs how long the factory polls the auto-started Appium server's
+ * `/status` endpoint before giving up. Only relevant when the harness
+ * auto-starts the server; when attaching to an already-running server the wait
+ * is skipped entirely.
+ *
+ * @param options - The Android Appium transport options.
+ * @returns The timeout in milliseconds.
+ */
+export declare function resolveAppiumStartTimeoutInMilliseconds(options: ObsidianAndroidAppiumTransportOptions): number;
 /**
  * Resolves the Appium session connection retry timeout, applying the default
  * when the option is omitted.

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

@@ -1,9 +1,15 @@
+const DEFAULT_APPIUM_START_TIMEOUT_IN_MILLISECONDS = 18e4;
 const DEFAULT_SESSION_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS = 18e4;
+function resolveAppiumStartTimeoutInMilliseconds(options) {
+  return options.appiumStartTimeoutInMilliseconds ?? DEFAULT_APPIUM_START_TIMEOUT_IN_MILLISECONDS;
+}
 function resolveSessionConnectionRetryTimeoutInMilliseconds(options) {
   return options.sessionConnectionRetryTimeoutInMilliseconds ?? DEFAULT_SESSION_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS;
 }
 export {
+  DEFAULT_APPIUM_START_TIMEOUT_IN_MILLISECONDS,
   DEFAULT_SESSION_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS,
+  resolveAppiumStartTimeoutInMilliseconds,
   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

@@ -6,7 +6,7 @@
  *
  * A single {@link connectToCdp} call resolves the owned-instance config, opens a
  * vault, and bootstraps `window.__obsidianIntegrationTesting` (so `evalWrapper`,
- * `typeIntoEditor`, `serializeError`, `getObsidianModule`, … are available), then
+ * the base `lib` helpers, `serializeError`, `getObsidianModule`, … are available), then
  * hands back a disposable {@link CdpConnection} exposing the chosen CDP port, a
  * raw {@link CdpConnection.invoke} and the rich {@link CdpConnection.evalInObsidian}.
  */
@@ -38,9 +38,10 @@ export interface CdpConnection extends AsyncDisposable {
     dispose(): Promise<void>;
     /**
      * Evaluates a self-contained function inside Obsidian via the rich helper
-     * path, receiving `{ app, obsidianModule, typeIntoEditor, context }` plus any
-     * `args`. Mirrors the top-level `evalInObsidian`, with the transport and vault
-     * path pre-bound to this connection.
+     * path, receiving `{ app, lib, obsidianModule, context }` plus any `args`
+     * (shared helpers like `typeIntoEditor` / `waitUntil` live on `lib`). Mirrors
+     * the top-level `evalInObsidian`, with the transport and vault path pre-bound
+     * to this connection.
      *
      * @param params - The evaluation parameters (`fn`, optional `args`/`contextId`).
      * @returns A {@link Promise} that resolves to the return value of `fn`.

package/dist/lib/esm/connect-to-cdp.mjs

@@ -61,4 +61,4 @@ function resolveEndpoint(transport, options) {
 export {
   connectToCdp
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/connect-to-cdp.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Programmatic helper to launch (or attach to) a CDP-enabled Obsidian instance\n * with the runtime helper namespace bootstrapped, for ad-hoc real-app debugging.\n *\n * A single {@link connectToCdp} call resolves the owned-instance config, opens a\n * vault, and bootstraps `window.__obsidianIntegrationTesting` (so `evalWrapper`,\n * `typeIntoEditor`, `serializeError`, `getObsidianModule`, \u2026 are available), then\n * hands back a disposable {@link CdpConnection} exposing the chosen CDP port, a\n * raw {@link CdpConnection.invoke} and the rich {@link CdpConnection.evalInObsidian}.\n */\n\n/* v8 ignore start -- Integration-time code (launches Obsidian / CDP) covered by integration tests, not unit tests. */\n\nimport type { Except } from 'type-fest';\n\nimport type { ContextId } from './context-id.mjs';\nimport type {\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.mjs';\nimport type { ObsidianCdpTransportOptions } from './transport-options.mjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.mjs';\nimport { TempVault } from './temp-vault.mjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nimport { createTransportFromOptions } from './transport-factory.mjs';\n\nconst DEFAULT_CDP_HOST = 'localhost';\n\n/**\n * A live connection to a CDP-enabled Obsidian instance with the runtime helper\n * namespace bootstrapped.\n *\n * Implements `AsyncDisposable`, so `await using conn = await connectToCdp(\u2026)`\n * disposes it (killing an owned instance and \u2014 for a throw-away temp vault \u2014\n * removing its directory) automatically.\n */\nexport interface CdpConnection extends AsyncDisposable {\n  /**\n   * The base CDP URL, e.g. `http://localhost:51888`.\n   */\n  readonly cdpUrl: string;\n\n  /**\n   * Disposes the connection: kills an owned instance and removes its isolated\n   * user-data dir. The vault directory is removed only when it is a throw-away\n   * temp vault (see {@link ConnectToCdpOptions.shouldRemoveVaultOnDispose}); a\n   * real vault passed via {@link ConnectToCdpOptions.vault} is never deleted.\n   *\n   * @returns A {@link Promise} that resolves once disposal completes.\n   */\n  dispose(): Promise<void>;\n\n  /**\n   * Evaluates a self-contained function inside Obsidian via the rich helper\n   * path, receiving `{ app, obsidianModule, typeIntoEditor, context }` plus any\n   * `args`. Mirrors the top-level `evalInObsidian`, with the transport and vault\n   * path pre-bound to this connection.\n   *\n   * @param params - The evaluation parameters (`fn`, optional `args`/`contextId`).\n   * @returns A {@link Promise} that resolves to the return value of `fn`.\n   */\n  evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n    params: Except<EvalInObsidianParams<Args, Result, TContextId>, 'transport' | 'vaultPath'>\n  ): Promise<Result>;\n\n  /**\n   * Evaluates a raw JavaScript expression inside Obsidian and returns the\n   * normalized string result (e.g. `'5'`, a JSON string, or `'(no output)'`).\n   *\n   * @param expression - A self-contained JavaScript expression.\n   * @returns A {@link Promise} that resolves to the raw result string.\n   */\n  invoke(expression: string): Promise<string>;\n\n  /**\n   * The CDP port the instance is reachable on (the free port chosen for an\n   * owned instance, or the attached {@link ConnectToCdpOptions.port}).\n   */\n  readonly port: number;\n\n  /**\n   * The opened vault. Exposes `path` and `populate(...)` for seeding files.\n   */\n  readonly vault: TempVault;\n}\n\n/**\n * Options for {@link connectToCdp}.\n */\nexport interface ConnectToCdpOptions {\n  /**\n   * Timeout in milliseconds for individual CDP commands.\n   *\n   * @default `30000`\n   */\n  readonly commandTimeoutInMilliseconds?: number;\n\n  /**\n   * CDP host.\n   *\n   * @default `'localhost'`\n   */\n  readonly host?: string;\n\n  /**\n   * Whether the Obsidian window is shown on screen. Unlike the test transports\n   * (hidden by default), `connectToCdp` **defaults to `true`** \u2014 it is meant for\n   * watching/debugging a real Obsidian. Set `false` to launch it off-screen.\n   * Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly isObsidianAppVisible?: boolean;\n\n  /**\n   * Pins the Electron shell (installer build) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed shell is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianInstallerVersion?: string;\n\n  /**\n   * Pins the Obsidian app version (asar) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed version is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianVersion?: string;\n\n  /**\n   * CDP port of an already-running Obsidian to **attach** to. When omitted, an\n   * isolated instance is launched on an automatically chosen free port.\n   *\n   * @default `undefined`\n   */\n  readonly port?: number;\n\n  /**\n   * Whether to remove the vault directory on {@link CdpConnection.dispose}.\n   *\n   * When omitted, defaults to `true` for an implicit throw-away temp vault\n   * ({@link vault} not given) and `false` when a {@link vault} path is given, so\n   * a real vault is never deleted. Set explicitly to override.\n   */\n  readonly shouldRemoveVaultOnDispose?: boolean;\n\n  /**\n   * Absolute path to an existing vault to open. When omitted, an empty temporary\n   * vault is created (and removed on dispose unless\n   * {@link shouldRemoveVaultOnDispose} says otherwise).\n   *\n   * @default `undefined`\n   */\n  readonly vault?: string;\n}\n\n/**\n * A resolved CDP host/port pair.\n */\ninterface ResolvedEndpoint {\n  host: string;\n  port: number;\n}\n\n/**\n * Launches (or attaches to) a CDP-enabled Obsidian instance, opens a vault, and\n * bootstraps the runtime helper namespace, returning a disposable connection.\n *\n * @param options - Connection options.\n * @returns A {@link Promise} that resolves to the live {@link CdpConnection}.\n */\nexport async function connectToCdp(options?: ConnectToCdpOptions): Promise<CdpConnection> {\n  const transportOptions: ObsidianCdpTransportOptions = {\n    isObsidianAppVisible: options?.isObsidianAppVisible ?? true,\n    type: 'obsidian-cdp',\n    ...(options?.commandTimeoutInMilliseconds !== undefined && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds }),\n    ...(options?.host !== undefined && { host: options.host }),\n    ...(options?.obsidianInstallerVersion !== undefined && { obsidianInstallerVersion: options.obsidianInstallerVersion }),\n    ...(options?.obsidianVersion !== undefined && { obsidianVersion: options.obsidianVersion }),\n    ...(options?.port !== undefined && { port: options.port })\n  };\n\n  const transport = await createTransportFromOptions(transportOptions);\n  const vault = new TempVault(options?.vault);\n  const shouldRemoveVaultOnDispose = options?.shouldRemoveVaultOnDispose ?? (options?.vault === undefined);\n\n  // Registering the vault is what launches the owned instance (provisions the\n  // Asar, opens the vault, and bootstraps the helper namespace), or opens the\n  // Vault in the attached instance.\n  await vault.register(transport);\n\n  const { host, port } = resolveEndpoint(transport, options);\n  const cdpUrl = `http://${host}:${String(port)}`;\n\n  const connection: CdpConnection = {\n    cdpUrl,\n\n    async dispose(): Promise<void> {\n      try {\n        if (shouldRemoveVaultOnDispose) {\n          await vault.dispose(transport);\n        } else {\n          await transport.unregisterVault(vault.path);\n        }\n      } finally {\n        await transport.dispose?.();\n      }\n    },\n\n    async evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n      params: Except<EvalInObsidianParams<Args, Result, TContextId>, 'transport' | 'vaultPath'>\n    ): Promise<Result> {\n      return evalInObsidian<Args, Result, TContextId>({ ...params, transport, vaultPath: vault.path });\n    },\n\n    async invoke(expression: string): Promise<string> {\n      return transport.evaluate(expression, { cwd: vault.path });\n    },\n\n    port,\n\n    async [Symbol.asyncDispose](): Promise<void> {\n      await connection.dispose();\n    },\n\n    vault\n  };\n\n  return connection;\n}\n\n/**\n * Resolves the CDP host/port for the connection: from the owned instance's\n * launched endpoint when present, otherwise from the attach options.\n *\n * @param transport - The transport created for this connection.\n * @param options - The connection options.\n * @returns The resolved host and port.\n * @throws Error if the port cannot be determined.\n */\nfunction resolveEndpoint(transport: unknown, options: ConnectToCdpOptions | undefined): ResolvedEndpoint {\n  if (transport instanceof DesktopCdpTransport) {\n    const endpoint = transport.getOwnedInstanceEndpoint();\n    if (endpoint) {\n      return { host: endpoint.host, port: endpoint.port };\n    }\n  }\n\n  if (options?.port !== undefined) {\n    return { host: options.host ?? DEFAULT_CDP_HOST, port: options.port };\n  }\n\n  throw new Error('connectToCdp: could not determine the CDP port.');\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AAwBA,SAAS,sBAAsB;AAC/B,SAAS,iBAAiB;AAC1B,SAAS,2BAA2B;AACpC,SAAS,kCAAkC;AAE3C,MAAM,mBAAmB;AAoJzB,eAAsB,aAAa,SAAuD;AACxF,QAAM,mBAAgD;AAAA,IACpD,sBAAsB,SAAS,wBAAwB;AAAA,IACvD,MAAM;AAAA,IACN,GAAI,SAAS,iCAAiC,UAAa,EAAE,8BAA8B,QAAQ,6BAA6B;AAAA,IAChI,GAAI,SAAS,SAAS,UAAa,EAAE,MAAM,QAAQ,KAAK;AAAA,IACxD,GAAI,SAAS,6BAA6B,UAAa,EAAE,0BAA0B,QAAQ,yBAAyB;AAAA,IACpH,GAAI,SAAS,oBAAoB,UAAa,EAAE,iBAAiB,QAAQ,gBAAgB;AAAA,IACzF,GAAI,SAAS,SAAS,UAAa,EAAE,MAAM,QAAQ,KAAK;AAAA,EAC1D;AAEA,QAAM,YAAY,MAAM,2BAA2B,gBAAgB;AACnE,QAAM,QAAQ,IAAI,UAAU,SAAS,KAAK;AAC1C,QAAM,6BAA6B,SAAS,8BAA+B,SAAS,UAAU;AAK9F,QAAM,MAAM,SAAS,SAAS;AAE9B,QAAM,EAAE,MAAM,KAAK,IAAI,gBAAgB,WAAW,OAAO;AACzD,QAAM,SAAS,UAAU,IAAI,IAAI,OAAO,IAAI,CAAC;AAE7C,QAAM,aAA4B;AAAA,IAChC;AAAA,IAEA,MAAM,UAAyB;AAC7B,UAAI;AACF,YAAI,4BAA4B;AAC9B,gBAAM,MAAM,QAAQ,SAAS;AAAA,QAC/B,OAAO;AACL,gBAAM,UAAU,gBAAgB,MAAM,IAAI;AAAA,QAC5C;AAAA,MACF,UAAE;AACA,cAAM,UAAU,UAAU;AAAA,MAC5B;AAAA,IACF;AAAA,IAEA,MAAM,eACJ,QACiB;AACjB,aAAO,eAAyC,EAAE,GAAG,QAAQ,WAAW,WAAW,MAAM,KAAK,CAAC;AAAA,IACjG;AAAA,IAEA,MAAM,OAAO,YAAqC;AAChD,aAAO,UAAU,SAAS,YAAY,EAAE,KAAK,MAAM,KAAK,CAAC;AAAA,IAC3D;AAAA,IAEA;AAAA,IAEA,OAAO,OAAO,YAAY,IAAmB;AAC3C,YAAM,WAAW,QAAQ;AAAA,IAC3B;AAAA,IAEA;AAAA,EACF;AAEA,SAAO;AACT;AAWA,SAAS,gBAAgB,WAAoB,SAA4D;AACvG,MAAI,qBAAqB,qBAAqB;AAC5C,UAAM,WAAW,UAAU,yBAAyB;AACpD,QAAI,UAAU;AACZ,aAAO,EAAE,MAAM,SAAS,MAAM,MAAM,SAAS,KAAK;AAAA,IACpD;AAAA,EACF;AAEA,MAAI,SAAS,SAAS,QAAW;AAC/B,WAAO,EAAE,MAAM,QAAQ,QAAQ,kBAAkB,MAAM,QAAQ,KAAK;AAAA,EACtE;AAEA,QAAM,IAAI,MAAM,iDAAiD;AACnE;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/connect-to-cdp.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Programmatic helper to launch (or attach to) a CDP-enabled Obsidian instance\n * with the runtime helper namespace bootstrapped, for ad-hoc real-app debugging.\n *\n * A single {@link connectToCdp} call resolves the owned-instance config, opens a\n * vault, and bootstraps `window.__obsidianIntegrationTesting` (so `evalWrapper`,\n * the base `lib` helpers, `serializeError`, `getObsidianModule`, \u2026 are available), then\n * hands back a disposable {@link CdpConnection} exposing the chosen CDP port, a\n * raw {@link CdpConnection.invoke} and the rich {@link CdpConnection.evalInObsidian}.\n */\n\n/* v8 ignore start -- Integration-time code (launches Obsidian / CDP) covered by integration tests, not unit tests. */\n\nimport type { Except } from 'type-fest';\n\nimport type { ContextId } from './context-id.mjs';\nimport type {\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.mjs';\nimport type { ObsidianCdpTransportOptions } from './transport-options.mjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.mjs';\nimport { TempVault } from './temp-vault.mjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nimport { createTransportFromOptions } from './transport-factory.mjs';\n\nconst DEFAULT_CDP_HOST = 'localhost';\n\n/**\n * A live connection to a CDP-enabled Obsidian instance with the runtime helper\n * namespace bootstrapped.\n *\n * Implements `AsyncDisposable`, so `await using conn = await connectToCdp(\u2026)`\n * disposes it (killing an owned instance and \u2014 for a throw-away temp vault \u2014\n * removing its directory) automatically.\n */\nexport interface CdpConnection extends AsyncDisposable {\n  /**\n   * The base CDP URL, e.g. `http://localhost:51888`.\n   */\n  readonly cdpUrl: string;\n\n  /**\n   * Disposes the connection: kills an owned instance and removes its isolated\n   * user-data dir. The vault directory is removed only when it is a throw-away\n   * temp vault (see {@link ConnectToCdpOptions.shouldRemoveVaultOnDispose}); a\n   * real vault passed via {@link ConnectToCdpOptions.vault} is never deleted.\n   *\n   * @returns A {@link Promise} that resolves once disposal completes.\n   */\n  dispose(): Promise<void>;\n\n  /**\n   * Evaluates a self-contained function inside Obsidian via the rich helper\n   * path, receiving `{ app, lib, obsidianModule, context }` plus any `args`\n   * (shared helpers like `typeIntoEditor` / `waitUntil` live on `lib`). Mirrors\n   * the top-level `evalInObsidian`, with the transport and vault path pre-bound\n   * to this connection.\n   *\n   * @param params - The evaluation parameters (`fn`, optional `args`/`contextId`).\n   * @returns A {@link Promise} that resolves to the return value of `fn`.\n   */\n  evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n    params: Except<EvalInObsidianParams<Args, Result, TContextId>, 'transport' | 'vaultPath'>\n  ): Promise<Result>;\n\n  /**\n   * Evaluates a raw JavaScript expression inside Obsidian and returns the\n   * normalized string result (e.g. `'5'`, a JSON string, or `'(no output)'`).\n   *\n   * @param expression - A self-contained JavaScript expression.\n   * @returns A {@link Promise} that resolves to the raw result string.\n   */\n  invoke(expression: string): Promise<string>;\n\n  /**\n   * The CDP port the instance is reachable on (the free port chosen for an\n   * owned instance, or the attached {@link ConnectToCdpOptions.port}).\n   */\n  readonly port: number;\n\n  /**\n   * The opened vault. Exposes `path` and `populate(...)` for seeding files.\n   */\n  readonly vault: TempVault;\n}\n\n/**\n * Options for {@link connectToCdp}.\n */\nexport interface ConnectToCdpOptions {\n  /**\n   * Timeout in milliseconds for individual CDP commands.\n   *\n   * @default `30000`\n   */\n  readonly commandTimeoutInMilliseconds?: number;\n\n  /**\n   * CDP host.\n   *\n   * @default `'localhost'`\n   */\n  readonly host?: string;\n\n  /**\n   * Whether the Obsidian window is shown on screen. Unlike the test transports\n   * (hidden by default), `connectToCdp` **defaults to `true`** \u2014 it is meant for\n   * watching/debugging a real Obsidian. Set `false` to launch it off-screen.\n   * Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly isObsidianAppVisible?: boolean;\n\n  /**\n   * Pins the Electron shell (installer build) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed shell is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianInstallerVersion?: string;\n\n  /**\n   * Pins the Obsidian app version (asar) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed version is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianVersion?: string;\n\n  /**\n   * CDP port of an already-running Obsidian to **attach** to. When omitted, an\n   * isolated instance is launched on an automatically chosen free port.\n   *\n   * @default `undefined`\n   */\n  readonly port?: number;\n\n  /**\n   * Whether to remove the vault directory on {@link CdpConnection.dispose}.\n   *\n   * When omitted, defaults to `true` for an implicit throw-away temp vault\n   * ({@link vault} not given) and `false` when a {@link vault} path is given, so\n   * a real vault is never deleted. Set explicitly to override.\n   */\n  readonly shouldRemoveVaultOnDispose?: boolean;\n\n  /**\n   * Absolute path to an existing vault to open. When omitted, an empty temporary\n   * vault is created (and removed on dispose unless\n   * {@link shouldRemoveVaultOnDispose} says otherwise).\n   *\n   * @default `undefined`\n   */\n  readonly vault?: string;\n}\n\n/**\n * A resolved CDP host/port pair.\n */\ninterface ResolvedEndpoint {\n  host: string;\n  port: number;\n}\n\n/**\n * Launches (or attaches to) a CDP-enabled Obsidian instance, opens a vault, and\n * bootstraps the runtime helper namespace, returning a disposable connection.\n *\n * @param options - Connection options.\n * @returns A {@link Promise} that resolves to the live {@link CdpConnection}.\n */\nexport async function connectToCdp(options?: ConnectToCdpOptions): Promise<CdpConnection> {\n  const transportOptions: ObsidianCdpTransportOptions = {\n    isObsidianAppVisible: options?.isObsidianAppVisible ?? true,\n    type: 'obsidian-cdp',\n    ...(options?.commandTimeoutInMilliseconds !== undefined && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds }),\n    ...(options?.host !== undefined && { host: options.host }),\n    ...(options?.obsidianInstallerVersion !== undefined && { obsidianInstallerVersion: options.obsidianInstallerVersion }),\n    ...(options?.obsidianVersion !== undefined && { obsidianVersion: options.obsidianVersion }),\n    ...(options?.port !== undefined && { port: options.port })\n  };\n\n  const transport = await createTransportFromOptions(transportOptions);\n  const vault = new TempVault(options?.vault);\n  const shouldRemoveVaultOnDispose = options?.shouldRemoveVaultOnDispose ?? (options?.vault === undefined);\n\n  // Registering the vault is what launches the owned instance (provisions the\n  // Asar, opens the vault, and bootstraps the helper namespace), or opens the\n  // Vault in the attached instance.\n  await vault.register(transport);\n\n  const { host, port } = resolveEndpoint(transport, options);\n  const cdpUrl = `http://${host}:${String(port)}`;\n\n  const connection: CdpConnection = {\n    cdpUrl,\n\n    async dispose(): Promise<void> {\n      try {\n        if (shouldRemoveVaultOnDispose) {\n          await vault.dispose(transport);\n        } else {\n          await transport.unregisterVault(vault.path);\n        }\n      } finally {\n        await transport.dispose?.();\n      }\n    },\n\n    async evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n      params: Except<EvalInObsidianParams<Args, Result, TContextId>, 'transport' | 'vaultPath'>\n    ): Promise<Result> {\n      return evalInObsidian<Args, Result, TContextId>({ ...params, transport, vaultPath: vault.path });\n    },\n\n    async invoke(expression: string): Promise<string> {\n      return transport.evaluate(expression, { cwd: vault.path });\n    },\n\n    port,\n\n    async [Symbol.asyncDispose](): Promise<void> {\n      await connection.dispose();\n    },\n\n    vault\n  };\n\n  return connection;\n}\n\n/**\n * Resolves the CDP host/port for the connection: from the owned instance's\n * launched endpoint when present, otherwise from the attach options.\n *\n * @param transport - The transport created for this connection.\n * @param options - The connection options.\n * @returns The resolved host and port.\n * @throws Error if the port cannot be determined.\n */\nfunction resolveEndpoint(transport: unknown, options: ConnectToCdpOptions | undefined): ResolvedEndpoint {\n  if (transport instanceof DesktopCdpTransport) {\n    const endpoint = transport.getOwnedInstanceEndpoint();\n    if (endpoint) {\n      return { host: endpoint.host, port: endpoint.port };\n    }\n  }\n\n  if (options?.port !== undefined) {\n    return { host: options.host ?? DEFAULT_CDP_HOST, port: options.port };\n  }\n\n  throw new Error('connectToCdp: could not determine the CDP port.');\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AAwBA,SAAS,sBAAsB;AAC/B,SAAS,iBAAiB;AAC1B,SAAS,2BAA2B;AACpC,SAAS,kCAAkC;AAE3C,MAAM,mBAAmB;AAqJzB,eAAsB,aAAa,SAAuD;AACxF,QAAM,mBAAgD;AAAA,IACpD,sBAAsB,SAAS,wBAAwB;AAAA,IACvD,MAAM;AAAA,IACN,GAAI,SAAS,iCAAiC,UAAa,EAAE,8BAA8B,QAAQ,6BAA6B;AAAA,IAChI,GAAI,SAAS,SAAS,UAAa,EAAE,MAAM,QAAQ,KAAK;AAAA,IACxD,GAAI,SAAS,6BAA6B,UAAa,EAAE,0BAA0B,QAAQ,yBAAyB;AAAA,IACpH,GAAI,SAAS,oBAAoB,UAAa,EAAE,iBAAiB,QAAQ,gBAAgB;AAAA,IACzF,GAAI,SAAS,SAAS,UAAa,EAAE,MAAM,QAAQ,KAAK;AAAA,EAC1D;AAEA,QAAM,YAAY,MAAM,2BAA2B,gBAAgB;AACnE,QAAM,QAAQ,IAAI,UAAU,SAAS,KAAK;AAC1C,QAAM,6BAA6B,SAAS,8BAA+B,SAAS,UAAU;AAK9F,QAAM,MAAM,SAAS,SAAS;AAE9B,QAAM,EAAE,MAAM,KAAK,IAAI,gBAAgB,WAAW,OAAO;AACzD,QAAM,SAAS,UAAU,IAAI,IAAI,OAAO,IAAI,CAAC;AAE7C,QAAM,aAA4B;AAAA,IAChC;AAAA,IAEA,MAAM,UAAyB;AAC7B,UAAI;AACF,YAAI,4BAA4B;AAC9B,gBAAM,MAAM,QAAQ,SAAS;AAAA,QAC/B,OAAO;AACL,gBAAM,UAAU,gBAAgB,MAAM,IAAI;AAAA,QAC5C;AAAA,MACF,UAAE;AACA,cAAM,UAAU,UAAU;AAAA,MAC5B;AAAA,IACF;AAAA,IAEA,MAAM,eACJ,QACiB;AACjB,aAAO,eAAyC,EAAE,GAAG,QAAQ,WAAW,WAAW,MAAM,KAAK,CAAC;AAAA,IACjG;AAAA,IAEA,MAAM,OAAO,YAAqC;AAChD,aAAO,UAAU,SAAS,YAAY,EAAE,KAAK,MAAM,KAAK,CAAC;AAAA,IAC3D;AAAA,IAEA;AAAA,IAEA,OAAO,OAAO,YAAY,IAAmB;AAC3C,YAAM,WAAW,QAAQ;AAAA,IAC3B;AAAA,IAEA;AAAA,EACF;AAEA,SAAO;AACT;AAWA,SAAS,gBAAgB,WAAoB,SAA4D;AACvG,MAAI,qBAAqB,qBAAqB;AAC5C,UAAM,WAAW,UAAU,yBAAyB;AACpD,QAAI,UAAU;AACZ,aAAO,EAAE,MAAM,SAAS,MAAM,MAAM,SAAS,KAAK;AAAA,IACpD;AAAA,EACF;AAEA,MAAI,SAAS,SAAS,QAAW;AAC/B,WAAO,EAAE,MAAM,QAAQ,QAAQ,kBAAkB,MAAM,QAAQ,KAAK;AAAA,EACtE;AAEA,QAAM,IAAI,MAAM,iDAAiD;AACnE;",
  "names": []
}


package/dist/lib/esm/device-readiness.d.mts

@@ -0,0 +1,55 @@
+/**
+ * @file
+ *
+ * Pure helpers for deciding when a freshly-booted Android emulator is idle
+ * enough to establish an Appium session, plus resolving the idle-wait timeout
+ * from the transport options. Kept separate from the integration-only
+ * `transport-factory` so the parsing and default resolution stay unit-testable
+ * (the factory itself needs a real emulator and is excluded from unit tests).
+ *
+ * `sys.boot_completed` fires *before* the guest is actually idle: package
+ * optimization (`dex2oat`) and system services keep churning after it, so a
+ * session established the instant it fires makes every one of UiAutomator2's
+ * serialized `adb` round-trips contend with that work and inflate ~3x. Gating
+ * the session on a later, quieter signal (the boot animation has stopped and
+ * the package manager is serving) lets it run against an idle guest instead.
+ */
+import type { ObsidianAndroidAppiumTransportOptions } from './transport-options.mjs';
+/**
+ * Default for {@link ObsidianAndroidAppiumTransportOptions.deviceIdleTimeoutInMilliseconds}.
+ */
+export declare const DEFAULT_DEVICE_IDLE_TIMEOUT_IN_MILLISECONDS = 60000;
+/**
+ * Parameters for {@link checkDeviceIdle}.
+ */
+export interface CheckDeviceIdleParams {
+    /** Raw stdout of `adb shell getprop init.svc.bootanim`. */
+    readonly bootAnimationProp: string;
+    /** Raw stdout of `adb shell cmd package list packages`. */
+    readonly packageListOutput: string;
+}
+/**
+ * Decides whether a booted emulator is idle enough to start an Appium session,
+ * from the raw output of the two probe commands.
+ *
+ * The guest is considered idle once the boot animation has stopped **and** the
+ * package manager is serving (it lists at least one package). Both are binary,
+ * later-than-`sys.boot_completed` signals, so this returns `true` well after the
+ * premature boot-completed flag but without any latency thresholds.
+ *
+ * @param params - The sampled probe outputs.
+ * @returns `true` when the guest is idle enough to proceed.
+ */
+export declare function checkDeviceIdle(params: CheckDeviceIdleParams): boolean;
+/**
+ * Resolves the post-boot device-idle wait timeout, applying the default when
+ * the option is omitted.
+ *
+ * This bounds how long the factory waits for a freshly-started emulator to
+ * become idle (see {@link checkDeviceIdle}) before establishing the session. A
+ * value of `0` skips the wait entirely.
+ *
+ * @param options - The Android Appium transport options.
+ * @returns The timeout in milliseconds.
+ */
+export declare function resolveDeviceIdleTimeoutInMilliseconds(options: ObsidianAndroidAppiumTransportOptions): number;

package/dist/lib/esm/device-readiness.mjs

@@ -0,0 +1,17 @@
+const BOOT_ANIMATION_STOPPED_STATE = "stopped";
+const PACKAGE_LINE_PREFIX = "package:";
+const DEFAULT_DEVICE_IDLE_TIMEOUT_IN_MILLISECONDS = 6e4;
+function checkDeviceIdle(params) {
+  const isBootAnimationStopped = params.bootAnimationProp.trim() === BOOT_ANIMATION_STOPPED_STATE;
+  const isPackageManagerReady = params.packageListOutput.split("\n").some((line) => line.trim().startsWith(PACKAGE_LINE_PREFIX));
+  return isBootAnimationStopped && isPackageManagerReady;
+}
+function resolveDeviceIdleTimeoutInMilliseconds(options) {
+  return options.deviceIdleTimeoutInMilliseconds ?? DEFAULT_DEVICE_IDLE_TIMEOUT_IN_MILLISECONDS;
+}
+export {
+  DEFAULT_DEVICE_IDLE_TIMEOUT_IN_MILLISECONDS,
+  checkDeviceIdle,
+  resolveDeviceIdleTimeoutInMilliseconds
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/eval-in-obsidian.d.mts

@@ -16,17 +16,109 @@ export interface CommonArgs {
      * The Obsidian {@link App} instance.
      */
     app: App;
+    /**
+     * The shared library bag injected into every callback — see {@link Lib}.
+     *
+     * Never empty: the harness pre-populates a **base** set of renderer-driving
+     * helpers (trusted input — `typeIntoEditor` / `pressKey` / `moveMouse` /
+     * `hoverElement` / `unhoverElement` — and `waitUntil`), and provider packages
+     * (chiefly `obsidian-dev-utils`) `Object.assign` their whole renderer-safe
+     * library on top via {@link registerLibResolver}. A serialized closure reaches
+     * every shared helper through `lib` — `lib.typeIntoEditor({ editor, text })`,
+     * `lib.getFileOrNull({ app, … })` — instead of importing or hand-rolling them.
+     */
+    lib: Lib;
+    /**
+     * The `obsidian` module, resolved at runtime inside the Obsidian process.
+     */
+    obsidianModule: typeof obsidian;
+}
+/**
+ * Parameters for {@link evalInObsidian}.
+ */
+export interface EvalInObsidianParams<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined> {
+    /**
+     * Additional arguments to pass to the function. Values may include functions —
+     * they are serialized via `toString()`.
+     */
+    readonly args?: Args;
+    /**
+     * A {@link ContextId} linking this call to a persistent store on `window`
+     * in the Obsidian process. The callback receives a typed `context` object
+     * that survives across calls sharing the same ID.
+     *
+     * When omitted, `context` is a fresh empty object each call.
+     */
+    readonly contextId?: TContextId;
+    /**
+     * The function to evaluate in the Obsidian context.
+     */
+    fn(args: Args & CommonArgs & ContextArgs<TContextId>): Promisable<Result>;
+    /**
+     * Skips pre-flight checks (vault registration, CLI availability).
+     * Used internally by vault registration functions.
+     *
+     * @internal
+     */
+    readonly shouldSkipPreflightChecks?: boolean;
+    /**
+     * Override the transport for this call. When omitted, uses the transport
+     * configured via the context provider (set by the framework adapter's global setup).
+     */
+    readonly transport?: ObsidianTransport;
+    /**
+     * The path to the Obsidian vault. Defaults to `process.cwd()`.
+     */
+    readonly vaultPath?: string;
+}
+/**
+ * A plain object with string keys.
+ */
+export type GenericObject = Record<string, unknown>;
+/**
+ * Parameters for {@link CommonArgs.hoverElement}.
+ */
+export interface HoverElementParams {
+    /**
+     * The element to hover. The pointer is moved to its center. This is a live
+     * renderer DOM node — the callback runs in-renderer, so no cross-process
+     * serialization is needed (same as {@link TypeIntoEditorParams.editor}).
+     */
+    readonly element: HTMLElement;
+}
+/**
+ * The shared library bag injected into every {@link evalInObsidian} callback as
+ * {@link CommonArgs.lib}.
+ *
+ * Two layers compose into this one bag. The **base** — the harness-provided
+ * renderer-driving helpers declared below (the trusted-input primitives and
+ * {@link Lib.waitUntil}) — is always present. On top, provider packages register
+ * a renderer-side resolver via {@link registerLibResolver} to `Object.assign`
+ * their whole renderer-safe library at runtime, and augment this **augmentable**
+ * interface (the `i18next` `CustomTypeOptions` idiom) via
+ * `declare module 'obsidian-integration-testing'` to type it. Multiple providers
+ * compose: their exports merge at runtime and their augmentations merge in the
+ * type system (`interface Lib extends …`).
+ *
+ * @example
+ * ```ts
+ * declare module 'obsidian-integration-testing' {
+ *   interface Lib extends (typeof import('obsidian-dev-utils/__merged')) {}
+ * }
+ * ```
+ */
+export interface Lib {
     /**
      * Moves the mouse pointer to the center of an element using **trusted**
      * Electron pointer input, then polls until the element actually matches
      * `:hover`.
      *
-     * Because the move is trusted (see {@link CommonArgs.moveMouse}), the real
-     * `:hover` state takes effect in the CSS engine — real theme `var()` values
-     * and real compositing — instead of a hand-simulated cascade. It polls the
-     * live `element.matches(':hover')` state (not a fixed delay), so it is robust
-     * under shared-instance load. It targets the single shared window's
-     * **global** pointer, so only one element is hovered at a time.
+     * Because the move is trusted (see {@link Lib.moveMouse}), the real `:hover`
+     * state takes effect in the CSS engine — real theme `var()` values and real
+     * compositing — instead of a hand-simulated cascade. It polls the live
+     * `element.matches(':hover')` state (not a fixed delay), so it is robust under
+     * shared-instance load. It targets the single shared window's **global**
+     * pointer, so only one element is hovered at a time.
      *
      * @param params - The element to hover.
      * @returns A {@link Promise} that resolves once the element matches `:hover`.
@@ -44,41 +136,35 @@ export interface CommonArgs {
      *
      * This is the low-level primitive: it performs a single move and does **not**
      * wait for any state to settle (callers poll their own readiness signal).
-     * Prefer {@link CommonArgs.hoverElement} / {@link CommonArgs.unhoverElement}
-     * for element-relative moves; use `moveMouse` directly when an
-     * element-relative target does not fit (e.g. an element spanning the full
-     * viewport width).
+     * Prefer {@link Lib.hoverElement} / {@link Lib.unhoverElement} for
+     * element-relative moves; use `moveMouse` directly when an element-relative
+     * target does not fit (e.g. an element spanning the full viewport width).
      *
      * @param params - The web-contents DIP coordinates to move to.
      * @returns A {@link Promise} that resolves once the move has been injected.
      */
     moveMouse(this: void, params: MoveMouseParams): Promise<void>;
-    /**
-     * The `obsidian` module, resolved at runtime inside the Obsidian process.
-     */
-    obsidianModule: typeof obsidian;
     /**
      * Presses a single key (optionally with modifiers) using **trusted** Electron
      * keyboard input, firing the full real key pipeline —
      * `keydown` → `keypress` → `beforeinput` → `input` → `keyup`.
      *
-     * This is the key-press analog of {@link CommonArgs.typeIntoEditor}: it
-     * injects a trusted `keyDown` → `char` → `keyUp` sequence via Electron's
+     * This is the key-press analog of {@link Lib.typeIntoEditor}: it injects a
+     * trusted `keyDown` → `char` → `keyUp` sequence via Electron's
      * `webContents.sendInputEvent`, so it is delivered to the window's DOM-focused
      * element and flows through the real input pipeline — unlike
      * `dispatchEvent(new KeyboardEvent(...))`, which is untrusted (`isTrusted:
      * false`) and ignored by CodeMirror and most key handlers. Use it for special
      * keys (`'Enter'`, `'Escape'`, `'Tab'`, arrow keys) and modifier combinations
-     * (`Shift+Enter`, `Ctrl+A`) that {@link CommonArgs.typeIntoEditor} (which
-     * types printable text) does not cover.
+     * (`Shift+Enter`, `Ctrl+A`) that {@link Lib.typeIntoEditor} (which types
+     * printable text) does not cover.
      *
      * This is the low-level primitive: it injects the key press and does **not**
      * poll for any effect (a key press has no universal observable outcome —
      * `Enter` edits the document, `Escape` closes a modal, `ArrowDown` moves the
      * selection). The caller focuses the intended target first, then awaits the
-     * expected effect via {@link CommonArgs.waitUntil}. It targets the single
-     * shared window's **global** focus, so only the DOM-focused element receives
-     * the key.
+     * expected effect via {@link Lib.waitUntil}. It targets the single shared
+     * window's **global** focus, so only the DOM-focused element receives the key.
      *
      * @param params - The key to press and any modifiers to hold.
      * @returns A {@link Promise} that resolves once the key press has been
@@ -91,11 +177,10 @@ export interface CommonArgs {
      *
      * Typing is pressing each character key in turn: this focuses the editor
      * (caret to end) and presses every code point of `text` via
-     * {@link CommonArgs.pressKey} — the same trusted `keyDown` → `char` → `keyUp`
-     * a real user produces. Each keystroke is delivered to the window's
-     * DOM-focused element and flows through CodeMirror's real input pipeline, so
-     * the typed text reaches the document **only if the editor genuinely holds
-     * focus**.
+     * {@link Lib.pressKey} — the same trusted `keyDown` → `char` → `keyUp` a real
+     * user produces. Each keystroke is delivered to the window's DOM-focused
+     * element and flows through CodeMirror's real input pipeline, so the typed
+     * text reaches the document **only if the editor genuinely holds focus**.
      * This makes "the user typed into the editor" a faithful end-to-end check,
      * unlike `dispatchEvent(new KeyboardEvent(...))` (untrusted — ignored by
      * CodeMirror) or `execCommand('insertText')` (mutates the selection even
@@ -114,11 +199,11 @@ export interface CommonArgs {
      * using a **trusted** Electron pointer move, then polls until the element no
      * longer matches `:hover`.
      *
-     * The inverse of {@link CommonArgs.hoverElement}. It targets the single
-     * shared window's **global** pointer, so only one element is hovered at a
-     * time. When an element spans the full viewport (no point outside its box is
-     * reachable), use {@link CommonArgs.moveMouse} directly to move the pointer
-     * to a known empty coordinate instead.
+     * The inverse of {@link Lib.hoverElement}. It targets the single shared
+     * window's **global** pointer, so only one element is hovered at a time. When
+     * an element spans the full viewport (no point outside its box is reachable),
+     * use {@link Lib.moveMouse} directly to move the pointer to a known empty
+     * coordinate instead.
      *
      * @param params - The element to move the pointer away from.
      * @returns A {@link Promise} that resolves once the element no longer matches
@@ -133,9 +218,9 @@ export interface CommonArgs {
      * asynchronous effect to settle (a view to open, a DOM node to appear, a
      * setting to apply). Because the callback is serialized via `toString()` and
      * cannot import modules, it can't reuse `obsidian-dev-utils`'
-     * `retryWithTimeout` / `runWithTimeout`. This helper is the shared,
-     * injected replacement for the per-closure poll loops consumers would
-     * otherwise hand-roll.
+     * `retryWithTimeout` / `runWithTimeout`. This helper is the shared, injected
+     * replacement for the per-closure poll loops consumers would otherwise
+     * hand-roll.
      *
      * The `predicate` may be synchronous or asynchronous — it is awaited on every
      * poll. It is checked immediately, then re-checked every
@@ -149,59 +234,6 @@ export interface CommonArgs {
      */
     waitUntil(this: void, params: WaitUntilParams): Promise<void>;
 }
-/**
- * Parameters for {@link evalInObsidian}.
- */
-export interface EvalInObsidianParams<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined> {
-    /**
-     * Additional arguments to pass to the function. Values may include functions —
-     * they are serialized via `toString()`.
-     */
-    readonly args?: Args;
-    /**
-     * A {@link ContextId} linking this call to a persistent store on `window`
-     * in the Obsidian process. The callback receives a typed `context` object
-     * that survives across calls sharing the same ID.
-     *
-     * When omitted, `context` is a fresh empty object each call.
-     */
-    readonly contextId?: TContextId;
-    /**
-     * The function to evaluate in the Obsidian context.
-     */
-    fn(args: Args & CommonArgs & ContextArgs<TContextId>): Promisable<Result>;
-    /**
-     * Skips pre-flight checks (vault registration, CLI availability).
-     * Used internally by vault registration functions.
-     *
-     * @internal
-     */
-    readonly shouldSkipPreflightChecks?: boolean;
-    /**
-     * Override the transport for this call. When omitted, uses the transport
-     * configured via the context provider (set by the framework adapter's global setup).
-     */
-    readonly transport?: ObsidianTransport;
-    /**
-     * The path to the Obsidian vault. Defaults to `process.cwd()`.
-     */
-    readonly vaultPath?: string;
-}
-/**
- * A plain object with string keys.
- */
-export type GenericObject = Record<string, unknown>;
-/**
- * Parameters for {@link CommonArgs.hoverElement}.
- */
-export interface HoverElementParams {
-    /**
-     * The element to hover. The pointer is moved to its center. This is a live
-     * renderer DOM node — the callback runs in-renderer, so no cross-process
-     * serialization is needed (same as {@link TypeIntoEditorParams.editor}).
-     */
-    readonly element: HTMLElement;
-}
 /**
  * Parameters for {@link CommonArgs.moveMouse}.
  */