obsidian-integration-testing 10.4.0 → 12.0.0

package/dist/lib/esm/vitest/global-setup.d.mts

@@ -33,8 +33,12 @@ export interface CreateSetupOptions {
      * Returns files/folders to write into the vault before Obsidian opens it (see
      * {@link CoreSetupParams.populate}). A thunk so large fixtures are built lazily,
      * once, in the setup process.
+     *
+     * May return a promise, so the map can be built by something that needs the network — notably
+     * `buildDemoVaultPopulateAsync`, which installs a demo vault's missing community plugins before
+     * reading them. A synchronous thunk (e.g. `buildDemoVaultPopulate`) is unchanged.
      */
-    populate?(this: void): PopulateFilesParams;
+    populate?(this: void): PopulateFilesParams | Promise<PopulateFilesParams>;
 }
 /**
  * A Vitest `globalSetup` module's `setup` / `teardown` pair.

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

@@ -1,5 +1,6 @@
 import { inject } from "vitest";
 import {
+  setSetupErrorResolver,
   setTransportOptionsResolver,
   setVaultPathResolver
 } from "../context-provider.mjs";
@@ -8,8 +9,10 @@ import {
   coreSetup,
   coreTeardown
 } from "../global-setup-core.mjs";
+import { IntegrationSetupFailedError } from "../integration-setup-failed-error.mjs";
 import { log } from "../log.mjs";
 import { TemporaryVault } from "../temporary-vault.mjs";
+setSetupErrorResolver(() => inject("setupError"));
 setTransportOptionsResolver(() => inject("obsidianTransport"));
 setVaultPathResolver(() => inject("temporaryVaultPath"));
 function createSetup(options) {
@@ -23,12 +26,16 @@ function createSetup(options) {
       setupResult = await coreSetup({
         enableCommunityPlugins: options?.enableCommunityPlugins,
         installPlugin: options?.installPlugin,
-        populate: options?.populate?.(),
+        populate: await options?.populate?.(),
         transportOptions
       });
     } catch (error) {
-      log(`[integration-setup:${label}] Setup failed (tests for this project will be skipped): ${errorToString(error)}`);
-      project.provide("setupError", errorToString(error));
+      log(`[integration-setup:${label}] Setup failed (every test in this project will fail with this error): ${errorToString(error)}`);
+      project.provide("setupError", {
+        errorName: error instanceof Error ? error.name : "Error",
+        message: errorToString(error),
+        transportLabel: label
+      });
       return;
     }
     project.provide("obsidianTransport", setupResult.transportOptions);
@@ -40,9 +47,9 @@ function createSetup(options) {
 }
 function getTemporaryVault() {
   const temporaryVaultPath = inject("temporaryVaultPath");
-  const setupErrorMessage = inject("setupError");
-  if (setupErrorMessage) {
-    throw new Error(`Integration setup failed \u2014 cannot get temp vault: ${setupErrorMessage}`);
+  const setupError = inject("setupError");
+  if (setupError) {
+    throw new IntegrationSetupFailedError(setupError);
   }
   return new TemporaryVault(temporaryVaultPath);
 }
@@ -55,4 +62,4 @@ export {
   setup,
   teardown
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/vitest/global-setup.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Vitest global setup and teardown adapter.\n *\n * Delegates to the framework-agnostic core and bridges context\n * to test workers via Vitest's `project.provide` / `inject`.\n */\n\n/* v8 ignore start -- Integration-time setup covered by integration tests, not unit tests. */\n\nimport type { TestProject } from 'vitest/node';\n\nimport { inject } from 'vitest';\n\nimport type { CoreSetupResult } from '../global-setup-core.mjs';\nimport type { PopulateFilesParams } from '../temporary-vault.mjs';\nimport type { ObsidianTransportOptions } from '../transport-options.mjs';\n\nimport {\n  setTransportOptionsResolver,\n  setVaultPathResolver\n} from '../context-provider.mjs';\nimport { errorToString } from '../error-to-string.mjs';\nimport {\n  coreSetup,\n  coreTeardown\n} from '../global-setup-core.mjs';\nimport { log } from '../log.mjs';\nimport { TemporaryVault } from '../temporary-vault.mjs';\n\nsetTransportOptionsResolver(() => inject('obsidianTransport'));\nsetVaultPathResolver(() => inject('temporaryVaultPath'));\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 Vitest `globalSetup` module's `setup` / `teardown` pair.\n */\nexport interface VitestGlobalSetup {\n  setup(this: void, project: TestProject): Promise<void>;\n  teardown(this: void): Promise<void>;\n}\n\n/**\n * Creates a Vitest global setup/teardown pair, optionally pre-populating the vault\n * before Obsidian opens it \u2014 use this for a dedicated large-vault/performance\n * project. 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): VitestGlobalSetup {\n  let setupResult: CoreSetupResult | undefined;\n\n  return { setup, teardown };\n\n  async function setup(project: TestProject): Promise<void> {\n    const environmentOptions = project.config.environmentOptions as Record<string, unknown> | undefined;\n    const transportOptions = environmentOptions?.['obsidianTransport'] as ObsidianTransportOptions | undefined;\n    const label = transportOptions?.type ?? 'obsidian-cdp';\n\n    try {\n      setupResult = await coreSetup({\n        enableCommunityPlugins: options?.enableCommunityPlugins,\n        installPlugin: options?.installPlugin,\n        populate: options?.populate?.(),\n        transportOptions\n      });\n    } catch (error: unknown) {\n      // Catch setup errors so that other projects' tests can still run.\n      // Individual tests in this project will fail with the stored error\n      // When they try to inject the temp vault path.\n      log(`[integration-setup:${label}] Setup failed (tests for this project will be skipped): ${errorToString(error)}`);\n      project.provide('setupError', errorToString(error));\n      return;\n    }\n\n    project.provide('obsidianTransport', setupResult.transportOptions);\n    project.provide('temporaryVaultPath', setupResult.temporaryVault.path);\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 * @returns The temporary vault.\n */\nexport function getTemporaryVault(): TemporaryVault {\n  const temporaryVaultPath = inject('temporaryVaultPath');\n  const setupErrorMessage = inject('setupError');\n  if (setupErrorMessage) {\n    throw new Error(`Integration setup failed \u2014 cannot get temp vault: ${setupErrorMessage}`);\n  }\n  return new TemporaryVault(temporaryVaultPath);\n}\n\nconst defaultGlobalSetup = createSetup();\n\n/**\n * Vitest 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 provides `temporaryVaultPath` to tests.\n *\n * @param project - The Vitest project.\n * @returns A promise that resolves when setup completes.\n */\nexport const setup = defaultGlobalSetup.setup;\n\n/**\n * Vitest 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"],
  "mappings": "AAaA,SAAS,cAAc;AAMvB;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,qBAAqB;AAC9B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,WAAW;AACpB,SAAS,sBAAsB;AAE/B,4BAA4B,MAAM,OAAO,mBAAmB,CAAC;AAC7D,qBAAqB,MAAM,OAAO,oBAAoB,CAAC;AAkDhD,SAAS,YAAY,SAAiD;AAC3E,MAAI;AAEJ,SAAO,EAAE,OAAAA,QAAO,UAAAC,UAAS;AAEzB,iBAAeD,OAAM,SAAqC;AACxD,UAAM,qBAAqB,QAAQ,OAAO;AAC1C,UAAM,mBAAmB,qBAAqB,mBAAmB;AACjE,UAAM,QAAQ,kBAAkB,QAAQ;AAExC,QAAI;AACF,oBAAc,MAAM,UAAU;AAAA,QAC5B,wBAAwB,SAAS;AAAA,QACjC,eAAe,SAAS;AAAA,QACxB,UAAU,SAAS,WAAW;AAAA,QAC9B;AAAA,MACF,CAAC;AAAA,IACH,SAAS,OAAgB;AAIvB,UAAI,sBAAsB,KAAK,4DAA4D,cAAc,KAAK,CAAC,EAAE;AACjH,cAAQ,QAAQ,cAAc,cAAc,KAAK,CAAC;AAClD;AAAA,IACF;AAEA,YAAQ,QAAQ,qBAAqB,YAAY,gBAAgB;AACjE,YAAQ,QAAQ,sBAAsB,YAAY,eAAe,IAAI;AAAA,EACvE;AAEA,iBAAeC,YAA0B;AACvC,UAAM,aAAa,WAAW;AAAA,EAChC;AACF;AAOO,SAAS,oBAAoC;AAClD,QAAM,qBAAqB,OAAO,oBAAoB;AACtD,QAAM,oBAAoB,OAAO,YAAY;AAC7C,MAAI,mBAAmB;AACrB,UAAM,IAAI,MAAM,0DAAqD,iBAAiB,EAAE;AAAA,EAC1F;AACA,SAAO,IAAI,eAAe,kBAAkB;AAC9C;AAEA,MAAM,qBAAqB,YAAY;AAWhC,MAAM,QAAQ,mBAAmB;AASjC,MAAM,WAAW,mBAAmB;",
  "names": ["setup", "teardown"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/vitest/global-setup.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Vitest global setup and teardown adapter.\n *\n * Delegates to the framework-agnostic core and bridges context\n * to test workers via Vitest's `project.provide` / `inject`.\n */\n\n/* v8 ignore start -- Integration-time setup covered by integration tests, not unit tests. */\n\nimport type { TestProject } from 'vitest/node';\n\nimport { inject } from 'vitest';\n\nimport type { CoreSetupResult } from '../global-setup-core.mjs';\nimport type { PopulateFilesParams } from '../temporary-vault.mjs';\nimport type { ObsidianTransportOptions } from '../transport-options.mjs';\n\nimport {\n  setSetupErrorResolver,\n  setTransportOptionsResolver,\n  setVaultPathResolver\n} from '../context-provider.mjs';\nimport { errorToString } from '../error-to-string.mjs';\nimport {\n  coreSetup,\n  coreTeardown\n} from '../global-setup-core.mjs';\nimport { IntegrationSetupFailedError } from '../integration-setup-failed-error.mjs';\nimport { log } from '../log.mjs';\nimport { TemporaryVault } from '../temporary-vault.mjs';\n\nsetSetupErrorResolver(() => inject('setupError'));\nsetTransportOptionsResolver(() => inject('obsidianTransport'));\nsetVaultPathResolver(() => inject('temporaryVaultPath'));\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   * May return a promise, so the map can be built by something that needs the network \u2014 notably\n   * `buildDemoVaultPopulateAsync`, which installs a demo vault's missing community plugins before\n   * reading them. A synchronous thunk (e.g. `buildDemoVaultPopulate`) is unchanged.\n   */\n  populate?(this: void): PopulateFilesParams | Promise<PopulateFilesParams>;\n}\n\n/**\n * A Vitest `globalSetup` module's `setup` / `teardown` pair.\n */\nexport interface VitestGlobalSetup {\n  setup(this: void, project: TestProject): Promise<void>;\n  teardown(this: void): Promise<void>;\n}\n\n/**\n * Creates a Vitest global setup/teardown pair, optionally pre-populating the vault\n * before Obsidian opens it \u2014 use this for a dedicated large-vault/performance\n * project. 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): VitestGlobalSetup {\n  let setupResult: CoreSetupResult | undefined;\n\n  return { setup, teardown };\n\n  async function setup(project: TestProject): Promise<void> {\n    const environmentOptions = project.config.environmentOptions as Record<string, unknown> | undefined;\n    const transportOptions = environmentOptions?.['obsidianTransport'] as ObsidianTransportOptions | undefined;\n    const label = transportOptions?.type ?? 'obsidian-cdp';\n\n    try {\n      setupResult = await coreSetup({\n        enableCommunityPlugins: options?.enableCommunityPlugins,\n        installPlugin: options?.installPlugin,\n        populate: await options?.populate?.(),\n        transportOptions\n      });\n    } catch (error: unknown) {\n      // Catch setup errors so that other projects' tests can still run. Every test in THIS project\n      // Then fails with the stored error: `getOrCreateTransport` reads it through the setup-error\n      // Resolver and throws before it can build a transport. Without that a worker gets no options\n      // At all and silently rebuilds the owned DESKTOP default, whatever platform this project asked\n      // For -- which is how an Android run came to report nine `Failed to parse URL from /json`\n      // Failures while the real cause sat once, far above, in this log (see AGENTS.md L9).\n      log(`[integration-setup:${label}] Setup failed (every test in this project will fail with this error): ${errorToString(error)}`);\n      project.provide('setupError', {\n        errorName: error instanceof Error ? error.name : 'Error',\n        message: errorToString(error),\n        transportLabel: label\n      });\n      return;\n    }\n\n    project.provide('obsidianTransport', setupResult.transportOptions);\n    project.provide('temporaryVaultPath', setupResult.temporaryVault.path);\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 * @returns The temporary vault.\n */\nexport function getTemporaryVault(): TemporaryVault {\n  const temporaryVaultPath = inject('temporaryVaultPath');\n  const setupError = inject('setupError');\n  if (setupError) {\n    throw new IntegrationSetupFailedError(setupError);\n  }\n  return new TemporaryVault(temporaryVaultPath);\n}\n\nconst defaultGlobalSetup = createSetup();\n\n/**\n * Vitest 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 provides `temporaryVaultPath` to tests.\n *\n * @param project - The Vitest project.\n * @returns A promise that resolves when setup completes.\n */\nexport const setup = defaultGlobalSetup.setup;\n\n/**\n * Vitest 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"],
  "mappings": "AAaA,SAAS,cAAc;AAMvB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,qBAAqB;AAC9B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,mCAAmC;AAC5C,SAAS,WAAW;AACpB,SAAS,sBAAsB;AAE/B,sBAAsB,MAAM,OAAO,YAAY,CAAC;AAChD,4BAA4B,MAAM,OAAO,mBAAmB,CAAC;AAC7D,qBAAqB,MAAM,OAAO,oBAAoB,CAAC;AAsDhD,SAAS,YAAY,SAAiD;AAC3E,MAAI;AAEJ,SAAO,EAAE,OAAAA,QAAO,UAAAC,UAAS;AAEzB,iBAAeD,OAAM,SAAqC;AACxD,UAAM,qBAAqB,QAAQ,OAAO;AAC1C,UAAM,mBAAmB,qBAAqB,mBAAmB;AACjE,UAAM,QAAQ,kBAAkB,QAAQ;AAExC,QAAI;AACF,oBAAc,MAAM,UAAU;AAAA,QAC5B,wBAAwB,SAAS;AAAA,QACjC,eAAe,SAAS;AAAA,QACxB,UAAU,MAAM,SAAS,WAAW;AAAA,QACpC;AAAA,MACF,CAAC;AAAA,IACH,SAAS,OAAgB;AAOvB,UAAI,sBAAsB,KAAK,0EAA0E,cAAc,KAAK,CAAC,EAAE;AAC/H,cAAQ,QAAQ,cAAc;AAAA,QAC5B,WAAW,iBAAiB,QAAQ,MAAM,OAAO;AAAA,QACjD,SAAS,cAAc,KAAK;AAAA,QAC5B,gBAAgB;AAAA,MAClB,CAAC;AACD;AAAA,IACF;AAEA,YAAQ,QAAQ,qBAAqB,YAAY,gBAAgB;AACjE,YAAQ,QAAQ,sBAAsB,YAAY,eAAe,IAAI;AAAA,EACvE;AAEA,iBAAeC,YAA0B;AACvC,UAAM,aAAa,WAAW;AAAA,EAChC;AACF;AAOO,SAAS,oBAAoC;AAClD,QAAM,qBAAqB,OAAO,oBAAoB;AACtD,QAAM,aAAa,OAAO,YAAY;AACtC,MAAI,YAAY;AACd,UAAM,IAAI,4BAA4B,UAAU;AAAA,EAClD;AACA,SAAO,IAAI,eAAe,kBAAkB;AAC9C;AAEA,MAAM,qBAAqB,YAAY;AAWhC,MAAM,QAAQ,mBAAmB;AASjC,MAAM,WAAW,mBAAmB;",
  "names": ["setup", "teardown"]
}


package/dist/lib/esm/vitest/setup.d.mts

@@ -10,5 +10,10 @@
  * context the global setup published via `provide` (e.g. the owned instance's
  * CDP `port`). Without it, a worker falls back to launching its own un-prepared
  * transport — which, for the owned-CDP default, has no CDP endpoint.
+ *
+ * The setup-error resolver is the same channel used in reverse: when the global setup
+ * FAILED it publishes nothing but the failure, and this registration is what lets
+ * `getOrCreateTransport` throw it instead of quietly building that same un-prepared
+ * desktop transport in a project configured for another platform.
  */
 export {};

package/dist/lib/esm/vitest/setup.mjs

@@ -1,8 +1,10 @@
 import { inject } from "vitest";
 import {
+  setSetupErrorResolver,
   setTransportOptionsResolver,
   setVaultPathResolver
 } from "../context-provider.mjs";
+setSetupErrorResolver(() => inject("setupError"));
 setTransportOptionsResolver(() => inject("obsidianTransport"));
 setVaultPathResolver(() => inject("temporaryVaultPath"));
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3ZpdGVzdC9zZXR1cC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIFZpdGVzdCAqKnBlci13b3JrZXIqKiBzZXR1cCBmaWxlLlxuICpcbiAqIFZpdGVzdCBydW5zIGBnbG9iYWxTZXR1cGAgb25seSBpbiB0aGUgbWFpbiBwcm9jZXNzLCBzbyB0aGUgdHJhbnNwb3J0LW9wdGlvbnNcbiAqIGFuZCB2YXVsdC1wYXRoIHJlc29sdmVycyByZWdpc3RlcmVkIHRoZXJlIG5ldmVyIGV4aXN0IGluIHRoZSB0ZXN0IHdvcmtlcnMgdGhhdFxuICogYWN0dWFsbHkgY2FsbCB7QGxpbmsgZXZhbEluT2JzaWRpYW59LiBBZGQgdGhpcyBtb2R1bGUgdG8gdGhlIGludGVncmF0aW9uXG4gKiBwcm9qZWN0J3MgYHNldHVwRmlsZXNgIHNvIGVhY2ggd29ya2VyIHJlZ2lzdGVycyB0aGUgcmVzb2x2ZXJzIGFuZCByZWFkcyB0aGVcbiAqIGNvbnRleHQgdGhlIGdsb2JhbCBzZXR1cCBwdWJsaXNoZWQgdmlhIGBwcm92aWRlYCAoZS5nLiB0aGUgb3duZWQgaW5zdGFuY2Unc1xuICogQ0RQIGBwb3J0YCkuIFdpdGhvdXQgaXQsIGEgd29ya2VyIGZhbGxzIGJhY2sgdG8gbGF1bmNoaW5nIGl0cyBvd24gdW4tcHJlcGFyZWRcbiAqIHRyYW5zcG9ydCBcdTIwMTQgd2hpY2gsIGZvciB0aGUgb3duZWQtQ0RQIGRlZmF1bHQsIGhhcyBubyBDRFAgZW5kcG9pbnQuXG4gKi9cbi8qIHY4IGlnbm9yZSBzdGFydCAtLSBJbnRlZ3JhdGlvbi10aW1lIHNldHVwIGNvdmVyZWQgYnkgaW50ZWdyYXRpb24gdGVzdHMsIG5vdCB1bml0IHRlc3RzLiAqL1xuXG5pbXBvcnQgeyBpbmplY3QgfSBmcm9tICd2aXRlc3QnO1xuXG5pbXBvcnQge1xuICBzZXRUcmFuc3BvcnRPcHRpb25zUmVzb2x2ZXIsXG4gIHNldFZhdWx0UGF0aFJlc29sdmVyXG59IGZyb20gJy4uL2NvbnRleHQtcHJvdmlkZXIubWpzJztcblxuc2V0VHJhbnNwb3J0T3B0aW9uc1Jlc29sdmVyKCgpID0+IGluamVjdCgnb2JzaWRpYW5UcmFuc3BvcnQnKSk7XG5zZXRWYXVsdFBhdGhSZXNvbHZlcigoKSA9PiBpbmplY3QoJ3RlbXBvcmFyeVZhdWx0UGF0aCcpKTtcblxuLyogdjggaWdub3JlIHN0b3AgKi9cbiJdLAogICJtYXBwaW5ncyI6ICJBQWVBLFNBQVMsY0FBYztBQUV2QjtBQUFBLEVBQ0U7QUFBQSxFQUNBO0FBQUEsT0FDSztBQUVQLDRCQUE0QixNQUFNLE9BQU8sbUJBQW1CLENBQUM7QUFDN0QscUJBQXFCLE1BQU0sT0FBTyxvQkFBb0IsQ0FBQzsiLAogICJuYW1lcyI6IFtdCn0K
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3ZpdGVzdC9zZXR1cC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIFZpdGVzdCAqKnBlci13b3JrZXIqKiBzZXR1cCBmaWxlLlxuICpcbiAqIFZpdGVzdCBydW5zIGBnbG9iYWxTZXR1cGAgb25seSBpbiB0aGUgbWFpbiBwcm9jZXNzLCBzbyB0aGUgdHJhbnNwb3J0LW9wdGlvbnNcbiAqIGFuZCB2YXVsdC1wYXRoIHJlc29sdmVycyByZWdpc3RlcmVkIHRoZXJlIG5ldmVyIGV4aXN0IGluIHRoZSB0ZXN0IHdvcmtlcnMgdGhhdFxuICogYWN0dWFsbHkgY2FsbCB7QGxpbmsgZXZhbEluT2JzaWRpYW59LiBBZGQgdGhpcyBtb2R1bGUgdG8gdGhlIGludGVncmF0aW9uXG4gKiBwcm9qZWN0J3MgYHNldHVwRmlsZXNgIHNvIGVhY2ggd29ya2VyIHJlZ2lzdGVycyB0aGUgcmVzb2x2ZXJzIGFuZCByZWFkcyB0aGVcbiAqIGNvbnRleHQgdGhlIGdsb2JhbCBzZXR1cCBwdWJsaXNoZWQgdmlhIGBwcm92aWRlYCAoZS5nLiB0aGUgb3duZWQgaW5zdGFuY2Unc1xuICogQ0RQIGBwb3J0YCkuIFdpdGhvdXQgaXQsIGEgd29ya2VyIGZhbGxzIGJhY2sgdG8gbGF1bmNoaW5nIGl0cyBvd24gdW4tcHJlcGFyZWRcbiAqIHRyYW5zcG9ydCBcdTIwMTQgd2hpY2gsIGZvciB0aGUgb3duZWQtQ0RQIGRlZmF1bHQsIGhhcyBubyBDRFAgZW5kcG9pbnQuXG4gKlxuICogVGhlIHNldHVwLWVycm9yIHJlc29sdmVyIGlzIHRoZSBzYW1lIGNoYW5uZWwgdXNlZCBpbiByZXZlcnNlOiB3aGVuIHRoZSBnbG9iYWwgc2V0dXBcbiAqIEZBSUxFRCBpdCBwdWJsaXNoZXMgbm90aGluZyBidXQgdGhlIGZhaWx1cmUsIGFuZCB0aGlzIHJlZ2lzdHJhdGlvbiBpcyB3aGF0IGxldHNcbiAqIGBnZXRPckNyZWF0ZVRyYW5zcG9ydGAgdGhyb3cgaXQgaW5zdGVhZCBvZiBxdWlldGx5IGJ1aWxkaW5nIHRoYXQgc2FtZSB1bi1wcmVwYXJlZFxuICogZGVza3RvcCB0cmFuc3BvcnQgaW4gYSBwcm9qZWN0IGNvbmZpZ3VyZWQgZm9yIGFub3RoZXIgcGxhdGZvcm0uXG4gKi9cbi8qIHY4IGlnbm9yZSBzdGFydCAtLSBJbnRlZ3JhdGlvbi10aW1lIHNldHVwIGNvdmVyZWQgYnkgaW50ZWdyYXRpb24gdGVzdHMsIG5vdCB1bml0IHRlc3RzLiAqL1xuXG5pbXBvcnQgeyBpbmplY3QgfSBmcm9tICd2aXRlc3QnO1xuXG5pbXBvcnQge1xuICBzZXRTZXR1cEVycm9yUmVzb2x2ZXIsXG4gIHNldFRyYW5zcG9ydE9wdGlvbnNSZXNvbHZlcixcbiAgc2V0VmF1bHRQYXRoUmVzb2x2ZXJcbn0gZnJvbSAnLi4vY29udGV4dC1wcm92aWRlci5tanMnO1xuXG5zZXRTZXR1cEVycm9yUmVzb2x2ZXIoKCkgPT4gaW5qZWN0KCdzZXR1cEVycm9yJykpO1xuc2V0VHJhbnNwb3J0T3B0aW9uc1Jlc29sdmVyKCgpID0+IGluamVjdCgnb2JzaWRpYW5UcmFuc3BvcnQnKSk7XG5zZXRWYXVsdFBhdGhSZXNvbHZlcigoKSA9PiBpbmplY3QoJ3RlbXBvcmFyeVZhdWx0UGF0aCcpKTtcblxuLyogdjggaWdub3JlIHN0b3AgKi9cbiJdLAogICJtYXBwaW5ncyI6ICJBQW9CQSxTQUFTLGNBQWM7QUFFdkI7QUFBQSxFQUNFO0FBQUEsRUFDQTtBQUFBLEVBQ0E7QUFBQSxPQUNLO0FBRVAsc0JBQXNCLE1BQU0sT0FBTyxZQUFZLENBQUM7QUFDaEQsNEJBQTRCLE1BQU0sT0FBTyxtQkFBbUIsQ0FBQztBQUM3RCxxQkFBcUIsTUFBTSxPQUFPLG9CQUFvQixDQUFDOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/esm/vitest/typings.d.mts

@@ -11,6 +11,7 @@
  * and `inject('obsidianTransport')` / `inject('temporaryVaultPath')`.
  */
 
+import type { IntegrationSetupFailedErrorConstructorParams } from '../integration-setup-failed-error.mjs';
 import type { ObsidianTransportOptions } from '../transport-options.mjs';
 
 // eslint-disable-next-line import-x/no-unassigned-import -- Forces module resolution so declare module augmentations merge correctly.
@@ -27,11 +28,12 @@ declare module 'vitest' {
     obsidianTransport?: ObsidianTransportOptions;
 
     /**
-     * Serialized error message from global setup failure.
-     * Present only when setup failed — tests should check this
-     * before attempting to use the temp vault or transport.
+     * The global setup's failure, serialized for the workers. Present only when
+     * setup failed; the per-worker setup file registers it as the setup-error
+     * resolver, and `getOrCreateTransport` throws it rather than let a worker
+     * build a transport the project never asked for.
      */
-    setupError?: string;
+    setupError?: IntegrationSetupFailedErrorConstructorParams;
 
     /**
      * Path to the temporary vault created by the global setup.

package/dist/lib/esm/webview-cdp.d.mts

@@ -0,0 +1,152 @@
+/**
+ * @file
+ *
+ * A second, independent Chrome DevTools Protocol connection to Obsidian Mobile's WebView, used to inject
+ * **trusted** input on Android (see **L39**).
+ *
+ * It is deliberately separate from the Appium session rather than layered on it. `AppiumTransport.evaluate`
+ * runs the whole `evalInObsidian` closure inside one W3C *Execute Script*, which awaits the returned
+ * promise — so while a closure sits waiting on `lib.clickElement(...)`, the WebDriver session is busy and
+ * cannot be asked to do anything else. CDP is id-multiplexed and Chromium accepts multiple debugger
+ * clients, so this socket stays free exactly when the Appium one does not. That is what lets the renderer
+ * call back out to the host mid-closure.
+ *
+ * Reaching the WebView's debugger is a two-step: the app publishes an abstract unix socket named
+ * `webview_devtools_remote_<pid>`, `adb forward` maps it to a local TCP port, and the usual `/json`
+ * endpoint then lists the page targets.
+ */
+import type { CdpInputCommand } from './mobile-input.mjs';
+/**
+ * One entry of the debugger's `/json` target list.
+ */
+export interface CdpTarget {
+    readonly title?: string;
+    readonly type?: string;
+    readonly url?: string;
+    readonly webSocketDebuggerUrl?: string;
+}
+/**
+ * Parameters for {@link connectToWebViewCdp}.
+ */
+export interface ConnectToWebViewCdpParams {
+    /**
+     * The Android application id whose WebView to attach to, e.g. `md.obsidian`.
+     */
+    readonly appId: string;
+    /**
+     * The adb device id (`emulator-5554`, a serial) to run adb against.
+     */
+    readonly deviceId: string;
+}
+/**
+ * Handles a CDP event.
+ */
+type CdpEventHandler = (params: Record<string, unknown>) => void;
+/**
+ * An open CDP connection to a WebView.
+ *
+ * Commands are id-multiplexed, so a command issued from inside an event handler completes while an earlier
+ * `Runtime.evaluate` is still awaiting its promise — which is the whole reason this class exists.
+ */
+export declare class WebViewCdpConnection {
+    private readonly webSocket;
+    private readonly deviceId;
+    private readonly port;
+    /**
+     * Whether the socket is still usable.
+     *
+     * Restarting the app tears its WebView down and takes the debugger target with it, so a cached
+     * connection has to be re-checked rather than assumed live.
+     *
+     * @returns `true` while the socket is open.
+     */
+    get isOpen(): boolean;
+    private readonly eventHandlers;
+    private messageId;
+    /**
+     * Wraps an already-open debugger socket, plus what is needed to tear its port forward down.
+     *
+     * @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.
+     */
+    constructor(webSocket: WebSocket, deviceId: string, port: number);
+    /**
+     * Closes the socket and drops the adb port forward.
+     */
+    dispose(): Promise<void>;
+    /**
+     * Synchronous disposal, for `process.on('exit')` handlers where async work cannot run.
+     *
+     * Without this an abrupt worker exit leaves the port forward behind — the async {@link dispose} above
+     * never gets a turn.
+     */
+    disposeSync(): void;
+    /**
+     * Subscribes to a CDP event. One handler per method; subscribing again replaces it.
+     *
+     * @param method - The CDP event name, e.g. `Runtime.bindingCalled`.
+     * @param handler - Called with the event parameters.
+     */
+    on(method: string, handler: CdpEventHandler): void;
+    /**
+     * Sends a CDP command and waits for its response.
+     *
+     * @param method - The CDP method name.
+     * @param params - The CDP method parameters.
+     * @returns The command result.
+     */
+    send(method: string, params?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /**
+     * Sends an ordered command sequence, honoring each command's delay.
+     *
+     * @param commands - The commands to send, in order.
+     */
+    sendAll(commands: readonly CdpInputCommand[]): Promise<void>;
+    /**
+     * Closes the debugger socket and stops routing its events.
+     */
+    private closeSocket;
+}
+/**
+ * Opens a CDP connection to the app's WebView.
+ *
+ * @param params - Which app on which device.
+ * @returns The open connection. Dispose it to close the socket and drop the adb port forward.
+ */
+export declare function connectToWebViewCdp(params: ConnectToWebViewCdpParams): Promise<WebViewCdpConnection>;
+/**
+ * Finds a port already forwarded to this device socket, so repeated runs reuse one forward.
+ *
+ * Without this every run allocates a fresh port, and any run that exits without the async
+ * {@link WebViewCdpConnection.dispose} — an abrupt worker exit, where only the synchronous teardown
+ * path runs — leaves its forward behind forever. Reuse bounds that to a single forward per socket
+ * rather than one per run.
+ *
+ * @param forwardList - The output of `adb forward --list`.
+ * @param deviceId - The adb device id to match.
+ * @param socketName - The abstract socket name to match.
+ * @returns The already-forwarded local port, or `undefined` when there is none.
+ */
+export declare function parseForwardedPort(forwardList: string, deviceId: string, socketName: string): number | undefined;
+/**
+ * Picks the WebView's devtools socket name out of `/proc/net/unix`.
+ *
+ * A device can host several debuggable WebViews (other apps, a leftover process), so the app's own pid is
+ * what disambiguates them. When no socket matches that pid the sole remaining candidate is used — a
+ * WebView whose socket is named after a child process rather than the one `pidof` reported still has to be
+ * reachable — but two unattributable candidates is ambiguous enough to refuse.
+ *
+ * @param procNetUnix - The contents of `/proc/net/unix`.
+ * @param pid - The application's process id.
+ * @returns The socket name, e.g. `webview_devtools_remote_18056`.
+ */
+export declare function parseWebViewDevtoolsSocketName(procNetUnix: string, pid: string): string;
+/**
+ * Picks the Obsidian page target out of the debugger's `/json` list.
+ *
+ * @param targets - The `/json` response.
+ * @returns The page target to attach to.
+ */
+export declare function selectWebViewPageTarget(targets: readonly CdpTarget[]): CdpTarget;
+export {};

package/dist/lib/esm/webview-cdp.mjs

@@ -0,0 +1,236 @@
+import { execFileSync } from "node:child_process";
+import { exec } from "./exec.mjs";
+import { log } from "./log.mjs";
+import { pickFreePort } from "./obsidian-instance.mjs";
+const ADB_TIMEOUT_IN_MILLISECONDS = 15e3;
+const FORWARD_LIST_COLUMN_COUNT = 3;
+const DECIMAL_RADIX = 10;
+const CDP_COMMAND_TIMEOUT_IN_MILLISECONDS = 3e4;
+const CDP_HOST = "127.0.0.1";
+class WebViewCdpConnection {
+  /**
+   * Wraps an already-open debugger socket, plus what is needed to tear its port forward down.
+   *
+   * @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.
+   */
+  constructor(webSocket, deviceId, port) {
+    this.webSocket = webSocket;
+    this.deviceId = deviceId;
+    this.port = port;
+    this.webSocket.addEventListener("message", (event) => {
+      const message = JSON.parse(String(event.data));
+      if (message.method === void 0) {
+        return;
+      }
+      this.eventHandlers.get(message.method)?.(message.params ?? {});
+    });
+  }
+  webSocket;
+  deviceId;
+  port;
+  /**
+   * Whether the socket is still usable.
+   *
+   * Restarting the app tears its WebView down and takes the debugger target with it, so a cached
+   * connection has to be re-checked rather than assumed live.
+   *
+   * @returns `true` while the socket is open.
+   */
+  get isOpen() {
+    return this.webSocket.readyState === WebSocket.OPEN;
+  }
+  eventHandlers = /* @__PURE__ */ new Map();
+  messageId = 0;
+  /**
+   * Closes the socket and drops the adb port forward.
+   */
+  async dispose() {
+    this.closeSocket();
+    await removeForward(this.deviceId, this.port);
+  }
+  /**
+   * Synchronous disposal, for `process.on('exit')` handlers where async work cannot run.
+   *
+   * Without this an abrupt worker exit leaves the port forward behind — the async {@link dispose} above
+   * never gets a turn.
+   */
+  disposeSync() {
+    this.closeSocket();
+    try {
+      execFileSync("adb", ["-s", this.deviceId, "forward", "--remove", `tcp:${String(this.port)}`], {
+        stdio: "ignore",
+        timeout: ADB_TIMEOUT_IN_MILLISECONDS
+      });
+    } catch {
+    }
+  }
+  /**
+   * Subscribes to a CDP event. One handler per method; subscribing again replaces it.
+   *
+   * @param method - The CDP event name, e.g. `Runtime.bindingCalled`.
+   * @param handler - Called with the event parameters.
+   */
+  on(method, handler) {
+    this.eventHandlers.set(method, handler);
+  }
+  /**
+   * Sends a CDP command and waits for its response.
+   *
+   * @param method - The CDP method name.
+   * @param params - The CDP method parameters.
+   * @returns The command result.
+   */
+  send(method, params = {}) {
+    const id = ++this.messageId;
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.webSocket.removeEventListener("message", handler);
+        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;
+        }
+        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 }));
+    });
+  }
+  /**
+   * Sends an ordered command sequence, honoring each command's delay.
+   *
+   * @param commands - The commands to send, in order.
+   */
+  async sendAll(commands) {
+    for (const command of commands) {
+      if (command.delayBeforeInMilliseconds !== void 0) {
+        await new Promise((resolve) => {
+          setTimeout(resolve, command.delayBeforeInMilliseconds);
+        });
+      }
+      await this.send(command.method, command.params);
+    }
+  }
+  /**
+   * Closes the debugger socket and stops routing its events.
+   */
+  closeSocket() {
+    this.eventHandlers.clear();
+    if (this.webSocket.readyState === WebSocket.OPEN) {
+      this.webSocket.close();
+    }
+  }
+}
+async function connectToWebViewCdp(params) {
+  const { appId, deviceId } = params;
+  const pidofOutput = await adb(deviceId, ["shell", "pidof", appId]);
+  const pid = pidofOutput.split(/\s+/, 1)[0] ?? "";
+  if (!pid) {
+    throw new Error(`${appId} is not running on ${deviceId}, so its WebView has no debugger to attach to.`);
+  }
+  const procNetUnix = await adb(deviceId, ["shell", "cat", "/proc/net/unix"]);
+  const socketName = parseWebViewDevtoolsSocketName(procNetUnix, pid);
+  const forwardList = await adb(deviceId, ["forward", "--list"]);
+  const existingPort = parseForwardedPort(forwardList, deviceId, socketName);
+  const port = existingPort ?? await pickFreePort();
+  if (existingPort === void 0) {
+    await adb(deviceId, ["forward", `tcp:${String(port)}`, `localabstract:${socketName}`]);
+    log(`[webview-cdp] Forwarded tcp:${String(port)} -> localabstract:${socketName} (${appId} pid ${pid})`);
+  } else {
+    log(`[webview-cdp] Reusing forward tcp:${String(port)} -> localabstract:${socketName} (${appId} pid ${pid})`);
+  }
+  try {
+    const response = await fetch(`http://${CDP_HOST}:${String(port)}/json`);
+    const target = selectWebViewPageTarget(await response.json());
+    const webSocket = new WebSocket(target.webSocketDebuggerUrl ?? "");
+    await new Promise((resolve, reject) => {
+      webSocket.addEventListener("open", () => {
+        resolve();
+      }, { once: true });
+      webSocket.addEventListener("error", () => {
+        reject(new Error(`Could not open the WebView CDP socket at ${target.webSocketDebuggerUrl ?? ""}.`));
+      }, { once: true });
+    });
+    log(`[webview-cdp] Attached to WebView target "${target.title ?? ""}"`);
+    return new WebViewCdpConnection(webSocket, deviceId, port);
+  } catch (error) {
+    await removeForward(deviceId, port);
+    throw error;
+  }
+}
+function parseForwardedPort(forwardList, deviceId, socketName) {
+  for (const line of forwardList.split("\n")) {
+    const [lineDeviceId, local, remote] = line.trim().split(/\s+/, FORWARD_LIST_COLUMN_COUNT);
+    if (lineDeviceId !== deviceId || remote !== `localabstract:${socketName}` || !local?.startsWith("tcp:")) {
+      continue;
+    }
+    const port = Number.parseInt(local.slice("tcp:".length), DECIMAL_RADIX);
+    if (Number.isSafeInteger(port)) {
+      return port;
+    }
+  }
+  return void 0;
+}
+function parseWebViewDevtoolsSocketName(procNetUnix, pid) {
+  const names = [
+    ...new Set([...procNetUnix.matchAll(/@webview_devtools_remote_\w+/g)].map((match) => match[0].slice("@".length)))
+  ];
+  const [soleName, ...otherNames] = names;
+  if (soleName === void 0) {
+    throw new Error(
+      "No `webview_devtools_remote_*` socket on the device. Obsidian Mobile is not running, or its WebView debugger is disabled."
+    );
+  }
+  const exactName = `webview_devtools_remote_${pid}`;
+  if (names.includes(exactName)) {
+    return exactName;
+  }
+  if (otherNames.length === 0) {
+    return soleName;
+  }
+  throw new Error(
+    `No \`${exactName}\` socket, and ${String(names.length)} other debuggable WebViews are present (${names.join(", ")}), so the right one cannot be chosen.`
+  );
+}
+function selectWebViewPageTarget(targets) {
+  const target = targets.find((candidate) => candidate.type === "page" && Boolean(candidate.webSocketDebuggerUrl)) ?? targets.find((candidate) => Boolean(candidate.webSocketDebuggerUrl));
+  if (!target) {
+    throw new Error("The WebView debugger listed no target with a WebSocket endpoint.");
+  }
+  return target;
+}
+async function adb(deviceId, commandArguments) {
+  const stdout = await exec(["adb", "-s", deviceId, ...commandArguments], {
+    isQuiet: true,
+    timeoutInMilliseconds: ADB_TIMEOUT_IN_MILLISECONDS
+  });
+  return stdout.trim();
+}
+async function removeForward(deviceId, port) {
+  try {
+    await exec(["adb", "-s", deviceId, "forward", "--remove", `tcp:${String(port)}`], {
+      isQuiet: true,
+      shouldIgnoreExitCode: true,
+      timeoutInMilliseconds: ADB_TIMEOUT_IN_MILLISECONDS
+    });
+  } catch {
+  }
+}
+export {
+  WebViewCdpConnection,
+  connectToWebViewCdp,
+  parseForwardedPort,
+  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.mjs';\n\nimport { exec } from './exec.mjs';\nimport { log } from './log.mjs';\nimport { pickFreePort } from './obsidian-instance.mjs';\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, honoring each command's delay.\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      if (command.delayBeforeInMilliseconds !== undefined) {\n        await new Promise<void>((resolve) => {\n          setTimeout(resolve, command.delayBeforeInMilliseconds);\n        });\n      }\n\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": []
}
