obsidian-integration-testing 11.0.0 → 12.0.0

package/dist/lib/cjs/integration-setup-failed-error.cjs

@@ -0,0 +1,62 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var integration_setup_failed_error_exports = {};
+__export(integration_setup_failed_error_exports, {
+  IntegrationSetupFailedError: () => IntegrationSetupFailedError
+});
+module.exports = __toCommonJS(integration_setup_failed_error_exports);
+class IntegrationSetupFailedError extends Error {
+  /**
+  The `name` of the original error the global setup threw.
+   */
+  errorName;
+  /**
+  The original setup failure, as stringified by the adapter that caught it.
+   */
+  originalMessage;
+  /**
+  The transport the failed project is configured for.
+   */
+  transportLabel;
+  /**
+   * Creates the error from the failure the global setup published to its workers.
+   *
+   * @param params - The configured transport plus the original error's name and message.
+   */
+  constructor(params) {
+    const {
+      errorName,
+      message,
+      transportLabel
+    } = params;
+    super(
+      `Integration setup for transport "${transportLabel}" failed, so its tests cannot run. Original error: ${message}`
+    );
+    this.name = "IntegrationSetupFailedError";
+    this.errorName = errorName;
+    this.originalMessage = message;
+    this.transportLabel = transportLabel;
+    this.stack = `${this.name}: ${this.message}`;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IntegrationSetupFailedError
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/integration-setup-failed-error.d.cts

@@ -0,0 +1,66 @@
+/**
+ * @file
+ *
+ * The distinct error thrown in a **test worker** when that project's integration
+ * global setup already failed in the main process.
+ *
+ * Without it a worker whose setup failed gets no transport options at all, and
+ * silently rebuilds the owned **desktop** CDP default — so an Android project's
+ * suite would run on desktop, and then die on `Failed to parse URL from /json`
+ * (an owned instance nobody launched has no CDP endpoint). Every file in the
+ * project reported that mask while the real cause appeared once, far above, in
+ * the setup log. This error replaces the mask: it is raised before any transport
+ * is constructed, and it carries the original setup failure verbatim, so each
+ * report names the actual cause.
+ *
+ * It deliberately carries no stack trace: the failure happened in the global
+ * setup, which already logged its own trace, and a second trace pointing into
+ * the harness only suggests the harness broke.
+ */
+/**
+ * Parameters for the {@link IntegrationSetupFailedError} constructor. This is also the
+ * shape the framework adapter publishes to its workers (Vitest: `provide('setupError')`).
+ */
+export interface IntegrationSetupFailedErrorConstructorParams {
+    /**
+    The `name` of the original error the global setup threw, so a caller can tell an
+    expected skip (`DesktopOnlyPluginSkipError`) from a real breakage without the
+    original error object, which does not survive the trip to a worker.
+     */
+    readonly errorName: string;
+    /**
+    The original setup failure, already stringified by the adapter that caught it.
+     */
+    readonly message: string;
+    /**
+    The transport the failed project is configured for (e.g. `obsidian-android-appium`),
+    so the report names the platform the suite was meant to run on.
+     */
+    readonly transportLabel: string;
+}
+/**
+ * Thrown when a test worker asks for the ambient transport of a project whose
+ * global setup failed. Carries the configured transport, the original error's
+ * `name`, and its message, so callers can `instanceof`-match and report the real
+ * cause instead of a downstream transport error.
+ */
+export declare class IntegrationSetupFailedError extends Error {
+    /**
+    The `name` of the original error the global setup threw.
+     */
+    readonly errorName: string;
+    /**
+    The original setup failure, as stringified by the adapter that caught it.
+     */
+    readonly originalMessage: string;
+    /**
+    The transport the failed project is configured for.
+     */
+    readonly transportLabel: string;
+    /**
+     * Creates the error from the failure the global setup published to its workers.
+     *
+     * @param params - The configured transport plus the original error's name and message.
+     */
+    constructor(params: IntegrationSetupFailedErrorConstructorParams);
+}

package/dist/lib/cjs/jest/global-setup.cjs

@@ -39,7 +39,7 @@ function createSetup(options) {
     setupResult = await (0, import_global_setup_core.coreSetup)({
       enableCommunityPlugins: options?.enableCommunityPlugins,
       installPlugin: options?.installPlugin,
-      populate: options?.populate?.(),
+      populate: await options?.populate?.(),
       transportOptions
     });
     globalThis.__obsidianIntegrationTesting = {
@@ -76,4 +76,4 @@ var global_setup_default = setup;
   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.cjs';\nimport type { PopulateFilesParams } from '../temporary-vault.cjs';\nimport type { ObsidianTransportOptions } from '../transport-options.cjs';\n\nimport {\n  setTransportOptionsResolver,\n  setVaultPathResolver\n} from '../context-provider.cjs';\nimport {\n  coreSetup,\n  coreTeardown\n} from '../global-setup-core.cjs';\nimport { TemporaryVault } from '../temporary-vault.cjs';\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 `temporaryVaultPath`.\n */\ninterface ObsidianIntegrationTestingGlobal {\n  /**\n  Temp vault path, set by the global setup for test workers.\n   */\n  temporaryVaultPath?: string | undefined;\n\n  /**\n  Transport options. Set by the consumer before setup, or by the setup itself.\n   */\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?.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 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      temporaryVaultPath: setupResult.temporaryVault.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.temporaryVaultPath`,\n * which is set by the Jest global setup.\n *\n * @returns The temporary vault.\n */\nexport function getTemporaryVault(): TemporaryVault {\n  const temporaryVaultPath = globalThis.__obsidianIntegrationTesting?.temporaryVaultPath;\n  if (!temporaryVaultPath) {\n    throw new Error(\n      'globalThis.__obsidianIntegrationTesting.temporaryVaultPath is not set. Did you configure obsidian-integration-testing/jest-global-setup as a Jest globalSetup?'\n    );\n  }\n  return new TemporaryVault(temporaryVaultPath);\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": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAeA,8BAGO;AACP,+BAGO;AACP,6BAA+B;AAAA,IA8B/B,qDAA4B,MAAM,WAAW,8BAA8B,gBAAgB;AAAA,IAC3F,8CAAqB,MAAM,WAAW,8BAA8B,kBAAkB;AAkD/E,SAAS,YAAY,SAA+C;AACzE,MAAI;AAEJ,SAAO,EAAE,OAAAA,QAAO,UAAAC,UAAS;AAEzB,iBAAeD,SAAuB;AACpC,UAAM,mBAAmB,WAAW,8BAA8B;AAElE,kBAAc,UAAM,oCAAU;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,oBAAoB,YAAY,eAAe;AAAA,MAC/C,kBAAkB,YAAY;AAAA,IAChC;AAAA,EACF;AAEA,iBAAeC,YAA0B;AACvC,cAAM,uCAAa,WAAW;AAAA,EAChC;AACF;AAUO,SAAS,oBAAoC;AAClD,QAAM,qBAAqB,WAAW,8BAA8B;AACpE,MAAI,CAAC,oBAAoB;AACvB,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,SAAO,IAAI,sCAAe,kBAAkB;AAC9C;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.cjs';\nimport type { PopulateFilesParams } from '../temporary-vault.cjs';\nimport type { ObsidianTransportOptions } from '../transport-options.cjs';\n\nimport {\n  setTransportOptionsResolver,\n  setVaultPathResolver\n} from '../context-provider.cjs';\nimport {\n  coreSetup,\n  coreTeardown\n} from '../global-setup-core.cjs';\nimport { TemporaryVault } from '../temporary-vault.cjs';\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 `temporaryVaultPath`.\n */\ninterface ObsidianIntegrationTestingGlobal {\n  /**\n  Temp vault path, set by the global setup for test workers.\n   */\n  temporaryVaultPath?: string | undefined;\n\n  /**\n  Transport options. Set by the consumer before setup, or by the setup itself.\n   */\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?.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 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: await options?.populate?.(),\n      transportOptions\n    });\n\n    globalThis.__obsidianIntegrationTesting = {\n      ...globalThis.__obsidianIntegrationTesting,\n      temporaryVaultPath: setupResult.temporaryVault.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.temporaryVaultPath`,\n * which is set by the Jest global setup.\n *\n * @returns The temporary vault.\n */\nexport function getTemporaryVault(): TemporaryVault {\n  const temporaryVaultPath = globalThis.__obsidianIntegrationTesting?.temporaryVaultPath;\n  if (!temporaryVaultPath) {\n    throw new Error(\n      'globalThis.__obsidianIntegrationTesting.temporaryVaultPath is not set. Did you configure obsidian-integration-testing/jest-global-setup as a Jest globalSetup?'\n    );\n  }\n  return new TemporaryVault(temporaryVaultPath);\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": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAeA,8BAGO;AACP,+BAGO;AACP,6BAA+B;AAAA,IA8B/B,qDAA4B,MAAM,WAAW,8BAA8B,gBAAgB;AAAA,IAC3F,8CAAqB,MAAM,WAAW,8BAA8B,kBAAkB;AAsD/E,SAAS,YAAY,SAA+C;AACzE,MAAI;AAEJ,SAAO,EAAE,OAAAA,QAAO,UAAAC,UAAS;AAEzB,iBAAeD,SAAuB;AACpC,UAAM,mBAAmB,WAAW,8BAA8B;AAElE,kBAAc,UAAM,oCAAU;AAAA,MAC5B,wBAAwB,SAAS;AAAA,MACjC,eAAe,SAAS;AAAA,MACxB,UAAU,MAAM,SAAS,WAAW;AAAA,MACpC;AAAA,IACF,CAAC;AAED,eAAW,+BAA+B;AAAA,MACxC,GAAG,WAAW;AAAA,MACd,oBAAoB,YAAY,eAAe;AAAA,MAC/C,kBAAkB,YAAY;AAAA,IAChC;AAAA,EACF;AAEA,iBAAeC,YAA0B;AACvC,cAAM,uCAAa,WAAW;AAAA,EAChC;AACF;AAUO,SAAS,oBAAoC;AAClD,QAAM,qBAAqB,WAAW,8BAA8B;AACpE,MAAI,CAAC,oBAAoB;AACvB,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,SAAO,IAAI,sCAAe,kBAAkB;AAC9C;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/cjs/jest/global-setup.d.cts

@@ -56,8 +56,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 Jest `globalSetup` / `globalTeardown` module's `setup` / `teardown` pair.

package/dist/lib/cjs/kill-process-tree.cjs

@@ -28,7 +28,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var kill_process_tree_exports = {};
 __export(kill_process_tree_exports, {
-  killProcessTree: () => killProcessTree
+  killProcessTree: () => killProcessTree,
+  killProcessTreeByPid: () => killProcessTreeByPid
 });
 module.exports = __toCommonJS(kill_process_tree_exports);
 var import_node_child_process = require("node:child_process");
@@ -38,20 +39,30 @@ function killProcessTree(child) {
   if (child.pid === void 0) {
     return;
   }
+  killProcessTreeByPid(child.pid);
+}
+function killProcessTreeByPid(pid) {
   if (import_node_process.default.platform === "win32") {
     try {
-      (0, import_node_child_process.execFileSync)("taskkill", ["/F", "/T", "/PID", String(child.pid)], { stdio: "ignore" });
+      (0, import_node_child_process.execFileSync)("taskkill", ["/F", "/T", "/PID", String(pid)], { stdio: "ignore" });
     } catch (error) {
       (0, import_log.log)(
-        `[kill-process-tree] taskkill for PID ${String(child.pid)} failed (may have already exited): ${error instanceof Error ? error.message : "unknown error"}`
+        `[kill-process-tree] taskkill for PID ${String(pid)} failed (may have already exited): ${error instanceof Error ? error.message : "unknown error"}`
       );
     }
-  } else {
-    child.kill("SIGKILL");
+    return;
+  }
+  try {
+    import_node_process.default.kill(pid, "SIGKILL");
+  } catch (error) {
+    (0, import_log.log)(
+      `[kill-process-tree] SIGKILL for PID ${String(pid)} failed (may have already exited): ${error instanceof Error ? error.message : "unknown error"}`
+    );
   }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  killProcessTree
+  killProcessTree,
+  killProcessTreeByPid
 });
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2tpbGwtcHJvY2Vzcy10cmVlLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogQ3Jvc3MtcGxhdGZvcm0gaGVscGVyIHRvIGtpbGwgYSBjaGlsZCBwcm9jZXNzIGFuZCBpdHMgZW50aXJlIHByb2Nlc3MgdHJlZS5cbiAqL1xuXG4vKiB2OCBpZ25vcmUgc3RhcnQgLS0gSW50ZWdyYXRpb24tdGltZSBwcm9jZXNzIG1hbmFnZW1lbnQgY292ZXJlZCBieSBpbnRlZ3JhdGlvbiB0ZXN0cywgbm90IHVuaXQgdGVzdHMuICovXG5cbmltcG9ydCB0eXBlIHsgQ2hpbGRQcm9jZXNzIH0gZnJvbSAnbm9kZTpjaGlsZF9wcm9jZXNzJztcblxuaW1wb3J0IHsgZXhlY0ZpbGVTeW5jIH0gZnJvbSAnbm9kZTpjaGlsZF9wcm9jZXNzJztcbmltcG9ydCBwcm9jZXNzIGZyb20gJ25vZGU6cHJvY2Vzcyc7XG5cbmltcG9ydCB7IGxvZyB9IGZyb20gJy4vbG9nLmNqcyc7XG5cbi8qKlxuICogS2lsbHMgYSBjaGlsZCBwcm9jZXNzIGFuZCBpdHMgZW50aXJlIHByb2Nlc3MgdHJlZS5cbiAqXG4gKiBPbiBXaW5kb3dzLCBgY2hpbGQua2lsbCgpYCBvbmx5IHNlbmRzIFNJR1RFUk0gdG8gdGhlIGRpcmVjdCBwcm9jZXNzLFxuICogbGVhdmluZyBzcGF3bmVkIGdyYW5kY2hpbGRyZW4gKGUuZy4gRWxlY3Ryb24gcmVuZGVyZXIvR1BVIGhlbHBlcnMsIFFFTVUsXG4gKiBVaUF1dG9tYXRvcikgYWxpdmUuIGB0YXNra2lsbCAvRiAvVCAvUElEYCBmb3JjZWZ1bGx5IHRlcm1pbmF0ZXMgdGhlIGVudGlyZSB0cmVlLlxuICpcbiAqIEBwYXJhbSBjaGlsZCAtIFRoZSBjaGlsZCBwcm9jZXNzIHRvIGtpbGwuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBraWxsUHJvY2Vzc1RyZWUoY2hpbGQ6IENoaWxkUHJvY2Vzcyk6IHZvaWQge1xuICBpZiAoY2hpbGQucGlkID09PSB1bmRlZmluZWQpIHtcbiAgICByZXR1cm47XG4gIH1cblxuICBpZiAocHJvY2Vzcy5wbGF0Zm9ybSA9PT0gJ3dpbjMyJykge1xuICAgIHRyeSB7XG4gICAgICBleGVjRmlsZVN5bmMoJ3Rhc2traWxsJywgWycvRicsICcvVCcsICcvUElEJywgU3RyaW5nKGNoaWxkLnBpZCldLCB7IHN0ZGlvOiAnaWdub3JlJyB9KTtcbiAgICB9IGNhdGNoIChlcnJvcjogdW5rbm93bikge1xuICAgICAgbG9nKFxuICAgICAgICBgW2tpbGwtcHJvY2Vzcy10cmVlXSB0YXNra2lsbCBmb3IgUElEICR7U3RyaW5nKGNoaWxkLnBpZCl9IGZhaWxlZCAobWF5IGhhdmUgYWxyZWFkeSBleGl0ZWQpOiAke2Vycm9yIGluc3RhbmNlb2YgRXJyb3IgPyBlcnJvci5tZXNzYWdlIDogJ3Vua25vd24gZXJyb3InfWBcbiAgICAgICk7XG4gICAgfVxuICB9IGVsc2Uge1xuICAgIGNoaWxkLmtpbGwoJ1NJR0tJTEwnKTtcbiAgfVxufVxuXG4vKiB2OCBpZ25vcmUgc3RvcCAqL1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFVQSxnQ0FBNkI7QUFDN0IsMEJBQW9CO0FBRXBCLGlCQUFvQjtBQVdiLFNBQVMsZ0JBQWdCLE9BQTJCO0FBQ3pELE1BQUksTUFBTSxRQUFRLFFBQVc7QUFDM0I7QUFBQSxFQUNGO0FBRUEsTUFBSSxvQkFBQUEsUUFBUSxhQUFhLFNBQVM7QUFDaEMsUUFBSTtBQUNGLGtEQUFhLFlBQVksQ0FBQyxNQUFNLE1BQU0sUUFBUSxPQUFPLE1BQU0sR0FBRyxDQUFDLEdBQUcsRUFBRSxPQUFPLFNBQVMsQ0FBQztBQUFBLElBQ3ZGLFNBQVMsT0FBZ0I7QUFDdkI7QUFBQSxRQUNFLHdDQUF3QyxPQUFPLE1BQU0sR0FBRyxDQUFDLHNDQUFzQyxpQkFBaUIsUUFBUSxNQUFNLFVBQVUsZUFBZTtBQUFBLE1BQ3pKO0FBQUEsSUFDRjtBQUFBLEVBQ0YsT0FBTztBQUNMLFVBQU0sS0FBSyxTQUFTO0FBQUEsRUFDdEI7QUFDRjsiLAogICJuYW1lcyI6IFsicHJvY2VzcyJdCn0K
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/kill-process-tree.d.cts

@@ -7,10 +7,18 @@ import type { ChildProcess } from 'node:child_process';
 /**
  * Kills a child process and its entire process tree.
  *
+ * @param child - The child process to kill.
+ */
+export declare function killProcessTree(child: ChildProcess): void;
+/**
+ * Kills a process tree by PID, for a process this run did not spawn itself — an
+ * Appium server left listening by an earlier run, identified through its marker
+ * (`appium-server-marker.ts`).
+ *
  * On Windows, `child.kill()` only sends SIGTERM to the direct process,
  * leaving spawned grandchildren (e.g. Electron renderer/GPU helpers, QEMU,
  * UiAutomator) alive. `taskkill /F /T /PID` forcefully terminates the entire tree.
  *
- * @param child - The child process to kill.
+ * @param pid - The PID whose process tree to kill.
  */
-export declare function killProcessTree(child: ChildProcess): void;
+export declare function killProcessTreeByPid(pid: number): void;

package/dist/lib/cjs/library.cjs

@@ -21,7 +21,7 @@ __export(library_exports, {
   LIBRARY_VERSION: () => LIBRARY_VERSION
 });
 module.exports = __toCommonJS(library_exports);
-const LIBRARY_VERSION = false ? "dev" : "11.0.0";
+const LIBRARY_VERSION = false ? "dev" : "12.0.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LIBRARY_VERSION

package/dist/lib/cjs/mobile-input.cjs

@@ -0,0 +1,161 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mobile_input_exports = {};
+__export(mobile_input_exports, {
+  MOBILE_INPUT_BINDING_NAME: () => MOBILE_INPUT_BINDING_NAME,
+  MOBILE_INPUT_TIMEOUT_IN_MILLISECONDS: () => MOBILE_INPUT_TIMEOUT_IN_MILLISECONDS,
+  buildResolveInputExpression: () => buildResolveInputExpression,
+  codePointOf: () => codePointOf,
+  toCdpInputCommands: () => toCdpInputCommands,
+  toCdpModifiers: () => toCdpModifiers
+});
+module.exports = __toCommonJS(mobile_input_exports);
+const MOBILE_INPUT_BINDING_NAME = "__obsidianIntegrationTestingInput";
+const MOBILE_INPUT_TIMEOUT_IN_MILLISECONDS = 15e3;
+const LONG_PRESS_DWELL_IN_MILLISECONDS = 600;
+const NO_MODIFIERS = 0;
+const MODIFIER_BIT_ALT = 1;
+const MODIFIER_BIT_CONTROL = 2;
+const MODIFIER_BIT_META = 4;
+const MODIFIER_BIT_SHIFT = 8;
+const CDP_MODIFIER_BIT_BY_NAME = /* @__PURE__ */ new Map([
+  ["alt", MODIFIER_BIT_ALT],
+  ["control", MODIFIER_BIT_CONTROL],
+  ["meta", MODIFIER_BIT_META],
+  ["shift", MODIFIER_BIT_SHIFT]
+]);
+const KEY_CODE_BACKSPACE = 8;
+const KEY_CODE_TAB = 9;
+const KEY_CODE_ENTER = 13;
+const KEY_CODE_ESCAPE = 27;
+const KEY_CODE_ARROW_LEFT = 37;
+const KEY_CODE_ARROW_UP = 38;
+const KEY_CODE_ARROW_RIGHT = 39;
+const KEY_CODE_ARROW_DOWN = 40;
+const KEY_CODE_DELETE = 46;
+const NAMED_KEYS = /* @__PURE__ */ new Map([
+  ["ArrowDown", { code: "ArrowDown", windowsVirtualKeyCode: KEY_CODE_ARROW_DOWN }],
+  ["ArrowLeft", { code: "ArrowLeft", windowsVirtualKeyCode: KEY_CODE_ARROW_LEFT }],
+  ["ArrowRight", { code: "ArrowRight", windowsVirtualKeyCode: KEY_CODE_ARROW_RIGHT }],
+  ["ArrowUp", { code: "ArrowUp", windowsVirtualKeyCode: KEY_CODE_ARROW_UP }],
+  ["Backspace", { code: "Backspace", windowsVirtualKeyCode: KEY_CODE_BACKSPACE }],
+  ["Delete", { code: "Delete", windowsVirtualKeyCode: KEY_CODE_DELETE }],
+  ["Enter", { code: "Enter", text: "\r", windowsVirtualKeyCode: KEY_CODE_ENTER }],
+  ["Escape", { code: "Escape", windowsVirtualKeyCode: KEY_CODE_ESCAPE }],
+  ["Tab", { code: "Tab", text: "	", windowsVirtualKeyCode: KEY_CODE_TAB }]
+]);
+const FIRST_CODE_POINT_INDEX = 0;
+const DIGIT_ZERO_CODE_POINT = codePointOf("0");
+const DIGIT_NINE_CODE_POINT = codePointOf("9");
+const UPPERCASE_A_CODE_POINT = codePointOf("A");
+const UPPERCASE_Z_CODE_POINT = codePointOf("Z");
+function buildResolveInputExpression(id, errorMessage) {
+  return `window.__obsidianIntegrationTesting?.resolveInput?.(${JSON.stringify(id)}, ${JSON.stringify(errorMessage ?? null)})`;
+}
+function codePointOf(text) {
+  const codePoint = text.codePointAt(FIRST_CODE_POINT_INDEX);
+  if (codePoint === void 0) {
+    throw new Error("codePointOf received an empty string.");
+  }
+  return codePoint;
+}
+function toCdpInputCommands(request) {
+  if (request.kind === "key") {
+    return toKeyCommands(request);
+  }
+  return toPointerCommands(request);
+}
+function toCdpModifiers(modifiers) {
+  const bits = /* @__PURE__ */ new Set();
+  for (const modifier of modifiers) {
+    const bit = CDP_MODIFIER_BIT_BY_NAME.get(modifier);
+    if (bit !== void 0) {
+      bits.add(bit);
+    }
+  }
+  let bitmask = NO_MODIFIERS;
+  for (const bit of bits) {
+    bitmask += bit;
+  }
+  return bitmask;
+}
+function resolveKey(key) {
+  const namedKey = NAMED_KEYS.get(key);
+  if (namedKey) {
+    return namedKey;
+  }
+  const codePoint = key.codePointAt(FIRST_CODE_POINT_INDEX);
+  if (codePoint === void 0 || String.fromCodePoint(codePoint) !== key) {
+    throw new Error(
+      `pressKey received an unknown key name on mobile: ${JSON.stringify(key)}. Pass a single character or one of: ${[...NAMED_KEYS.keys()].join(", ")}.`
+    );
+  }
+  const upperCasedCodePoint = codePointOf(key.toUpperCase());
+  return {
+    code: resolveKeyCode(upperCasedCodePoint),
+    text: key,
+    windowsVirtualKeyCode: upperCasedCodePoint
+  };
+}
+function resolveKeyCode(upperCasedCodePoint) {
+  if (upperCasedCodePoint >= UPPERCASE_A_CODE_POINT && upperCasedCodePoint <= UPPERCASE_Z_CODE_POINT) {
+    return `Key${String.fromCodePoint(upperCasedCodePoint)}`;
+  }
+  if (upperCasedCodePoint >= DIGIT_ZERO_CODE_POINT && upperCasedCodePoint <= DIGIT_NINE_CODE_POINT) {
+    return `Digit${String.fromCodePoint(upperCasedCodePoint)}`;
+  }
+  return "";
+}
+function toKeyCommands(request) {
+  const { code, text, windowsVirtualKeyCode } = resolveKey(request.key);
+  const modifiers = toCdpModifiers(request.modifiers);
+  const base = { code, key: request.key, modifiers, windowsVirtualKeyCode };
+  const commands = [
+    { method: "Input.dispatchKeyEvent", params: { ...base, type: "rawKeyDown" } }
+  ];
+  if (text !== void 0) {
+    commands.push({ method: "Input.dispatchKeyEvent", params: { ...base, text, type: "char" } });
+  }
+  commands.push({ method: "Input.dispatchKeyEvent", params: { ...base, type: "keyUp" } });
+  return commands;
+}
+function toPointerCommands(request) {
+  const modifiers = toCdpModifiers(request.modifiers);
+  return [
+    {
+      method: "Input.dispatchTouchEvent",
+      params: { modifiers, touchPoints: [{ x: request.x, y: request.y }], type: "touchStart" }
+    },
+    {
+      ...request.kind === "longPress" && { delayBeforeInMilliseconds: LONG_PRESS_DWELL_IN_MILLISECONDS },
+      method: "Input.dispatchTouchEvent",
+      params: { modifiers, touchPoints: [], type: "touchEnd" }
+    }
+  ];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MOBILE_INPUT_BINDING_NAME,
+  MOBILE_INPUT_TIMEOUT_IN_MILLISECONDS,
+  buildResolveInputExpression,
+  codePointOf,
+  toCdpInputCommands,
+  toCdpModifiers
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/mobile-input.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Translates a mobile trusted-input request into the ordered Chrome DevTools Protocol `Input.*` commands\n * that realize it (see **L39**).\n *\n * Pure and synchronous by design: the WebView connection ({@link WebViewCdpConnection}) sends whatever this\n * returns, so every decision that is worth a test \u2014 the touch pair a tap expands into, the dwell a\n * long-press adds, the `rawKeyDown` \u2192 `char` \u2192 `keyUp` shape a key press mirrors from the desktop twin, the\n * modifier bitmask \u2014 lives here rather than inside the transport's I/O path.\n *\n * The request travels renderer \u2192 host as JSON (the renderer computes the coordinates, because only it can\n * see the DOM), so both the request and the command shapes are deliberately plain data.\n */\n\n/**\n * The name of the `Runtime.addBinding` function the host exposes on the page so the renderer can hand it an\n * input request mid-closure.\n *\n * It is passed *into* the serialized bootstrap closure as data rather than referenced from it, because that\n * closure may not read outer scope (**L15**) \u2014 so this stays the single definition.\n */\nexport const MOBILE_INPUT_BINDING_NAME = '__obsidianIntegrationTestingInput';\n\n/**\n * How long the renderer waits for the host to service one input request before giving up.\n *\n * Generous relative to the work (a tap is two CDP commands; a long-press adds a 600ms dwell): the point is\n * to fail with a legible error rather than hang the closure until the whole run times out. Passed into the\n * bootstrap closure as data, for the same reason as {@link MOBILE_INPUT_BINDING_NAME}.\n */\nexport const MOBILE_INPUT_TIMEOUT_IN_MILLISECONDS = 15_000;\n\n/**\n * A single Chrome DevTools Protocol command, plus how long to wait before sending it.\n *\n * The delay is carried here rather than applied by the producer so that the whole sequence stays pure\n * data \u2014 a test asserts the dwell without waiting for it.\n */\nexport interface CdpInputCommand {\n  /**\n   * Milliseconds to wait before sending this command. Absent means \"send immediately\".\n   *\n   * Used only by the long-press dwell.\n   */\n  readonly delayBeforeInMilliseconds?: number;\n\n  /**\n   * The CDP method name, e.g. `Input.dispatchTouchEvent`.\n   */\n  readonly method: string;\n\n  /**\n   * The CDP method parameters.\n   */\n  readonly params: Record<string, unknown>;\n}\n\n/**\n * What the renderer hands to the host binding: one request, plus the id to answer it on.\n *\n * The renderer builds this literal inside the serialized bootstrap closure, which cannot import (**L15**),\n * so the shape is declared here and mirrored there. They are one wire format; change them together.\n */\nexport interface MobileInputEnvelope {\n  /**\n   * The request id the renderer is waiting on.\n   */\n  readonly id: string;\n\n  /**\n   * What to inject.\n   */\n  readonly request: MobileInputRequest;\n}\n\n/**\n * Anything the renderer can ask the host to inject.\n */\nexport type MobileInputRequest = MobileKeyInputRequest | MobilePointerInputRequest;\n\n/**\n * A trusted key press to inject on mobile.\n */\nexport interface MobileKeyInputRequest {\n  /**\n   * The key to press, in the same spelling the desktop twin takes: either a named key\n   * (`Enter`, `Escape`, `Tab`, `Backspace`, `Delete`, an arrow) or a single printable character.\n   */\n  readonly key: string;\n\n  /**\n   * Discriminant.\n   */\n  readonly kind: 'key';\n\n  /**\n   * Modifiers already resolved to their platform-independent lowercase names by the renderer's\n   * `toElectronModifiers` \u2014 the one mapping a key press and a click share, so `'Mod'` cannot mean two\n   * different things (**L17**).\n   */\n  readonly modifiers: readonly string[];\n}\n\n/**\n * A trusted pointer gesture to inject on mobile, in CSS pixels within the WebView's own viewport.\n *\n * No device-pixel conversion is involved: CDP takes page coordinates, so `devicePixelRatio` and the\n * WebView's offset under the status bar never enter the picture (they would for native injection).\n */\nexport interface MobilePointerInputRequest {\n  /**\n   * `tap` is the touch analog of a left click; `longPress` is the mobile context-menu gesture, i.e. what a\n   * desktop right click means here.\n   */\n  readonly kind: 'longPress' | 'tap';\n\n  /**\n   * See {@link MobileKeyInputRequest.modifiers}.\n   */\n  readonly modifiers: readonly string[];\n\n  /**\n   * The viewport x coordinate, in CSS pixels.\n   */\n  readonly x: number;\n\n  /**\n   * The viewport y coordinate, in CSS pixels.\n   */\n  readonly y: number;\n}\n\n/**\n * How long a long-press holds the touch down before releasing it.\n *\n * Obsidian Mobile implements long-press in JavaScript (a timer started on `touchstart`) rather than\n * relying on a native gesture, so this has to clear *its* threshold, not Android's. 600ms is the\n * conventional Android long-press threshold and clears Obsidian's comfortably.\n */\nconst LONG_PRESS_DWELL_IN_MILLISECONDS = 600;\n\nconst NO_MODIFIERS = 0;\nconst MODIFIER_BIT_ALT = 1;\nconst MODIFIER_BIT_CONTROL = 2;\nconst MODIFIER_BIT_META = 4;\nconst MODIFIER_BIT_SHIFT = 8;\n\n/**\n * CDP's modifier bitmask, which is not the same spelling as Electron's string list.\n *\n * @see {@link https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-dispatchKeyEvent}\n */\nconst CDP_MODIFIER_BIT_BY_NAME = new Map<string, number>([\n  ['alt', MODIFIER_BIT_ALT],\n  ['control', MODIFIER_BIT_CONTROL],\n  ['meta', MODIFIER_BIT_META],\n  ['shift', MODIFIER_BIT_SHIFT]\n]);\n\nconst KEY_CODE_BACKSPACE = 8;\nconst KEY_CODE_TAB = 9;\nconst KEY_CODE_ENTER = 13;\nconst KEY_CODE_ESCAPE = 27;\nconst KEY_CODE_ARROW_LEFT = 37;\nconst KEY_CODE_ARROW_UP = 38;\nconst KEY_CODE_ARROW_RIGHT = 39;\nconst KEY_CODE_ARROW_DOWN = 40;\nconst KEY_CODE_DELETE = 46;\n\n/**\n * Named keys, with the `text` a real key press would produce (absent when it produces none).\n *\n * Only keys the fleet actually presses are listed, plus the editing keys a caller would reasonably reach\n * for next. An unknown multi-character key is a caller error, not a silent no-op \u2014 see\n * {@link toKeyCommands}.\n */\nconst NAMED_KEYS = new Map<string, NamedKey>([\n  ['ArrowDown', { code: 'ArrowDown', windowsVirtualKeyCode: KEY_CODE_ARROW_DOWN }],\n  ['ArrowLeft', { code: 'ArrowLeft', windowsVirtualKeyCode: KEY_CODE_ARROW_LEFT }],\n  ['ArrowRight', { code: 'ArrowRight', windowsVirtualKeyCode: KEY_CODE_ARROW_RIGHT }],\n  ['ArrowUp', { code: 'ArrowUp', windowsVirtualKeyCode: KEY_CODE_ARROW_UP }],\n  ['Backspace', { code: 'Backspace', windowsVirtualKeyCode: KEY_CODE_BACKSPACE }],\n  ['Delete', { code: 'Delete', windowsVirtualKeyCode: KEY_CODE_DELETE }],\n  ['Enter', { code: 'Enter', text: '\\r', windowsVirtualKeyCode: KEY_CODE_ENTER }],\n  ['Escape', { code: 'Escape', windowsVirtualKeyCode: KEY_CODE_ESCAPE }],\n  ['Tab', { code: 'Tab', text: '\\t', windowsVirtualKeyCode: KEY_CODE_TAB }]\n]);\n\nconst FIRST_CODE_POINT_INDEX = 0;\nconst DIGIT_ZERO_CODE_POINT = codePointOf('0');\nconst DIGIT_NINE_CODE_POINT = codePointOf('9');\nconst UPPERCASE_A_CODE_POINT = codePointOf('A');\nconst UPPERCASE_Z_CODE_POINT = codePointOf('Z');\n\n/**\n * The CDP spelling of one named key.\n */\ninterface NamedKey {\n  readonly code: string;\n  readonly text?: string;\n  readonly windowsVirtualKeyCode: number;\n}\n\n/**\n * Builds the expression the host evaluates to answer one input request.\n *\n * Optional chaining throughout: by the time the host answers, the page may have navigated and dropped the\n * namespace, and a `TypeError` inside this evaluate would be reported as an injection failure that already\n * succeeded.\n *\n * @param id - The request id the renderer is waiting on.\n * @param errorMessage - Why the injection failed, when it did. Omit on success.\n * @returns A self-contained expression to pass to `Runtime.evaluate`.\n */\nexport function buildResolveInputExpression(id: string, errorMessage?: string): string {\n  return `window.__obsidianIntegrationTesting?.resolveInput?.(${JSON.stringify(id)}, ${JSON.stringify(errorMessage ?? null)})`;\n}\n\n/**\n * The first code point of a non-empty string.\n *\n * `String.prototype.codePointAt` is typed `number | undefined`, so every call site would otherwise carry a\n * `?? fallback` that no input can ever reach \u2014 a dead branch under the 100% coverage gate. Throwing here\n * keeps that impossible case in ONE place, where a unit test can reach it directly, instead of spreading\n * unreachable fallbacks (or coverage suppressions) across the module.\n *\n * @param text - A non-empty string.\n * @returns Its first code point.\n * @throws When `text` is empty.\n */\nexport function codePointOf(text: string): number {\n  const codePoint = text.codePointAt(FIRST_CODE_POINT_INDEX);\n  if (codePoint === undefined) {\n    throw new Error('codePointOf received an empty string.');\n  }\n\n  return codePoint;\n}\n\n/**\n * Translates a mobile input request into the ordered CDP commands that realize it.\n *\n * @param request - What the renderer asked the host to inject.\n * @returns The commands to send, in order.\n */\nexport function toCdpInputCommands(request: MobileInputRequest): CdpInputCommand[] {\n  if (request.kind === 'key') {\n    return toKeyCommands(request);\n  }\n\n  return toPointerCommands(request);\n}\n\n/**\n * Folds resolved modifier names into CDP's bitmask.\n *\n * Unknown names are ignored rather than throwing: the renderer's `toElectronModifiers` is exhaustive over\n * Obsidian's `Modifier` union, so an unknown name here would mean the two copies have already drifted, and\n * failing the whole gesture is a worse outcome than pressing it unmodified.\n *\n * @param modifiers - Resolved lowercase modifier names.\n * @returns The CDP modifier bitmask.\n */\nexport function toCdpModifiers(modifiers: readonly string[]): number {\n  // Summing DISTINCT bits equals OR-ing them, and the `Set` is what makes that hold even when a caller\n  // Passes the same modifier twice \u2014 so the mask is built without a bitwise operator.\n  const bits = new Set<number>();\n  for (const modifier of modifiers) {\n    const bit = CDP_MODIFIER_BIT_BY_NAME.get(modifier);\n    if (bit !== undefined) {\n      bits.add(bit);\n    }\n  }\n\n  let bitmask = NO_MODIFIERS;\n  for (const bit of bits) {\n    bitmask += bit;\n  }\n\n  return bitmask;\n}\n\n/**\n * Resolves a key name to its CDP spelling.\n *\n * @param key - A named key or a single printable character.\n * @returns The CDP spelling.\n */\nfunction resolveKey(key: string): NamedKey {\n  const namedKey = NAMED_KEYS.get(key);\n  if (namedKey) {\n    return namedKey;\n  }\n\n  // \"Exactly one code point\", tested without splitting the string: `fromCodePoint` round-trips only when\n  // `key` is that single code point, so an astral-plane character counts as one and `'Ctrl+K'` does not.\n  const codePoint = key.codePointAt(FIRST_CODE_POINT_INDEX);\n  if (codePoint === undefined || String.fromCodePoint(codePoint) !== key) {\n    throw new Error(\n      `pressKey received an unknown key name on mobile: ${JSON.stringify(key)}. `\n        + `Pass a single character or one of: ${[...NAMED_KEYS.keys()].join(', ')}.`\n    );\n  }\n\n  const upperCasedCodePoint = codePointOf(key.toUpperCase());\n  return {\n    code: resolveKeyCode(upperCasedCodePoint),\n    text: key,\n    windowsVirtualKeyCode: upperCasedCodePoint\n  };\n}\n\n/**\n * Resolves the physical `code` for a printable character.\n *\n * Characters outside the ASCII letter/digit rows have no stable physical key, so they get an empty\n * `code` \u2014 the `text` still carries them, which is what an editor reads.\n *\n * @param upperCasedCodePoint - The character's upper-cased code point.\n * @returns The CDP `code`, or an empty string when there is no stable one.\n */\nfunction resolveKeyCode(upperCasedCodePoint: number): string {\n  if (upperCasedCodePoint >= UPPERCASE_A_CODE_POINT && upperCasedCodePoint <= UPPERCASE_Z_CODE_POINT) {\n    return `Key${String.fromCodePoint(upperCasedCodePoint)}`;\n  }\n\n  if (upperCasedCodePoint >= DIGIT_ZERO_CODE_POINT && upperCasedCodePoint <= DIGIT_NINE_CODE_POINT) {\n    return `Digit${String.fromCodePoint(upperCasedCodePoint)}`;\n  }\n\n  return '';\n}\n\n/**\n * Builds the command sequence for a key press.\n *\n * Mirrors the desktop twin's trusted `keyDown` \u2192 `char` \u2192 `keyUp` in CDP's spelling: `rawKeyDown` fires\n * `keydown` alone, `char` fires `keypress` / `beforeinput` / `input`, `keyUp` fires `keyup`. A key that\n * produces no text (`Escape`) skips the `char`, exactly as a real one does.\n *\n * @param request - The key request.\n * @returns The commands to send, in order.\n */\nfunction toKeyCommands(request: MobileKeyInputRequest): CdpInputCommand[] {\n  const { code, text, windowsVirtualKeyCode } = resolveKey(request.key);\n  const modifiers = toCdpModifiers(request.modifiers);\n  const base = { code, key: request.key, modifiers, windowsVirtualKeyCode };\n\n  const commands: CdpInputCommand[] = [\n    { method: 'Input.dispatchKeyEvent', params: { ...base, type: 'rawKeyDown' } }\n  ];\n\n  if (text !== undefined) {\n    commands.push({ method: 'Input.dispatchKeyEvent', params: { ...base, text, type: 'char' } });\n  }\n\n  commands.push({ method: 'Input.dispatchKeyEvent', params: { ...base, type: 'keyUp' } });\n\n  return commands;\n}\n\n/**\n * Builds the command sequence for a tap or a long-press.\n *\n * A trusted touch pair is all Chromium needs \u2014 it synthesizes `pointerdown` / `touchstart` /\n * `pointerup` / `touchend` / `click` from it, every one `isTrusted`. The release carries an empty\n * `touchPoints` list, which is CDP's spelling for \"all fingers lifted\".\n *\n * @param request - The pointer request.\n * @returns The commands to send, in order.\n */\nfunction toPointerCommands(request: MobilePointerInputRequest): CdpInputCommand[] {\n  const modifiers = toCdpModifiers(request.modifiers);\n\n  return [\n    {\n      method: 'Input.dispatchTouchEvent',\n      params: { modifiers, touchPoints: [{ x: request.x, y: request.y }], type: 'touchStart' }\n    },\n    {\n      ...(request.kind === 'longPress' && { delayBeforeInMilliseconds: LONG_PRESS_DWELL_IN_MILLISECONDS }),\n      method: 'Input.dispatchTouchEvent',\n      params: { modifiers, touchPoints: [], type: 'touchEnd' }\n    }\n  ];\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAsBO,MAAM,4BAA4B;AASlC,MAAM,uCAAuC;AA6GpD,MAAM,mCAAmC;AAEzC,MAAM,eAAe;AACrB,MAAM,mBAAmB;AACzB,MAAM,uBAAuB;AAC7B,MAAM,oBAAoB;AAC1B,MAAM,qBAAqB;AAO3B,MAAM,2BAA2B,oBAAI,IAAoB;AAAA,EACvD,CAAC,OAAO,gBAAgB;AAAA,EACxB,CAAC,WAAW,oBAAoB;AAAA,EAChC,CAAC,QAAQ,iBAAiB;AAAA,EAC1B,CAAC,SAAS,kBAAkB;AAC9B,CAAC;AAED,MAAM,qBAAqB;AAC3B,MAAM,eAAe;AACrB,MAAM,iBAAiB;AACvB,MAAM,kBAAkB;AACxB,MAAM,sBAAsB;AAC5B,MAAM,oBAAoB;AAC1B,MAAM,uBAAuB;AAC7B,MAAM,sBAAsB;AAC5B,MAAM,kBAAkB;AASxB,MAAM,aAAa,oBAAI,IAAsB;AAAA,EAC3C,CAAC,aAAa,EAAE,MAAM,aAAa,uBAAuB,oBAAoB,CAAC;AAAA,EAC/E,CAAC,aAAa,EAAE,MAAM,aAAa,uBAAuB,oBAAoB,CAAC;AAAA,EAC/E,CAAC,cAAc,EAAE,MAAM,cAAc,uBAAuB,qBAAqB,CAAC;AAAA,EAClF,CAAC,WAAW,EAAE,MAAM,WAAW,uBAAuB,kBAAkB,CAAC;AAAA,EACzE,CAAC,aAAa,EAAE,MAAM,aAAa,uBAAuB,mBAAmB,CAAC;AAAA,EAC9E,CAAC,UAAU,EAAE,MAAM,UAAU,uBAAuB,gBAAgB,CAAC;AAAA,EACrE,CAAC,SAAS,EAAE,MAAM,SAAS,MAAM,MAAM,uBAAuB,eAAe,CAAC;AAAA,EAC9E,CAAC,UAAU,EAAE,MAAM,UAAU,uBAAuB,gBAAgB,CAAC;AAAA,EACrE,CAAC,OAAO,EAAE,MAAM,OAAO,MAAM,KAAM,uBAAuB,aAAa,CAAC;AAC1E,CAAC;AAED,MAAM,yBAAyB;AAC/B,MAAM,wBAAwB,YAAY,GAAG;AAC7C,MAAM,wBAAwB,YAAY,GAAG;AAC7C,MAAM,yBAAyB,YAAY,GAAG;AAC9C,MAAM,yBAAyB,YAAY,GAAG;AAsBvC,SAAS,4BAA4B,IAAY,cAA+B;AACrF,SAAO,uDAAuD,KAAK,UAAU,EAAE,CAAC,KAAK,KAAK,UAAU,gBAAgB,IAAI,CAAC;AAC3H;AAcO,SAAS,YAAY,MAAsB;AAChD,QAAM,YAAY,KAAK,YAAY,sBAAsB;AACzD,MAAI,cAAc,QAAW;AAC3B,UAAM,IAAI,MAAM,uCAAuC;AAAA,EACzD;AAEA,SAAO;AACT;AAQO,SAAS,mBAAmB,SAAgD;AACjF,MAAI,QAAQ,SAAS,OAAO;AAC1B,WAAO,cAAc,OAAO;AAAA,EAC9B;AAEA,SAAO,kBAAkB,OAAO;AAClC;AAYO,SAAS,eAAe,WAAsC;AAGnE,QAAM,OAAO,oBAAI,IAAY;AAC7B,aAAW,YAAY,WAAW;AAChC,UAAM,MAAM,yBAAyB,IAAI,QAAQ;AACjD,QAAI,QAAQ,QAAW;AACrB,WAAK,IAAI,GAAG;AAAA,IACd;AAAA,EACF;AAEA,MAAI,UAAU;AACd,aAAW,OAAO,MAAM;AACtB,eAAW;AAAA,EACb;AAEA,SAAO;AACT;AAQA,SAAS,WAAW,KAAuB;AACzC,QAAM,WAAW,WAAW,IAAI,GAAG;AACnC,MAAI,UAAU;AACZ,WAAO;AAAA,EACT;AAIA,QAAM,YAAY,IAAI,YAAY,sBAAsB;AACxD,MAAI,cAAc,UAAa,OAAO,cAAc,SAAS,MAAM,KAAK;AACtE,UAAM,IAAI;AAAA,MACR,oDAAoD,KAAK,UAAU,GAAG,CAAC,wCAC7B,CAAC,GAAG,WAAW,KAAK,CAAC,EAAE,KAAK,IAAI,CAAC;AAAA,IAC7E;AAAA,EACF;AAEA,QAAM,sBAAsB,YAAY,IAAI,YAAY,CAAC;AACzD,SAAO;AAAA,IACL,MAAM,eAAe,mBAAmB;AAAA,IACxC,MAAM;AAAA,IACN,uBAAuB;AAAA,EACzB;AACF;AAWA,SAAS,eAAe,qBAAqC;AAC3D,MAAI,uBAAuB,0BAA0B,uBAAuB,wBAAwB;AAClG,WAAO,MAAM,OAAO,cAAc,mBAAmB,CAAC;AAAA,EACxD;AAEA,MAAI,uBAAuB,yBAAyB,uBAAuB,uBAAuB;AAChG,WAAO,QAAQ,OAAO,cAAc,mBAAmB,CAAC;AAAA,EAC1D;AAEA,SAAO;AACT;AAYA,SAAS,cAAc,SAAmD;AACxE,QAAM,EAAE,MAAM,MAAM,sBAAsB,IAAI,WAAW,QAAQ,GAAG;AACpE,QAAM,YAAY,eAAe,QAAQ,SAAS;AAClD,QAAM,OAAO,EAAE,MAAM,KAAK,QAAQ,KAAK,WAAW,sBAAsB;AAExE,QAAM,WAA8B;AAAA,IAClC,EAAE,QAAQ,0BAA0B,QAAQ,EAAE,GAAG,MAAM,MAAM,aAAa,EAAE;AAAA,EAC9E;AAEA,MAAI,SAAS,QAAW;AACtB,aAAS,KAAK,EAAE,QAAQ,0BAA0B,QAAQ,EAAE,GAAG,MAAM,MAAM,MAAM,OAAO,EAAE,CAAC;AAAA,EAC7F;AAEA,WAAS,KAAK,EAAE,QAAQ,0BAA0B,QAAQ,EAAE,GAAG,MAAM,MAAM,QAAQ,EAAE,CAAC;AAEtF,SAAO;AACT;AAYA,SAAS,kBAAkB,SAAuD;AAChF,QAAM,YAAY,eAAe,QAAQ,SAAS;AAElD,SAAO;AAAA,IACL;AAAA,MACE,QAAQ;AAAA,MACR,QAAQ,EAAE,WAAW,aAAa,CAAC,EAAE,GAAG,QAAQ,GAAG,GAAG,QAAQ,EAAE,CAAC,GAAG,MAAM,aAAa;AAAA,IACzF;AAAA,IACA;AAAA,MACE,GAAI,QAAQ,SAAS,eAAe,EAAE,2BAA2B,iCAAiC;AAAA,MAClG,QAAQ;AAAA,MACR,QAAQ,EAAE,WAAW,aAAa,CAAC,GAAG,MAAM,WAAW;AAAA,IACzD;AAAA,EACF;AACF;",
  "names": []
}
