obsidian-integration-testing 9.0.0 → 9.1.1

package/dist/lib/esm/jest/global-setup.mjs

@@ -14,7 +14,12 @@ function createSetup(options) {
   return { setup: setup2, teardown: teardown2 };
   async function setup2() {
     const transportOptions = globalThis.__obsidianIntegrationTesting?.transportOptions;
-    setupResult = await coreSetup({ installPlugin: options?.installPlugin, populate: options?.populate?.(), transportOptions });
+    setupResult = await coreSetup({
+      enableCommunityPlugins: options?.enableCommunityPlugins,
+      installPlugin: options?.installPlugin,
+      populate: options?.populate?.(),
+      transportOptions
+    });
     globalThis.__obsidianIntegrationTesting = {
       ...globalThis.__obsidianIntegrationTesting,
       tempVaultPath: setupResult.tempVault.path,
@@ -49,4 +54,4 @@ export {
   setup,
   teardown
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/jest/global-setup.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Jest global setup and teardown adapter.\n *\n * Delegates to the framework-agnostic core and bridges context\n * to test workers via `globalThis.__obsidianIntegrationTesting`.\n */\n\n/* v8 ignore start -- Integration-time setup covered by integration tests, not unit tests. */\n\nimport type { CoreSetupResult } from '../global-setup-core.mjs';\nimport type { PopulateFilesParams } from '../temp-vault.mjs';\nimport type { ObsidianTransportOptions } from '../transport-options.mjs';\n\nimport {\n  setTransportOptionsResolver,\n  setVaultPathResolver\n} from '../context-provider.mjs';\nimport {\n  coreSetup,\n  coreTeardown\n} from '../global-setup-core.mjs';\nimport { TempVault } from '../temp-vault.mjs';\n\n/**\n * Shape of `globalThis.__obsidianIntegrationTesting`.\n *\n * Consumers may pre-populate `transportOptions` before the global setup runs\n * (e.g., via Jest config `globals`). The setup then adds `tempVaultPath`.\n */\ninterface ObsidianIntegrationTestingGlobal {\n  /** Temp vault path, set by the global setup for test workers. */\n  tempVaultPath?: string | undefined;\n\n  /** Transport options. Set by the consumer before setup, or by the setup itself. */\n  transportOptions?: ObsidianTransportOptions | undefined;\n}\n\n/* eslint-disable vars-on-top -- Required for `declare global` augmentation. */\ndeclare global {\n  /**\n   * Namespace for all `obsidian-integration-testing` global state.\n   * Consumers configure transport options here; the setup populates the rest.\n   */\n  var __obsidianIntegrationTesting: ObsidianIntegrationTestingGlobal | undefined;\n}\n/* eslint-enable vars-on-top -- End of `declare global` block. */\n\nsetTransportOptionsResolver(() => globalThis.__obsidianIntegrationTesting?.transportOptions);\nsetVaultPathResolver(() => globalThis.__obsidianIntegrationTesting?.tempVaultPath);\n\n/**\n * Options for {@link createSetup}.\n */\nexport interface CreateSetupOptions {\n  /**\n   * Whether to install and enable the built plugin in the temp vault. Defaults\n   * to `true`. Set to `false` for a **non-plugin** consumer that only needs a\n   * registered, empty vault to `evalInObsidian` against \u2014 the owned instance is\n   * still launched and its endpoint published to workers, so re-exporting\n   * `createSetup({ installPlugin: false })` reuses the same attach wiring with no\n   * plugin copy/enable. See {@link CoreSetupParams.installPlugin}.\n   */\n  readonly installPlugin?: boolean;\n\n  /**\n   * Returns files/folders to write into the vault before Obsidian opens it (see\n   * {@link CoreSetupParams.populate}). A thunk so large fixtures are built lazily,\n   * once, in the setup process.\n   */\n  populate?(this: void): PopulateFilesParams;\n}\n\n/**\n * A Jest `globalSetup` / `globalTeardown` module's `setup` / `teardown` pair.\n */\nexport interface JestGlobalSetup {\n  setup(this: void): Promise<void>;\n  teardown(this: void): Promise<void>;\n}\n\n/**\n * Creates a Jest global setup/teardown pair, optionally pre-populating the vault\n * before Obsidian opens it \u2014 use this for a dedicated large-vault/performance\n * setup. The plain {@link setup} / {@link teardown} exports are the no-populate\n * case (`createSetup()`). Pass `{ installPlugin: false }` for a non-plugin consumer\n * that only needs a registered, empty vault (see {@link CreateSetupOptions.installPlugin}).\n *\n * @param options - Setup options.\n * @returns The `setup` and `teardown` functions to re-export from a `globalSetup` module.\n */\nexport function createSetup(options?: CreateSetupOptions): JestGlobalSetup {\n  let setupResult: CoreSetupResult | undefined;\n\n  return { setup, teardown };\n\n  async function setup(): Promise<void> {\n    const transportOptions = globalThis.__obsidianIntegrationTesting?.transportOptions;\n\n    setupResult = await coreSetup({ installPlugin: options?.installPlugin, populate: options?.populate?.(), transportOptions });\n\n    globalThis.__obsidianIntegrationTesting = {\n      ...globalThis.__obsidianIntegrationTesting,\n      tempVaultPath: setupResult.tempVault.path,\n      transportOptions: setupResult.transportOptions\n    };\n  }\n\n  async function teardown(): Promise<void> {\n    await coreTeardown(setupResult);\n  }\n}\n\n/**\n * Returns the temporary vault provided by the global setup.\n *\n * Reads the vault path from `globalThis.__obsidianIntegrationTesting.tempVaultPath`,\n * which is set by the Jest global setup.\n *\n * @returns The temporary vault.\n */\nexport function getTempVault(): TempVault {\n  const tempVaultPath = globalThis.__obsidianIntegrationTesting?.tempVaultPath;\n  if (!tempVaultPath) {\n    throw new Error(\n      'globalThis.__obsidianIntegrationTesting.tempVaultPath is not set. Did you configure obsidian-integration-testing/jest-global-setup as a Jest globalSetup?'\n    );\n  }\n  return new TempVault(tempVaultPath);\n}\n\n/**\n * Returns the transport options provided by the global setup.\n *\n * @returns The transport options, or `undefined` if not configured.\n */\nexport function getTransportOptions(): ObsidianTransportOptions | undefined {\n  return globalThis.__obsidianIntegrationTesting?.transportOptions;\n}\n\nconst defaultGlobalSetup = createSetup();\n\n/**\n * Jest global setup function (no pre-population).\n *\n * Copies the built plugin into a temporary vault, enables it via the Obsidian CLI,\n * and populates `globalThis.__obsidianIntegrationTesting` for tests.\n *\n * Transport options are read from `globalThis.__obsidianIntegrationTesting.transportOptions`.\n * Set this in your Jest config via the `globals` option.\n *\n * @returns A promise that resolves when setup completes.\n */\nexport const setup = defaultGlobalSetup.setup;\n\n/**\n * Jest global teardown function.\n *\n * Removes the temporary vault created during setup.\n *\n * @returns A promise that resolves when teardown completes.\n */\nexport const teardown = defaultGlobalSetup.teardown;\n\n// Jest's `globalSetup` config can reference this module directly because its default export is the setup function.\n// eslint-disable-next-line import-x/no-default-export -- Jest's globalSetup loader requires a default-export function.\nexport default setup;\n"],
  "mappings": "AAeA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,iBAAiB;AA0B1B,4BAA4B,MAAM,WAAW,8BAA8B,gBAAgB;AAC3F,qBAAqB,MAAM,WAAW,8BAA8B,aAAa;AA0C1E,SAAS,YAAY,SAA+C;AACzE,MAAI;AAEJ,SAAO,EAAE,OAAAA,QAAO,UAAAC,UAAS;AAEzB,iBAAeD,SAAuB;AACpC,UAAM,mBAAmB,WAAW,8BAA8B;AAElE,kBAAc,MAAM,UAAU,EAAE,eAAe,SAAS,eAAe,UAAU,SAAS,WAAW,GAAG,iBAAiB,CAAC;AAE1H,eAAW,+BAA+B;AAAA,MACxC,GAAG,WAAW;AAAA,MACd,eAAe,YAAY,UAAU;AAAA,MACrC,kBAAkB,YAAY;AAAA,IAChC;AAAA,EACF;AAEA,iBAAeC,YAA0B;AACvC,UAAM,aAAa,WAAW;AAAA,EAChC;AACF;AAUO,SAAS,eAA0B;AACxC,QAAM,gBAAgB,WAAW,8BAA8B;AAC/D,MAAI,CAAC,eAAe;AAClB,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,SAAO,IAAI,UAAU,aAAa;AACpC;AAOO,SAAS,sBAA4D;AAC1E,SAAO,WAAW,8BAA8B;AAClD;AAEA,MAAM,qBAAqB,YAAY;AAahC,MAAM,QAAQ,mBAAmB;AASjC,MAAM,WAAW,mBAAmB;AAI3C,IAAO,uBAAQ;",
  "names": ["setup", "teardown"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/jest/global-setup.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Jest global setup and teardown adapter.\n *\n * Delegates to the framework-agnostic core and bridges context\n * to test workers via `globalThis.__obsidianIntegrationTesting`.\n */\n\n/* v8 ignore start -- Integration-time setup covered by integration tests, not unit tests. */\n\nimport type { CoreSetupResult } from '../global-setup-core.mjs';\nimport type { PopulateFilesParams } from '../temp-vault.mjs';\nimport type { ObsidianTransportOptions } from '../transport-options.mjs';\n\nimport {\n  setTransportOptionsResolver,\n  setVaultPathResolver\n} from '../context-provider.mjs';\nimport {\n  coreSetup,\n  coreTeardown\n} from '../global-setup-core.mjs';\nimport { TempVault } from '../temp-vault.mjs';\n\n/**\n * Shape of `globalThis.__obsidianIntegrationTesting`.\n *\n * Consumers may pre-populate `transportOptions` before the global setup runs\n * (e.g., via Jest config `globals`). The setup then adds `tempVaultPath`.\n */\ninterface ObsidianIntegrationTestingGlobal {\n  /** Temp vault path, set by the global setup for test workers. */\n  tempVaultPath?: string | undefined;\n\n  /** Transport options. Set by the consumer before setup, or by the setup itself. */\n  transportOptions?: ObsidianTransportOptions | undefined;\n}\n\n/* eslint-disable vars-on-top -- Required for `declare global` augmentation. */\ndeclare global {\n  /**\n   * Namespace for all `obsidian-integration-testing` global state.\n   * Consumers configure transport options here; the setup populates the rest.\n   */\n  var __obsidianIntegrationTesting: ObsidianIntegrationTestingGlobal | undefined;\n}\n/* eslint-enable vars-on-top -- End of `declare global` block. */\n\nsetTransportOptionsResolver(() => globalThis.__obsidianIntegrationTesting?.transportOptions);\nsetVaultPathResolver(() => globalThis.__obsidianIntegrationTesting?.tempVaultPath);\n\n/**\n * Options for {@link createSetup}.\n */\nexport interface CreateSetupOptions {\n  /**\n   * Community-plugin ids to enable in the vault in addition to the plugin-under-test,\n   * after it is enabled (see {@link CoreSetupParams.enableCommunityPlugins}). Seed each\n   * plugin's built files via {@link CreateSetupOptions.populate} (e.g. with `buildDemoVaultPopulate`)\n   * so the enable finds them on disk.\n   */\n  readonly enableCommunityPlugins?: readonly string[];\n\n  /**\n   * Whether to install and enable the built plugin in the temp vault. Defaults\n   * to `true`. Set to `false` for a **non-plugin** consumer that only needs a\n   * registered, empty vault to `evalInObsidian` against \u2014 the owned instance is\n   * still launched and its endpoint published to workers, so re-exporting\n   * `createSetup({ installPlugin: false })` reuses the same attach wiring with no\n   * plugin copy/enable. See {@link CoreSetupParams.installPlugin}.\n   */\n  readonly installPlugin?: boolean;\n\n  /**\n   * Returns files/folders to write into the vault before Obsidian opens it (see\n   * {@link CoreSetupParams.populate}). A thunk so large fixtures are built lazily,\n   * once, in the setup process.\n   */\n  populate?(this: void): PopulateFilesParams;\n}\n\n/**\n * A Jest `globalSetup` / `globalTeardown` module's `setup` / `teardown` pair.\n */\nexport interface JestGlobalSetup {\n  setup(this: void): Promise<void>;\n  teardown(this: void): Promise<void>;\n}\n\n/**\n * Creates a Jest global setup/teardown pair, optionally pre-populating the vault\n * before Obsidian opens it \u2014 use this for a dedicated large-vault/performance\n * setup. The plain {@link setup} / {@link teardown} exports are the no-populate\n * case (`createSetup()`). Pass `{ installPlugin: false }` for a non-plugin consumer\n * that only needs a registered, empty vault (see {@link CreateSetupOptions.installPlugin}).\n *\n * @param options - Setup options.\n * @returns The `setup` and `teardown` functions to re-export from a `globalSetup` module.\n */\nexport function createSetup(options?: CreateSetupOptions): JestGlobalSetup {\n  let setupResult: CoreSetupResult | undefined;\n\n  return { setup, teardown };\n\n  async function setup(): Promise<void> {\n    const transportOptions = globalThis.__obsidianIntegrationTesting?.transportOptions;\n\n    setupResult = await coreSetup({\n      enableCommunityPlugins: options?.enableCommunityPlugins,\n      installPlugin: options?.installPlugin,\n      populate: options?.populate?.(),\n      transportOptions\n    });\n\n    globalThis.__obsidianIntegrationTesting = {\n      ...globalThis.__obsidianIntegrationTesting,\n      tempVaultPath: setupResult.tempVault.path,\n      transportOptions: setupResult.transportOptions\n    };\n  }\n\n  async function teardown(): Promise<void> {\n    await coreTeardown(setupResult);\n  }\n}\n\n/**\n * Returns the temporary vault provided by the global setup.\n *\n * Reads the vault path from `globalThis.__obsidianIntegrationTesting.tempVaultPath`,\n * which is set by the Jest global setup.\n *\n * @returns The temporary vault.\n */\nexport function getTempVault(): TempVault {\n  const tempVaultPath = globalThis.__obsidianIntegrationTesting?.tempVaultPath;\n  if (!tempVaultPath) {\n    throw new Error(\n      'globalThis.__obsidianIntegrationTesting.tempVaultPath is not set. Did you configure obsidian-integration-testing/jest-global-setup as a Jest globalSetup?'\n    );\n  }\n  return new TempVault(tempVaultPath);\n}\n\n/**\n * Returns the transport options provided by the global setup.\n *\n * @returns The transport options, or `undefined` if not configured.\n */\nexport function getTransportOptions(): ObsidianTransportOptions | undefined {\n  return globalThis.__obsidianIntegrationTesting?.transportOptions;\n}\n\nconst defaultGlobalSetup = createSetup();\n\n/**\n * Jest global setup function (no pre-population).\n *\n * Copies the built plugin into a temporary vault, enables it via a renderer eval\n * over the transport, and populates `globalThis.__obsidianIntegrationTesting` for tests.\n *\n * Transport options are read from `globalThis.__obsidianIntegrationTesting.transportOptions`.\n * Set this in your Jest config via the `globals` option.\n *\n * @returns A promise that resolves when setup completes.\n */\nexport const setup = defaultGlobalSetup.setup;\n\n/**\n * Jest global teardown function.\n *\n * Removes the temporary vault created during setup.\n *\n * @returns A promise that resolves when teardown completes.\n */\nexport const teardown = defaultGlobalSetup.teardown;\n\n// Jest's `globalSetup` config can reference this module directly because its default export is the setup function.\n// eslint-disable-next-line import-x/no-default-export -- Jest's globalSetup loader requires a default-export function.\nexport default setup;\n"],
  "mappings": "AAeA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,iBAAiB;AA0B1B,4BAA4B,MAAM,WAAW,8BAA8B,gBAAgB;AAC3F,qBAAqB,MAAM,WAAW,8BAA8B,aAAa;AAkD1E,SAAS,YAAY,SAA+C;AACzE,MAAI;AAEJ,SAAO,EAAE,OAAAA,QAAO,UAAAC,UAAS;AAEzB,iBAAeD,SAAuB;AACpC,UAAM,mBAAmB,WAAW,8BAA8B;AAElE,kBAAc,MAAM,UAAU;AAAA,MAC5B,wBAAwB,SAAS;AAAA,MACjC,eAAe,SAAS;AAAA,MACxB,UAAU,SAAS,WAAW;AAAA,MAC9B;AAAA,IACF,CAAC;AAED,eAAW,+BAA+B;AAAA,MACxC,GAAG,WAAW;AAAA,MACd,eAAe,YAAY,UAAU;AAAA,MACrC,kBAAkB,YAAY;AAAA,IAChC;AAAA,EACF;AAEA,iBAAeC,YAA0B;AACvC,UAAM,aAAa,WAAW;AAAA,EAChC;AACF;AAUO,SAAS,eAA0B;AACxC,QAAM,gBAAgB,WAAW,8BAA8B;AAC/D,MAAI,CAAC,eAAe;AAClB,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,SAAO,IAAI,UAAU,aAAa;AACpC;AAOO,SAAS,sBAA4D;AAC1E,SAAO,WAAW,8BAA8B;AAClD;AAEA,MAAM,qBAAqB,YAAY;AAahC,MAAM,QAAQ,mBAAmB;AASjC,MAAM,WAAW,mBAAmB;AAI3C,IAAO,uBAAQ;",
  "names": ["setup", "teardown"]
}


package/dist/lib/esm/library.mjs

@@ -1,4 +1,4 @@
-const LIBRARY_VERSION = false ? "dev" : "8.4.0";
+const LIBRARY_VERSION = false ? "dev" : "9.1.0";
 export {
   LIBRARY_VERSION
 };

package/dist/lib/esm/plugin-enable-retry.d.mts

@@ -0,0 +1,71 @@
+/**
+ * @file
+ *
+ * Pure helpers for retrying the plugin-enable step, plus resolving the retry
+ * knobs from the transport options. Kept separate from the integration-only
+ * `global-setup-core` orchestration so the decision logic and default
+ * resolution stay unit-testable (the orchestration itself needs a real
+ * transport and is excluded from unit tests).
+ *
+ * When the harness auto-starts an Android emulator (cold boot) and immediately
+ * syncs the vault and enables the plugin, the plugin can land in the enabled set
+ * but fail to load — the freshly booted guest's plugin subsystem isn't settled
+ * and the single-shot enable races it. Device-idle and `layoutReady` are already
+ * gated upstream, so the residual gap is narrow; retrying the enable a few times
+ * with backoff recovers the transient race while still failing fast on a genuine
+ * plugin bug (a captured load error, which retrying cannot fix).
+ */
+import type { EnablePluginResult } from './enable-plugin.mjs';
+import type { ObsidianTransportOptions } from './transport-options.mjs';
+/**
+ * Default for {@link ObsidianAndroidAppiumTransportOptions.pluginEnableRetryCount}.
+ */
+export declare const DEFAULT_PLUGIN_ENABLE_RETRY_COUNT = 3;
+/**
+ * Default for {@link ObsidianAndroidAppiumTransportOptions.pluginEnableRetryDelayInMilliseconds}.
+ */
+export declare const DEFAULT_PLUGIN_ENABLE_RETRY_DELAY_IN_MILLISECONDS = 2000;
+/**
+ * Computes the exponential backoff delay for a given retry, from a base delay.
+ *
+ * `attemptIndex` is 0-based: the first retry waits the base delay, the second
+ * twice that, the third four times, and so on.
+ *
+ * @param baseDelayInMilliseconds - The base delay.
+ * @param attemptIndex - The 0-based retry index.
+ * @returns The delay in milliseconds for this retry.
+ */
+export declare function computeBackoffDelayInMilliseconds(baseDelayInMilliseconds: number, attemptIndex: number): number;
+/**
+ * Resolves the number of extra plugin-enable attempts, applying the default when
+ * the option is omitted. Only the Android transport carries the knob; every
+ * other transport (and `undefined`) falls back to the default — harmless there,
+ * since a plugin that loads on the first try never enters the retry path.
+ *
+ * A value of `0` disables retry (a single attempt).
+ *
+ * @param options - The resolved transport options.
+ * @returns The retry count.
+ */
+export declare function resolvePluginEnableRetryCount(options: null | ObsidianTransportOptions): number;
+/**
+ * Resolves the base backoff delay between plugin-enable attempts, applying the
+ * default when the option is omitted. See {@link resolvePluginEnableRetryCount}
+ * for the transport handling.
+ *
+ * @param options - The resolved transport options.
+ * @returns The base delay in milliseconds.
+ */
+export declare function resolvePluginEnableRetryDelayInMilliseconds(options: null | ObsidianTransportOptions): number;
+/**
+ * Decides whether a failed plugin-enable is a retryable cold-boot race.
+ *
+ * Retry only the transient swallow signature — the plugin is in the enabled set
+ * but not loaded and no cause was captured (neither the `loadPlugin`
+ * monkey-patch nor the renderer console surfaced an error). A captured error is
+ * a deterministic bug that retrying cannot fix, so it is not retryable.
+ *
+ * @param result - The enable result from a single attempt.
+ * @returns `true` when the enable should be retried.
+ */
+export declare function shouldRetryPluginEnable(result: EnablePluginResult): boolean;

package/dist/lib/esm/plugin-enable-retry.mjs

@@ -0,0 +1,24 @@
+const DEFAULT_PLUGIN_ENABLE_RETRY_COUNT = 3;
+const DEFAULT_PLUGIN_ENABLE_RETRY_DELAY_IN_MILLISECONDS = 2e3;
+const EXPONENTIAL_BACKOFF_BASE = 2;
+function computeBackoffDelayInMilliseconds(baseDelayInMilliseconds, attemptIndex) {
+  return baseDelayInMilliseconds * EXPONENTIAL_BACKOFF_BASE ** attemptIndex;
+}
+function resolvePluginEnableRetryCount(options) {
+  return options?.type === "obsidian-android-appium" ? options.pluginEnableRetryCount ?? DEFAULT_PLUGIN_ENABLE_RETRY_COUNT : DEFAULT_PLUGIN_ENABLE_RETRY_COUNT;
+}
+function resolvePluginEnableRetryDelayInMilliseconds(options) {
+  return options?.type === "obsidian-android-appium" ? options.pluginEnableRetryDelayInMilliseconds ?? DEFAULT_PLUGIN_ENABLE_RETRY_DELAY_IN_MILLISECONDS : DEFAULT_PLUGIN_ENABLE_RETRY_DELAY_IN_MILLISECONDS;
+}
+function shouldRetryPluginEnable(result) {
+  return !result.isLoaded && !result.errorMessage && !result.rendererConsoleErrors;
+}
+export {
+  DEFAULT_PLUGIN_ENABLE_RETRY_COUNT,
+  DEFAULT_PLUGIN_ENABLE_RETRY_DELAY_IN_MILLISECONDS,
+  computeBackoffDelayInMilliseconds,
+  resolvePluginEnableRetryCount,
+  resolvePluginEnableRetryDelayInMilliseconds,
+  shouldRetryPluginEnable
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,92 @@
+/**
+ * @file
+ *
+ * Node-side "kick off, then poll" helper over {@link evalInObsidian}.
+ *
+ * A single `evalInObsidian` closure cannot run longer than CDP's ~30s
+ * `Runtime.evaluate` cap, so a long-running in-Obsidian operation (e.g. a whole
+ * plugin/vault bootstrap) cannot be awaited inside one closure. This helper does
+ * it from Node instead: it optionally runs a short `start` closure once to kick
+ * the work off, then repeatedly runs a short `poll` closure — each a separate,
+ * well-under-30s eval — until the Node-side `until` predicate accepts a poll
+ * result, or a Node-side timeout elapses. It removes the per-test hand-rolled
+ * `evalInObsidian` + `sleep` loop.
+ *
+ * The timing loop lives in the pure, unit-tested {@link pollUntil}; this module is
+ * the integration-only wiring (it drives a live Obsidian), covered by an
+ * integration test.
+ */
+import type { Promisable } from 'type-fest';
+import type { ContextArgs } from './context-id.mjs';
+import type { CommonArgs, GenericObject } from './eval-in-obsidian.mjs';
+import type { ObsidianTransport } from './transport.mjs';
+import { ContextId } from './context-id.mjs';
+/**
+ * Parameters for {@link pollInObsidian}. Mirrors {@link EvalInObsidianParams} for
+ * the shared forwarded fields (`args` / `contextId` / `transport` / `vaultPath`);
+ * `start` / `poll` are the in-Obsidian closures and `until` is the Node-side
+ * acceptance predicate.
+ */
+export interface PollInObsidianParams<Args extends GenericObject, PollResult, TContextId extends ContextId<unknown> | undefined = undefined> {
+    /**
+     * Additional arguments passed to both `start` and `poll` (serialized like
+     * {@link EvalInObsidianParams.args}).
+     */
+    readonly args?: Args;
+    /**
+     * A {@link ContextId} shared by `start` and `poll`, so `start` can stash
+     * non-serializable state that `poll` later reads. When omitted, each closure
+     * gets a fresh empty `context`.
+     */
+    readonly contextId?: TContextId;
+    /**
+     * Delay between `poll` attempts, in milliseconds.
+     *
+     * @default `500`
+     */
+    readonly intervalInMilliseconds?: number;
+    /**
+     * The closure polled repeatedly inside Obsidian. Keep it short (well under the
+     * ~30s CDP cap): it should read and return a JSON-serializable status, not
+     * await the long operation itself.
+     */
+    poll(this: void, args: Args & CommonArgs & ContextArgs<TContextId>): Promisable<PollResult>;
+    /**
+     * An optional closure run **once** before polling begins, to kick off the
+     * long-running work (fire-and-forget from Node's perspective). Keep it short —
+     * start the work and return; do not await it to completion here.
+     */
+    start?(this: void, args: Args & CommonArgs & ContextArgs<TContextId>): Promisable<unknown>;
+    /**
+     * Total budget before the poll rejects, in milliseconds.
+     *
+     * @default `120000`
+     */
+    readonly timeoutInMilliseconds?: number;
+    /**
+     * Optional detail appended to the timeout error message.
+     */
+    readonly timeoutMessage?: string;
+    /**
+     * Override the transport (forwarded to every underlying `evalInObsidian`).
+     */
+    readonly transport?: ObsidianTransport;
+    /**
+     * Whether a given `poll` result is acceptable, evaluated in **Node**. Returning
+     * `true` resolves {@link pollInObsidian} with that result.
+     */
+    until(this: void, result: PollResult): boolean;
+    /**
+     * The vault path to evaluate against (forwarded to every underlying
+     * `evalInObsidian`).
+     */
+    readonly vaultPath?: string;
+}
+/**
+ * Kicks off an optional `start` closure once, then polls `poll` from Node until
+ * `until` accepts a result or the timeout elapses.
+ *
+ * @param params - The poll parameters.
+ * @returns A {@link Promise} that resolves with the first accepted `poll` result.
+ */
+export declare function pollInObsidian<Args extends GenericObject, PollResult, TContextId extends ContextId<unknown> | undefined = undefined>(params: PollInObsidianParams<Args, PollResult, TContextId>): Promise<PollResult>;

package/dist/lib/esm/poll-in-obsidian.mjs

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


package/dist/lib/esm/poll-until.d.mts

@@ -0,0 +1,42 @@
+/**
+ * @file
+ *
+ * Pure poll-until-satisfied loop: repeatedly runs an async `attempt`, returning
+ * its result once `until` accepts it, or throwing when a timeout elapses.
+ *
+ * Extracted from the integration-only {@link pollInObsidian} wrapper (which binds
+ * `attempt` to an `evalInObsidian` call and is excluded from unit tests) so the
+ * timing/timeout logic stays unit-testable. The clock and sleep are injected so
+ * the loop is deterministic under test.
+ */
+/**
+ * Parameters for {@link pollUntil}.
+ */
+export interface PollUntilParams<Result> {
+    /** Runs one attempt and resolves with its result. */
+    attempt(this: void): Promise<Result>;
+    /** Delay between attempts, in milliseconds. */
+    readonly intervalInMilliseconds: number;
+    /** Returns the current time in milliseconds (injected for deterministic tests). */
+    nowInMilliseconds(this: void): number;
+    /** Sleeps for the given number of milliseconds (injected for deterministic tests). */
+    sleep(this: void, milliseconds: number): Promise<void>;
+    /** Total budget before the poll rejects, in milliseconds. */
+    readonly timeoutInMilliseconds: number;
+    /** Optional detail appended to the timeout error message. */
+    readonly timeoutMessage?: string;
+    /** Whether a given attempt result is acceptable (stops the poll). */
+    until(this: void, result: Result): boolean;
+}
+/**
+ * Runs `attempt` immediately, then repeatedly every `intervalInMilliseconds`,
+ * until `until(result)` is truthy — resolving with that result — or the
+ * `timeoutInMilliseconds` budget elapses, at which point it rejects. At least one
+ * attempt always runs; the timeout is checked after each unsatisfied attempt, so
+ * a slow single attempt cannot be interrupted mid-flight but no further attempt
+ * starts past the deadline.
+ *
+ * @param params - The poll parameters.
+ * @returns A {@link Promise} that resolves with the first accepted attempt result.
+ */
+export declare function pollUntil<Result>(params: PollUntilParams<Result>): Promise<Result>;

package/dist/lib/esm/poll-until.mjs

@@ -0,0 +1,19 @@
+async function pollUntil(params) {
+  const { attempt, intervalInMilliseconds, nowInMilliseconds, sleep, timeoutInMilliseconds, timeoutMessage, until } = params;
+  const deadline = nowInMilliseconds() + timeoutInMilliseconds;
+  while (true) {
+    const result = await attempt();
+    if (until(result)) {
+      return result;
+    }
+    if (nowInMilliseconds() >= deadline) {
+      const suffix = timeoutMessage === void 0 ? "" : `: ${timeoutMessage}`;
+      throw new Error(`pollInObsidian timed out after ${String(timeoutInMilliseconds)} milliseconds${suffix}`);
+    }
+    await sleep(intervalInMilliseconds);
+  }
+}
+export {
+  pollUntil
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/transport-appium.d.mts

@@ -38,7 +38,7 @@
  * This avoids the onboarding flow entirely.
  */
 import type { Browser } from 'webdriverio';
-import type { ObsidianTransport, TransportEvalOptions } from './transport.mjs';
+import type { ConsoleCaptureHandle, ObsidianTransport, TransportEvalOptions } from './transport.mjs';
 /**
  * Session connection info returned by {@link AppiumTransport.getSessionInfo},
  * used to reattach from another process.
@@ -142,6 +142,17 @@ export declare class AppiumTransport implements ObsidianTransport {
      * @param config - Appium transport configuration.
      */
     constructor(config: AppiumTransportConfig);
+    /**
+     * Begins a console capture by stamping the device log with a unique marker.
+     *
+     * Uses `adb shell log` to write a marker into `logcat` at capture start so a
+     * later {@link AppiumTransport.readConsoleCaptureSince} can slice out
+     * everything the WebView logged afterwards — without the invasive `logcat -c`
+     * buffer clear.
+     *
+     * @returns A handle carrying the unique marker.
+     */
+    beginConsoleCapture(): Promise<ConsoleCaptureHandle>;
     /**
      * Ends the Appium session.
      *
@@ -186,6 +197,18 @@ export declare class AppiumTransport implements ObsidianTransport {
      * @param _files - Map of relative file paths to content buffers (unused — adb pushes the directory directly).
      */
     pushFiles(vaultPath: string, _files: Record<string, Uint8Array>): Promise<void>;
+    /**
+     * Dumps `adb logcat` and returns the WebView console/error output logged
+     * since the marker from {@link AppiumTransport.beginConsoleCapture}.
+     *
+     * Filters to the Chromium/WebView tags that carry JS `console.*` output and
+     * uncaught errors, and caps the result length. Bounded, post-hoc,
+     * failure-path-only — never a live monitor.
+     *
+     * @param handle - The capture handle (or `undefined` when capture never started).
+     * @returns The captured console/error text, or `undefined` if nothing relevant was logged.
+     */
+    readConsoleCaptureSince(handle: ConsoleCaptureHandle | undefined): Promise<string | undefined>;
     /**
      * Registers a vault on mobile by pushing files and configuring localStorage.
      *