obsidian-integration-testing 12.1.2 → 12.3.0

package/dist/lib/esm/eval-cap-exceeded-error.mjs

@@ -0,0 +1,36 @@
+const SCRIPT_TIMEOUT_PATTERN = /script\s*timeout/i;
+class EvalCapExceededError extends Error {
+  /**
+  The per-eval cap the closure outran, in milliseconds.
+   */
+  capInMilliseconds;
+  /**
+  How the transport that enforced the cap was named in the message.
+   */
+  transportName;
+  /**
+   * Creates the error from the cap, the transport, and the raw error it replaces.
+   *
+   * @param params - The cap, the transport, the option that sets the cap, and the underlying error.
+   */
+  constructor(params) {
+    super(buildMessage(params), { cause: params.cause });
+    this.name = "EvalCapExceededError";
+    this.capInMilliseconds = params.capInMilliseconds;
+    this.transportName = params.transportName;
+  }
+}
+function isScriptTimeoutError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return SCRIPT_TIMEOUT_PATTERN.test(error.message) || SCRIPT_TIMEOUT_PATTERN.test(error.name);
+}
+function buildMessage(params) {
+  return `A single evalInObsidian closure ran longer than the ${params.transportName} per-eval cap of ${String(params.capInMilliseconds)}ms, so it was killed mid-flight. This is a property of the closure, not of the device or the app: everything awaited inside one closure shares that one budget, including every \`lib.waitUntil\` timeout and every settle \`sleep\`. Do the waiting from Node instead \u2014 \`pollInObsidian\` runs a short \`poll\` closure repeatedly until a Node-side \`until\` accepts, so no single eval is ever long. Raise \`${params.optionName}\` only for a closure that genuinely cannot be split.`;
+}
+export {
+  EvalCapExceededError,
+  isScriptTimeoutError
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/eval-cap-exceeded-error.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * The one error both transports raise when a single `evalInObsidian` closure\n * outruns the per-eval cap, and the predicate that recognizes the raw transport\n * error it replaces.\n *\n * The cap itself is not the problem this module solves \u2014 the diagnosis is.\n * Desktop surfaces the overrun as a generic\n * `CDP command timed out ... : Runtime.evaluate`, which never names the test's\n * own wait and so reads as a broken device or a wedged app \u2014 a plugin release was\n * once held for two days by that reading, with a healthy emulator blamed for\n * having no network.\n *\n * Android is worse, because it surfaces NOTHING. On a live emulator the closure\n * was measured completing in the guest on schedule \u2014 timers armed at 30s and 40s fired within\n * ~13ms of nominal on a visible, focused page \u2014 while its Execute Script response\n * never reached the client, so the call hung until whichever outer budget gave up\n * first. A hang names nothing at all, which is why the Android cap is enforced by\n * the transport on the Node side rather than by the `timeouts.script` capability\n * it also declares and that nothing acts on.\n *\n * Both transports therefore funnel into the message below, which says what the cap\n * is, which transport enforced it, and what to do instead.\n *\n * A closure that needs to wait longer than the cap should not be waiting inside\n * Obsidian at all. `pollInObsidian` is the sanctioned shape: short closures, and\n * the waiting done from Node.\n */\n\n/*\n * The W3C error code is the spaced `script timeout`, while a client that turns it into a type spells the\n * Same thing as `ScriptTimeoutError` \u2014 hence the optional whitespace, which lets one pattern read both.\n */\nconst SCRIPT_TIMEOUT_PATTERN = /script\\s*timeout/i;\n\n/**\n * Parameters for {@link EvalCapExceededError}'s constructor.\n */\nexport interface EvalCapExceededErrorConstructorParams {\n  /**\n  The per-eval cap the closure outran, in milliseconds.\n   */\n  readonly capInMilliseconds: number;\n\n  /**\n  The underlying transport error, kept as the `cause` so the raw diagnosis is not lost.\n   */\n  readonly cause: unknown;\n\n  /**\n  The name of the option that sets the cap on this transport, so the message can name the real knob.\n   */\n  readonly optionName: string;\n\n  /**\n  How to refer to the transport that enforced the cap, e.g. `'Android (Appium)'`.\n   */\n  readonly transportName: string;\n}\n\n/**\n * Thrown when one `evalInObsidian` closure ran longer than the transport's\n * per-eval cap.\n *\n * Carries the cap and the transport so a caller can `instanceof`-match, and the\n * original transport error as `cause`.\n */\nexport class EvalCapExceededError extends Error {\n  /**\n  The per-eval cap the closure outran, in milliseconds.\n   */\n  public readonly capInMilliseconds: number;\n\n  /**\n  How the transport that enforced the cap was named in the message.\n   */\n  public readonly transportName: string;\n\n  /**\n   * Creates the error from the cap, the transport, and the raw error it replaces.\n   *\n   * @param params - The cap, the transport, the option that sets the cap, and the underlying error.\n   */\n  public constructor(params: EvalCapExceededErrorConstructorParams) {\n    super(buildMessage(params), { cause: params.cause });\n    this.name = 'EvalCapExceededError';\n    this.capInMilliseconds = params.capInMilliseconds;\n    this.transportName = params.transportName;\n  }\n}\n\n/**\n * Whether an error is a WebDriver script timeout \u2014 the W3C error a driver would\n * raise if it enforced `timeouts.script`.\n *\n * Matched on the message rather than on a type, because the error arrives as a\n * generic `WebDriverError` whose only distinguishing mark is the W3C error code\n * in its text.\n *\n * **This driver never raises it.** UiAutomator2 was measured accepting the\n * capability, reporting it back, and enforcing nothing. The predicate is kept\n * because it costs nothing, it is the right translation if a future driver does\n * enforce the capability, and it keeps one error covering one condition on both\n * transports \u2014 but the Android cap is enforced Node-side, and this is not what\n * enforces it.\n *\n * @param error - The error thrown by the transport.\n * @returns `true` when the error is a script timeout.\n */\nexport function isScriptTimeoutError(error: unknown): boolean {\n  if (!(error instanceof Error)) {\n    return false;\n  }\n\n  return SCRIPT_TIMEOUT_PATTERN.test(error.message) || SCRIPT_TIMEOUT_PATTERN.test(error.name);\n}\n\n/**\n * Builds the shared message both transports report.\n *\n * @param params - The cap, the transport, and the option that sets the cap.\n * @returns The message.\n */\nfunction buildMessage(params: EvalCapExceededErrorConstructorParams): string {\n  return `A single evalInObsidian closure ran longer than the ${params.transportName} per-eval cap of ${String(params.capInMilliseconds)}ms, so it was killed mid-flight. This is a property of the closure, not of the device or the app: `\n    + 'everything awaited inside one closure shares that one budget, including every `lib.waitUntil` timeout '\n    + 'and every settle `sleep`. Do the waiting from Node instead \u2014 `pollInObsidian` runs a short `poll` '\n    + 'closure repeatedly until a Node-side `until` accepts, so no single eval is ever long. Raise '\n    + `\\`${params.optionName}\\` only for a closure that genuinely cannot be split.`;\n}\n"],
  "mappings": "AAkCA,MAAM,yBAAyB;AAkCxB,MAAM,6BAA6B,MAAM;AAAA;AAAA;AAAA;AAAA,EAI9B;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOT,YAAY,QAA+C;AAChE,UAAM,aAAa,MAAM,GAAG,EAAE,OAAO,OAAO,MAAM,CAAC;AACnD,SAAK,OAAO;AACZ,SAAK,oBAAoB,OAAO;AAChC,SAAK,gBAAgB,OAAO;AAAA,EAC9B;AACF;AAoBO,SAAS,qBAAqB,OAAyB;AAC5D,MAAI,EAAE,iBAAiB,QAAQ;AAC7B,WAAO;AAAA,EACT;AAEA,SAAO,uBAAuB,KAAK,MAAM,OAAO,KAAK,uBAAuB,KAAK,MAAM,IAAI;AAC7F;AAQA,SAAS,aAAa,QAAuD;AAC3E,SAAO,uDAAuD,OAAO,aAAa,oBAAoB,OAAO,OAAO,iBAAiB,CAAC,0ZAI7H,OAAO,UAAU;AAC5B;",
  "names": []
}


package/dist/lib/esm/eval-cap.d.mts

@@ -0,0 +1,43 @@
+/**
+ * @file
+ *
+ * The per-eval cap: how long a single `evalInObsidian` closure may run before
+ * the transport carrying it gives up.
+ *
+ * It lives in its own module, and is re-exported from the package root, because
+ * it is the single most load-bearing number a test author has to respect — and
+ * until this module existed there was nothing to import. Both transports held
+ * the same 30s privately, so every consumer that needed to size a closure
+ * restated it as a literal with a comment saying where the number came from.
+ * That is a mirror nothing maintains: raise a cap here and every restatement is
+ * silently wrong in the direction that produces the unreadable failure, because
+ * the consumer goes on believing it has headroom it no longer has.
+ *
+ * **The two transports share this ONE constant rather than agreeing by
+ * coincidence.** They enforce it through different knobs — desktop bounds the
+ * `Runtime.evaluate` CDP command (`commandTimeoutInMilliseconds`), Android
+ * bounds the Execute Script call Node-side (`scriptTimeoutInMilliseconds`) —
+ * but the knobs are two implementations of one policy, not two policies that
+ * happen to agree. A reader of either default now sees which it is.
+ */
+/**
+ * The default per-eval cap, in milliseconds: the budget one `evalInObsidian`
+ * closure has to fit inside.
+ *
+ * Everything awaited inside a single closure shares this one budget — every
+ * `lib.waitUntil` timeout and every settle `sleep` — so a closure's declared
+ * waits have to sum to less than this, not merely be individually shorter.
+ *
+ * An overrun is reported as `EvalCapExceededError`, which names the cap, the
+ * transport that enforced it, and the option that sets it. Raising that option
+ * is almost never the right answer: a closure that needs to wait longer than
+ * this should not be waiting inside Obsidian at all. `pollInObsidian` is the
+ * sanctioned shape — short closures, with the waiting done from Node — and it
+ * exists precisely so no single eval is ever long.
+ *
+ * Both transports default to this value: it is what
+ * `ObsidianCdpTransportOptions.commandTimeoutInMilliseconds` and
+ * `ObsidianAndroidAppiumTransportOptions.scriptTimeoutInMilliseconds` fall back
+ * to when they are omitted.
+ */
+export declare const DEFAULT_EVAL_CAP_IN_MILLISECONDS = 30000;

package/dist/lib/esm/eval-cap.mjs

@@ -0,0 +1,5 @@
+const DEFAULT_EVAL_CAP_IN_MILLISECONDS = 3e4;
+export {
+  DEFAULT_EVAL_CAP_IN_MILLISECONDS
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -33,7 +33,10 @@ import {
   resolvePluginEnableRetryDelayInMilliseconds,
   shouldRetryPluginEnable
 } from "./plugin-enable-retry.mjs";
-import { acquireSetupLock } from "./setup-lock.mjs";
+import {
+  acquireSetupLock,
+  ANDROID_SETUP_LOCK_SCOPE
+} from "./setup-lock.mjs";
 import { TemporaryVault } from "./temporary-vault.mjs";
 import { AppiumTransport } from "./transport-appium.mjs";
 import { DesktopCdpTransport } from "./transport-desktop-cdp.mjs";
@@ -51,7 +54,6 @@ const activeSetups = /* @__PURE__ */ new Set();
 const disposedResults = /* @__PURE__ */ new WeakSet();
 let isCleanupHandlerRegistered = false;
 const setupLocks = /* @__PURE__ */ new Map();
-const ANDROID_LOCK_SCOPE = "android";
 async function coreSetup(params) {
   const projectRoot = findProjectRoot();
   const envFilePath = join(projectRoot, ".env");
@@ -288,7 +290,7 @@ function findProjectRoot() {
   }
 }
 function getLockScope(transportOptions) {
-  return transportOptions?.type === "obsidian-android-appium" ? ANDROID_LOCK_SCOPE : void 0;
+  return transportOptions?.type === "obsidian-android-appium" ? ANDROID_SETUP_LOCK_SCOPE : void 0;
 }
 function registerProcessCleanupHandler() {
   if (isCleanupHandlerRegistered) {
@@ -420,4 +422,4 @@ export {
   remapConfigDirectoryKeys,
   resolveIntegrationTransportOptions
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/global-setup-core.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Framework-agnostic core logic for integration test global setup and teardown.\n *\n * Vitest and Jest adapters delegate to these functions.\n */\n\n/* v8 ignore start -- Integration-time setup covered by integration tests, not unit tests. */\n\nimport type { PluginManifest } from 'obsidian';\n\nimport {\n  existsSync,\n  rmSync\n} from 'node:fs';\nimport {\n  readFile,\n  stat\n} from 'node:fs/promises';\nimport {\n  basename,\n  join\n} from 'node:path';\nimport process, { loadEnvFile } from 'node:process';\nimport { setTimeout as sleep } from 'node:timers/promises';\n\nimport type { EnablePluginResult } from './enable-plugin.mjs';\nimport type { SetupLock } from './setup-lock.mjs';\nimport type { PopulateFilesParams } from './temporary-vault.mjs';\nimport type { ObsidianTransportOptions } from './transport-options.mjs';\nimport type { ObsidianTransport } from './transport.mjs';\n\nimport { DEFAULT_CONFIG_DIRECTORY } from './config-directory.mjs';\nimport { DesktopOnlyPluginSkipError } from './desktop-only-plugin-skip-error.mjs';\nimport {\n  enablePluginWithErrorCapture,\n  getGenericPluginLoadFailureMessage\n} from './enable-plugin.mjs';\nimport { errorToString } from './error-to-string.mjs';\nimport { evalInObsidian } from './eval-in-obsidian.mjs';\nimport { ensureHeadlessVaultConfig } from './headless-vault-config.mjs';\nimport {\n  resolveLeftoverMaxAgeInMilliseconds,\n  sweepHostLeftovers,\n  willSweepLeftovers\n} from './leftover-cleanup.mjs';\nimport { log } from './log.mjs';\nimport {\n  computeBackoffDelayInMilliseconds,\n  resolvePluginEnableRetryCount,\n  resolvePluginEnableRetryDelayInMilliseconds,\n  shouldRetryPluginEnable\n} from './plugin-enable-retry.mjs';\nimport { acquireSetupLock } from './setup-lock.mjs';\nimport { TemporaryVault } from './temporary-vault.mjs';\nimport { AppiumTransport } from './transport-appium.mjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nimport { createTransportFromOptions } from './transport-factory.mjs';\nimport {\n  checkIsMobileTransport,\n  resolveOwnedConfigDirectory\n} from './transport-options.mjs';\nimport { installPluginIntoVault } from './vault-plugin-install.mjs';\n\nconst DEFAULT_TRANSPORT_TYPE = 'obsidian-cdp';\nconst DIST_DEV = 'dist/dev';\nconst DIST_BUILD = 'dist/build';\nconst MAIN_JS = 'main.js';\n\n/**\n * Tracks setups that completed successfully but haven't been torn down yet.\n * Used by the `beforeExit` handler to clean up when a test runner exits\n * without calling teardown (e.g., when one project's setup fails and the\n * runner aborts before tearing down already-initialized projects).\n */\nconst activeSetups = new Set<CoreSetupResult>();\nconst disposedResults = new WeakSet<CoreSetupResult>();\nlet isCleanupHandlerRegistered = false;\n\n/**\n * The cross-process setup lock held by each active setup. Released when the\n * setup is torn down (or by the process cleanup handlers), allowing a competing\n * run to proceed. See {@link acquireSetupLock}.\n */\nconst setupLocks = new Map<CoreSetupResult, SetupLock>();\n\nconst ANDROID_LOCK_SCOPE = 'android';\n\n/**\n * Parameters for {@link coreSetup}.\n */\nexport interface CoreSetupParams {\n  /**\n   * Community-plugin ids to enable in the vault **in addition to** the\n   * plugin-under-test, after it is enabled. Each id's built files must already be\n   * present under `.obsidian/plugins/<id>/` \u2014 seed them via {@link CoreSetupParams.populate}\n   * (e.g. with `buildDemoVaultPopulate`). Enabling goes through the same\n   * retry/load-verify path as the plugin-under-test. Composes with\n   * `installPlugin: false` (enable extras into an otherwise plugin-less vault).\n   */\n  readonly enableCommunityPlugins?: readonly string[] | undefined;\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 (e.g. a typings\n   * crawler) that only needs a registered, empty vault to `evalInObsidian`\n   * against: the plugin `dist`/`manifest.json` read, the copy into the config\n   * folder's `plugins/`, the `community-plugins.json` write, and the enable step\n   * are all skipped, while the transport, temp vault, registration, and\n   * worker-facing endpoint provisioning still run unchanged.\n   */\n  readonly installPlugin?: boolean | undefined;\n\n  /**\n   * Files and folders to write into the vault **before** Obsidian opens it, so\n   * its startup scan indexes them in one pass (see {@link TemporaryVault.populate}).\n   * Use this for large fixtures \u2014 writing thousands of notes after open and\n   * forcing a re-scan is far slower and less reliable.\n   *\n   * Keys naming the config folder are written as `.obsidian/\u2026`; under a\n   * `configDirectory` override {@link remapConfigDirectoryKeys} redirects them to\n   * the folder the vault will actually read, so a map does not have to carry a\n   * second copy of the override.\n   */\n  readonly populate?: PopulateFilesParams | undefined;\n\n  /**\n  Transport options. When omitted, uses an off-screen owned desktop instance.\n   */\n  readonly transportOptions?: ObsidianTransportOptions | undefined;\n}\n\n/**\n * Result returned by {@link coreSetup}, used by framework adapters\n * to pass context to test workers.\n */\nexport interface CoreSetupResult {\n  /**\n  The temporary vault created during setup.\n   */\n  readonly temporaryVault: TemporaryVault;\n\n  /**\n  The transport instance used during setup.\n   */\n  readonly transport: ObsidianTransport;\n\n  /**\n  Short label for log messages (e.g. `\"obsidian-cdp\"`).\n   */\n  readonly transportLabel: string;\n\n  /**\n  The transport options that were resolved.\n   */\n  readonly transportOptions: ObsidianTransportOptions | undefined;\n}\n\n/**\n * Parameters for {@link copyPluginIntoVault}.\n */\ninterface CopyPluginIntoVaultParams {\n  /**\n  The config folder the vault will read, when overridden away from `.obsidian` \u2014 the resolved\n  {@link resolveOwnedConfigDirectory} value, which is `undefined` for Obsidian's own default.\n   */\n  readonly configDirectory: string | undefined;\n\n  /**\n  Short label for log messages.\n   */\n  readonly label: string;\n\n  /**\n  The project root to resolve the built plugin from.\n   */\n  readonly projectRoot: string;\n\n  /**\n  The temp vault to copy the plugin into.\n   */\n  readonly temporaryVault: TemporaryVault;\n\n  /**\n  The transport (used for the mobile/desktop-only compatibility check).\n   */\n  readonly transport: ObsidianTransport;\n}\n\n/**\n * Parameters for {@link enableExtraCommunityPlugins}.\n */\ninterface EnableExtraCommunityPluginsParams {\n  /**\n  Short label for log messages.\n   */\n  readonly label: string;\n\n  /**\n  The ids of the extra community plugins to enable (their binaries must already be in the vault).\n   */\n  readonly pluginIds: readonly string[];\n\n  /**\n  The temp vault the plugins were seeded into.\n   */\n  readonly temporaryVault: TemporaryVault;\n\n  /**\n  The transport to evaluate against.\n   */\n  readonly transport: ObsidianTransport;\n\n  /**\n  The resolved transport options (source of the plugin-enable retry knobs).\n   */\n  readonly transportOptions: null | ObsidianTransportOptions;\n}\n\n/**\n * Parameters for {@link enablePluginInVault}.\n */\ninterface EnablePluginInVaultParams {\n  /**\n  Short label for log messages.\n   */\n  readonly label: string;\n\n  /**\n  The id of the plugin to enable.\n   */\n  readonly pluginId: string;\n\n  /**\n  The temp vault the plugin was copied into.\n   */\n  readonly temporaryVault: TemporaryVault;\n\n  /**\n  The transport to evaluate against.\n   */\n  readonly transport: ObsidianTransport;\n\n  /**\n  The resolved transport options (source of the plugin-enable retry knobs).\n   */\n  readonly transportOptions: null | ObsidianTransportOptions;\n}\n\n/**\n * Parameters for {@link skipIfDesktopOnly}.\n */\ninterface SkipIfDesktopOnlyParams {\n  /**\n  Short label for log messages.\n   */\n  readonly label: string;\n\n  /**\n  The project root to resolve the built plugin's manifest from.\n   */\n  readonly projectRoot: string;\n\n  /**\n  Whether a plugin is being installed at all -- there is nothing to check when the vault stays empty.\n   */\n  readonly shouldInstallPlugin: boolean;\n\n  /**\n  The resolved transport options, whose discriminant says whether this run is mobile.\n   */\n  readonly transportOptions: ObsidianTransportOptions;\n}\n\n/**\n * Parameters for {@link sweepLeftovers}.\n */\ninterface SweepLeftoversParams {\n  /**\n  Directory names to keep regardless of age (e.g. a concurrent setup's vault).\n   */\n  readonly excludedNames?: readonly string[] | undefined;\n\n  /**\n  Short label for log messages.\n   */\n  readonly label: string;\n\n  /**\n  Which end of the run is sweeping, for the log prefix.\n   */\n  readonly phase: 'setup' | 'teardown';\n\n  /**\n  The resolved transport options (source of the sweep knobs).\n   */\n  readonly transportOptions: ObsidianTransportOptions | undefined;\n}\n\n/**\n * Framework-agnostic global setup logic.\n *\n * Loads `.env` from the project root, creates a transport, creates and registers\n * a temporary vault with Obsidian, and \u2014 unless {@link CoreSetupParams.installPlugin}\n * is `false` \u2014 copies the built plugin into the vault and enables it. The\n * plugin-less mode still launches the owned instance and publishes its\n * worker-facing endpoint, so a non-plugin consumer reuses the same attach wiring.\n *\n * @param params - Setup parameters.\n * @returns The setup result containing the temp vault, transport, and resolved options.\n */\nexport async function coreSetup(params?: CoreSetupParams): Promise<CoreSetupResult> {\n  const projectRoot = findProjectRoot();\n  const envFilePath = join(projectRoot, '.env');\n  if (existsSync(envFilePath)) {\n    loadEnvFile(envFilePath);\n  }\n\n  const transportOptions = resolveIntegrationTransportOptions(params?.transportOptions);\n  const label = transportOptions.type;\n  const shouldInstallPlugin = params?.installPlugin !== false;\n\n  // Before the lock, the sweep and above all the transport: creating a mobile transport boots the AVD and\n  // Auto-starts Appium (~70 s) only to reach the same conclusion from `transport.isMobile` further down.\n  // Neither input needs a device -- the manifest is on disk and the discriminant already says mobile.\n  await skipIfDesktopOnly({ label, projectRoot, shouldInstallPlugin, transportOptions });\n\n  const lockScope = getLockScope(transportOptions);\n\n  let lock: SetupLock | undefined;\n  if (lockScope !== undefined) {\n    log(`[integration-setup:${label}] Acquiring '${lockScope}' setup lock (serializes against any concurrent integration-test run)...`);\n    lock = await acquireSetupLock({ label, scope: lockScope });\n    log(`[integration-setup:${label}] Setup lock acquired.`);\n  }\n\n  await sweepLeftovers({ label, phase: 'setup', transportOptions });\n\n  let transport: ObsidianTransport | undefined;\n  let temporaryVault: TemporaryVault | undefined;\n\n  try {\n    log(`[integration-setup:${label}] Creating transport...`);\n    transport = await createTransportFromOptions(transportOptions);\n    log(`[integration-setup:${label}] Transport created: ${transport.constructor.name}`);\n\n    log(`[integration-setup:${label}] Project root: ${projectRoot}`);\n\n    temporaryVault = new TemporaryVault();\n    log(`[integration-setup:${label}] Created temp vault: ${temporaryVault.path}`);\n\n    /*\n     * Which folder this vault will actually read, resolved once and handed to every writer below.\n     * Every pre-open write has to agree on it: one that hardcodes `.obsidian` under an override writes\n     * somewhere nothing looks, and nothing throws to say so.\n     */\n    const configDirectory = resolveOwnedConfigDirectory(transportOptions);\n\n    let pluginId: string | undefined;\n\n    if (shouldInstallPlugin) {\n      pluginId = await copyPluginIntoVault({ configDirectory, label, projectRoot, temporaryVault, transport });\n    } else {\n      log(`[integration-setup:${label}] Skipping plugin install (installPlugin: false) \u2014 registering an empty vault.`);\n    }\n\n    if (params?.populate) {\n      const populate = remapConfigDirectoryKeys(params.populate, configDirectory);\n      const entryCount = Object.keys(populate).length;\n      log(`[integration-setup:${label}] Populating vault with ${String(entryCount)} entries before open...`);\n      temporaryVault.populate(populate);\n    }\n\n    await ensureHeadlessVaultConfig({\n      configDirectory,\n      label,\n      vaultPath: temporaryVault.path\n    });\n\n    // `register` pushes the directory to the device before registering it, so every write above \u2014\n    // The plugin copy, the populate map, and the headless config just written \u2014 reaches the app.\n    log(`[integration-setup:${label}] Registering vault...`);\n    await temporaryVault.register(transport);\n    log(`[integration-setup:${label}] Vault registered.`);\n\n    if (pluginId !== undefined) {\n      await enablePluginInVault({ label, pluginId, temporaryVault, transport, transportOptions });\n    }\n\n    await enableExtraCommunityPlugins({\n      label,\n      pluginIds: params?.enableCommunityPlugins ?? [],\n      temporaryVault,\n      transport,\n      transportOptions\n    });\n\n    const augmentedOptions = augmentTransportOptions(transportOptions, transport);\n    const result: CoreSetupResult = { temporaryVault, transport, transportLabel: label, transportOptions: augmentedOptions };\n    activeSetups.add(result);\n    if (lock) {\n      setupLocks.set(result, lock);\n    }\n    registerProcessCleanupHandler();\n    return result;\n  } catch (error: unknown) {\n    log(`[integration-setup:${label}] Setup failed, cleaning up...`);\n    try {\n      if (temporaryVault && transport) {\n        await temporaryVault.dispose(transport);\n      }\n    } catch (cleanupError: unknown) {\n      log(`[integration-setup:${label}] Vault cleanup error (non-fatal): ${errorToString(cleanupError)}`);\n    }\n    try {\n      await transport?.dispose?.();\n    } catch (cleanupError: unknown) {\n      log(`[integration-setup:${label}] Transport cleanup error (non-fatal): ${errorToString(cleanupError)}`);\n    }\n\n    // Release the lock so a waiting run can proceed even though this run failed.\n    lock?.release();\n\n    log(`[integration-setup:${label}] NOTE: If the test runner reports \"No test files found\", ignore it \u2014 it is a side effect of the setup failure above.`);\n    throw error;\n  }\n}\n\n/**\n * Framework-agnostic global teardown logic.\n *\n * Disposes of the temporary vault and transport created during setup.\n *\n * @param result - The result from {@link coreSetup}. When `undefined`, does nothing.\n */\nexport async function coreTeardown(result?: CoreSetupResult): Promise<void> {\n  if (!result || disposedResults.has(result)) {\n    return;\n  }\n  disposedResults.add(result);\n\n  log(`[integration-teardown:${result.transportLabel}] Tearing down...`);\n\n  try {\n    await teardownAsync(result);\n  } catch (error: unknown) {\n    log(`[integration-teardown:${result.transportLabel}] Cleanup error (non-fatal): ${errorToString(error)}`);\n  } finally {\n    activeSetups.delete(result);\n    releaseSetupLock(result);\n  }\n\n  await sweepLeftovers({\n    excludedNames: [...activeSetups].map((activeSetup) => basename(activeSetup.temporaryVault.path)),\n    label: result.transportLabel,\n    phase: 'teardown',\n    transportOptions: result.transportOptions\n  });\n}\n\n/**\n * Redirects a populate map's config-folder entries to the folder the vault will actually read.\n *\n * A populate map names its destinations vault-relative, and everything that builds one \u2014 including\n * `buildDemoVaultPopulate`, which seeds `.obsidian/*` config files and injected community plugins'\n * binaries \u2014 writes them under a literal `.obsidian/`, because that is the folder Obsidian uses when nothing\n * overrides it. Under a `configDirectory` override those entries land in a folder the vault never opens, and\n * the plugins seeded that way come back as the generic \"enabled but not loaded\" with nothing naming a config\n * folder. Rewriting the key here fixes every consumer at once \u2014 a hand-written map as much as a demo vault's\n * \u2014 and needs no second copy of the override for a caller to keep in sync with their transport options.\n *\n * Safe rather than magic: the vault is one the harness made for this run and has exactly one config folder,\n * so under an override a `.obsidian/` entry is dead weight nothing reads. Only a leading `.obsidian` path\n * SEGMENT moves; a note whose name merely contains the string does not.\n *\n * @param populate - The consumer's populate map.\n * @param configDirectory - The resolved override, or `undefined` for Obsidian's default (a no-op).\n * @returns The map with its config-folder keys redirected, or the original map when there is nothing to move.\n */\nexport function remapConfigDirectoryKeys(populate: PopulateFilesParams, configDirectory: string | undefined): PopulateFilesParams {\n  if (configDirectory === undefined || configDirectory === DEFAULT_CONFIG_DIRECTORY) {\n    return populate;\n  }\n\n  const prefix = `${DEFAULT_CONFIG_DIRECTORY}/`;\n  const remapped: PopulateFilesParams = {};\n  for (const [path, content] of Object.entries(populate)) {\n    remapped[path.startsWith(prefix) ? `${configDirectory}/${path.slice(prefix.length)}` : path] = content;\n  }\n\n  return remapped;\n}\n\n/**\n * Resolves transport options for an integration run.\n *\n * Desktop launches are normally visible, but test setup explicitly keeps its\n * owned instance off-screen so it does not interrupt the developer.\n *\n * @param options - Consumer-provided transport options.\n * @returns Options with the desktop integration visibility default applied.\n */\nexport function resolveIntegrationTransportOptions(options?: ObsidianTransportOptions): ObsidianTransportOptions {\n  if (options?.type === 'obsidian-android-appium') {\n    return options;\n  }\n\n  return {\n    ...options,\n    isObsidianAppVisible: options?.isObsidianAppVisible ?? false,\n    type: 'obsidian-cdp'\n  };\n}\n\n/**\n * Augments transport options with reuse info so test workers can reattach to the\n * instance the global setup already launched instead of creating their own:\n *\n * - **Appium** \u2014 injects the established `sessionId`/`deviceId`.\n * - **Owned desktop CDP** \u2014 injects the owned instance's `host`/`port` (chosen\n *   at launch) plus the internal `isHarnessOwnedInstance` flag, so each worker\n *   **attaches** to that instance over CDP rather than launching (and never\n *   registering) its own \u2014 the bug that otherwise leaves a worker's transport\n *   with no CDP endpoint.\n *\n * @param options - The original transport options.\n * @param transport - The transport instance created during setup.\n * @returns The augmented options, or the original options if not applicable.\n */\nfunction augmentTransportOptions(\n  options: ObsidianTransportOptions | undefined,\n  transport: ObsidianTransport\n): ObsidianTransportOptions | undefined {\n  if (options?.type === 'obsidian-android-appium' && transport instanceof AppiumTransport) {\n    const sessionInfo = transport.getSessionInfo();\n    log(`[integration-setup:${options.type}] Session reuse info: sessionId=${sessionInfo.sessionId}, deviceId=${sessionInfo.deviceId}`);\n    return {\n      ...options,\n      deviceId: sessionInfo.deviceId,\n      sessionId: sessionInfo.sessionId\n    };\n  }\n\n  if ((options === undefined || options.type === 'obsidian-cdp') && transport instanceof DesktopCdpTransport) {\n    const endpoint = transport.getOwnedInstanceEndpoint();\n    if (endpoint) {\n      log(`[integration-setup:${DEFAULT_TRANSPORT_TYPE}] Owned instance reuse info: host=${endpoint.host}, port=${String(endpoint.port)}`);\n      return {\n        ...options,\n        host: endpoint.host,\n        isHarnessOwnedInstance: true,\n        port: endpoint.port,\n        type: 'obsidian-cdp'\n      };\n    }\n  }\n\n  return options;\n}\n\n/**\n * Copies the built plugin into the temp vault and marks it as a community plugin.\n *\n * Reads `manifest.json` from the newer of `dist/dev`/`dist/build`, rejects a\n * desktop-only plugin on a mobile transport, then hands the write itself to\n * {@link installPluginIntoVault} \u2014 which puts the build in\n * `<configDirectory>/plugins/<id>` and writes\n * `<configDirectory>/community-plugins.json`, honouring a `configDirectory`\n * override so the plugin lands where the vault will actually look for it.\n *\n * @param params - The copy parameters.\n * @returns The plugin id read from the manifest.\n */\nasync function copyPluginIntoVault(params: CopyPluginIntoVaultParams): Promise<string> {\n  const { configDirectory, label, projectRoot, temporaryVault, transport } = params;\n  const distPath = await resolveDistPath(projectRoot);\n  const manifestJson = JSON.parse(await readFile(join(distPath, 'manifest.json'), 'utf-8')) as PluginManifest;\n  const pluginId = manifestJson.id;\n\n  // The same refusal {@link skipIfDesktopOnly} already made before the transport existed. Kept as the\n  // Backstop for any caller that reaches here another way, and throwing the same type so both paths read\n  // Identically in the log.\n  if (transport.isMobile && manifestJson.isDesktopOnly) {\n    throw new DesktopOnlyPluginSkipError(pluginId);\n  }\n\n  const mainJs = join(distPath, MAIN_JS);\n  const buildStat = await stat(mainJs);\n  log(`[integration-setup:${label}] Using ${distPath} (${buildStat.mtime.toISOString()}). If outdated, rebuild.`);\n\n  await installPluginIntoVault({ configDirectory, distPath, pluginId, vaultPath: temporaryVault.path });\n  log(`[integration-setup:${label}] Installed \"${pluginId}\" into ${configDirectory ?? DEFAULT_CONFIG_DIRECTORY}/plugins (and enabled it there).`);\n\n  return pluginId;\n}\n\n/**\n * Enables extra community plugins (beyond the plugin-under-test) in the registered vault, each through the\n * same {@link enablePluginInVault} path. Each plugin's built files must already be present in the vault (seed\n * them via {@link CoreSetupParams.populate}). A no-op when the list is empty.\n *\n * @param params - The enable parameters.\n */\nasync function enableExtraCommunityPlugins(params: EnableExtraCommunityPluginsParams): Promise<void> {\n  const { label, pluginIds, temporaryVault, transport, transportOptions } = params;\n  for (const pluginId of pluginIds) {\n    log(`[integration-setup:${label}] Enabling extra community plugin \"${pluginId}\"...`);\n    await enablePluginInVault({ label, pluginId, temporaryVault, transport, transportOptions });\n  }\n}\n\n/**\n * Enables the plugin in the registered vault and verifies it loaded.\n *\n * Obsidian's `enablePlugin()` wraps `loadPlugin()` in a try-catch that swallows\n * errors and returns false, so {@link enablePluginWithErrorCapture} monkey-patches\n * `loadPlugin()` to capture the error before it's swallowed.\n *\n * @param params - The enable parameters.\n */\nasync function enablePluginInVault(params: EnablePluginInVaultParams): Promise<void> {\n  const { label, pluginId, temporaryVault, transport, transportOptions } = params;\n  log(`[integration-setup:${label}] Enabling plugin \"${pluginId}\"...`);\n\n  /*\n   * Open a native console-capture window (Layer 2, Android only) around the\n   * enable so that if Obsidian swallows the load error before the monkey-patch\n   * and the renderer console (Layer 1) came up empty, we can still recover the\n   * real cause from `adb logcat`. No-op (undefined) on transports that don't\n   * implement it (e.g. desktop).\n   */\n  const captureHandle = await transport.beginConsoleCapture?.();\n\n  /*\n   * On a freshly cold-booted emulator the plugin subsystem can still be settling\n   * when we enable the plugin, so a single-shot enable races the load and loses\n   * (the plugin lands in the enabled set but never loads). Retry the enable +\n   * load-verification a few times with exponential backoff, which recovers the\n   * transient race. A captured load error (`realError`) is a deterministic bug \u2014\n   * retrying cannot fix it, so we fail fast. Non-Android transports resolve to\n   * the same defaults but never enter the retry path: their load either succeeds\n   * on the first attempt or throws a captured error.\n   */\n  const maxAttempts = 1 + resolvePluginEnableRetryCount(transportOptions);\n  const baseDelayInMilliseconds = resolvePluginEnableRetryDelayInMilliseconds(transportOptions);\n\n  for (let attempt = 1; attempt <= maxAttempts; attempt++) {\n    let result: EnablePluginResult;\n    try {\n      result = await evalInObsidian({\n        callback: enablePluginWithErrorCapture,\n        input: { pluginId },\n        shouldSkipPreflightChecks: true,\n        transport,\n        vaultPath: temporaryVault.path\n      });\n    } catch (error) {\n      /*\n       * The eval itself threw (e.g. the WebView context was lost mid-execution on\n       * a churning guest) \u2014 a transport-level transient. Retry if attempts remain.\n       */\n      if (attempt < maxAttempts) {\n        const delayInMilliseconds = computeBackoffDelayInMilliseconds(baseDelayInMilliseconds, attempt - 1);\n        log(\n          `[integration-setup:${label}] Enable attempt ${String(attempt)}/${String(maxAttempts)} threw `\n            + `(${errorToString(error)}); retrying in ${String(delayInMilliseconds)}ms...`\n        );\n        await sleep(delayInMilliseconds);\n        continue;\n      }\n      throw error;\n    }\n\n    /*\n     * `errorMessage` is the real throw seen by the monkey-patch;\n     * `rendererConsoleErrors` (Layer 1) is the real cause console-logged in the renderer.\n     */\n    const realError = result.errorMessage ?? result.rendererConsoleErrors;\n\n    if (result.isLoaded && !realError) {\n      const attemptSuffix = attempt > 1 ? ` (attempt ${String(attempt)}/${String(maxAttempts)})` : '';\n      log(`[integration-setup:${label}] Plugin \"${pluginId}\" enabled successfully${attemptSuffix}.`);\n      return;\n    }\n\n    // A captured load error is deterministic \u2014 fail fast rather than retry.\n    if (!shouldRetryPluginEnable(result)) {\n      throw new Error(`Plugin \"${pluginId}\" failed to load: ${realError ?? getGenericPluginLoadFailureMessage(pluginId)}`);\n    }\n\n    // Transient cold-boot race (enabled but not loaded, no cause captured): retry.\n    if (attempt < maxAttempts) {\n      const delayInMilliseconds = computeBackoffDelayInMilliseconds(baseDelayInMilliseconds, attempt - 1);\n      log(\n        `[integration-setup:${label}] Plugin \"${pluginId}\" enabled but not loaded `\n          + `(attempt ${String(attempt)}/${String(maxAttempts)}); retrying in ${String(delayInMilliseconds)}ms...`\n      );\n      await sleep(delayInMilliseconds);\n    }\n  }\n\n  /*\n   * Exhausted every attempt on the transient signature: compose the most\n   * specific detail available (`adb logcat` tail on Android, else the generic\n   * message) \u2014 unchanged from the pre-retry single-shot failure.\n   */\n  const logcatTail = await transport.readConsoleCaptureSince?.(captureHandle);\n  const detail = logcatTail ?? getGenericPluginLoadFailureMessage(pluginId);\n  throw new Error(`Plugin \"${pluginId}\" failed to load: ${detail}`);\n}\n\n/**\n * Finds the project root by walking up from `process.cwd()` looking for `package.json`.\n *\n * @returns The absolute path to the project root.\n */\nfunction findProjectRoot(): string {\n  let directory = process.cwd();\n\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Loop terminates at filesystem root.\n  while (true) {\n    if (existsSync(join(directory, 'package.json'))) {\n      return directory;\n    }\n    const parent = join(directory, '..');\n    if (parent === directory) {\n      throw new Error('Could not find project root (no package.json found).');\n    }\n    directory = parent;\n  }\n}\n\n/**\n * Resolves the cross-process lock scope for a transport, or `undefined` when no\n * lock is needed.\n *\n * Desktop runs use harness-owned, isolated instances (their own user-data dir\n * and CDP port), so they no longer contend and need no lock. Only the Android\n * transport, which shares the single emulator and Appium server, must serialize.\n *\n * @param transportOptions - The resolved transport options.\n * @returns The lock scope string, or `undefined` if no lock is needed.\n */\nfunction getLockScope(transportOptions: ObsidianTransportOptions | undefined): string | undefined {\n  return transportOptions?.type === 'obsidian-android-appium' ? ANDROID_LOCK_SCOPE : undefined;\n}\n\n/**\n * Registers cleanup handlers for orphaned setups that were never explicitly\n * torn down.\n *\n * Two handlers cover different exit scenarios:\n *\n * - `beforeExit` \u2014 fires when the event loop drains naturally. Allows full\n *   async teardown (unregister vaults, dispose transports). Does NOT fire\n *   when `process.exit()` is called directly.\n *\n * - `unhandledRejection` \u2014 catches async errors that bypass `coreSetup`'s\n *   catch block. Performs full async teardown while we still can.\n *\n * - `exit` \u2014 fires on every exit, including `process.exit()`. Only synchronous\n *   work is possible, so this handler does best-effort cleanup: kills child\n *   processes via `disposeSync()` and removes temp vault directories with\n *   `rmSync`. Unregistering vaults (which requires IPC with Obsidian) is\n *   skipped \u2014 a stale vault entry is an acceptable trade-off vs. leaked\n *   processes and temp directories.\n */\nfunction registerProcessCleanupHandler(): void {\n  if (isCleanupHandlerRegistered) {\n    return;\n  }\n  isCleanupHandlerRegistered = true;\n\n  process.on('beforeExit', () => {\n    if (activeSetups.size === 0) {\n      return;\n    }\n\n    log(`[integration-teardown] Process exiting with ${String(activeSetups.size)} setup(s) not torn down. Cleaning up...`);\n\n    for (const result of activeSetups) {\n      coreTeardown(result).catch((error: unknown) => {\n        log(`[integration-teardown:${result.transportLabel}] Process cleanup error (non-fatal): ${errorToString(error)}`);\n      });\n    }\n  });\n\n  process.on('unhandledRejection', () => {\n    if (activeSetups.size === 0) {\n      return;\n    }\n\n    log(`[integration-teardown] Unhandled rejection detected. Tearing down ${String(activeSetups.size)} active setup(s)...`);\n    for (const result of activeSetups) {\n      coreTeardown(result).catch((error: unknown) => {\n        log(`[integration-teardown:${result.transportLabel}] Rejection cleanup error (non-fatal): ${errorToString(error)}`);\n      });\n    }\n  });\n\n  process.on('exit', () => {\n    if (activeSetups.size === 0) {\n      return;\n    }\n\n    log(`[integration-teardown] Sync cleanup: ${String(activeSetups.size)} orphaned setup(s).`);\n    for (const result of activeSetups) {\n      try {\n        result.transport.disposeSync?.();\n      } catch (error: unknown) {\n        log(`[integration-teardown:${result.transportLabel}] Sync transport cleanup error (non-fatal): ${errorToString(error)}`);\n      }\n      try {\n        rmSync(result.temporaryVault.path, { force: true, recursive: true });\n      } catch (error: unknown) {\n        log(`[integration-teardown:${result.transportLabel}] Sync vault cleanup error (non-fatal): ${errorToString(error)}`);\n      }\n      releaseSetupLock(result);\n    }\n    activeSetups.clear();\n  });\n}\n\n/**\n * Releases and forgets the setup lock associated with a result, if any.\n *\n * @param result - The setup result whose lock should be released.\n */\nfunction releaseSetupLock(result: CoreSetupResult): void {\n  const lock = setupLocks.get(result);\n  if (lock) {\n    lock.release();\n    setupLocks.delete(result);\n  }\n}\n\n/**\n * Resolves the dist path to use for integration tests.\n *\n * Picks whichever of `dist/dev` and `dist/build` has a newer `main.js`.\n * If only one exists, that one is used. Throws if neither exists.\n *\n * @param projectRoot - The absolute path to the project root.\n * @returns The absolute path to the chosen dist folder.\n */\nasync function resolveDistPath(projectRoot: string): Promise<string> {\n  const devPath = join(projectRoot, DIST_DEV);\n  const buildPath = join(projectRoot, DIST_BUILD);\n  const devMainJs = join(devPath, MAIN_JS);\n  const buildMainJs = join(buildPath, MAIN_JS);\n  const devStat = existsSync(devMainJs) ? await stat(devMainJs) : null;\n  const buildStat = existsSync(buildMainJs) ? await stat(buildMainJs) : null;\n\n  if (devStat && buildStat) {\n    return devStat.mtime > buildStat.mtime ? devPath : buildPath;\n  }\n\n  if (devStat) {\n    return devPath;\n  }\n\n  if (buildStat) {\n    return buildPath;\n  }\n\n  throw new Error('No build found. Run `npm run build` or `npm run dev` first.');\n}\n\n/**\n * Refuses a mobile run for a desktop-only plugin, before anything costly has happened.\n *\n * A no-op unless a plugin is being installed onto a mobile transport. Otherwise reads `manifest.json`\n * out of the newer dist folder \u2014 no device, no lock, no sweep. When there is no readable build the check\n * simply does not fire: a missing or malformed build is a different problem, and {@link resolveDistPath}\n * downstream already reports it in its own words.\n *\n * @param params - The transport label, project root, transport options and whether a plugin is installed.\n * @throws {DesktopOnlyPluginSkipError} When the manifest says `isDesktopOnly: true`.\n */\nasync function skipIfDesktopOnly(params: SkipIfDesktopOnlyParams): Promise<void> {\n  const { label, projectRoot, shouldInstallPlugin, transportOptions } = params;\n\n  if (!shouldInstallPlugin || !checkIsMobileTransport(transportOptions)) {\n    return;\n  }\n\n  let manifestJson: PluginManifest;\n  try {\n    const distPath = await resolveDistPath(projectRoot);\n    manifestJson = JSON.parse(await readFile(join(distPath, 'manifest.json'), 'utf-8')) as PluginManifest;\n  } catch {\n    return;\n  }\n\n  if (!manifestJson.isDesktopOnly) {\n    return;\n  }\n\n  log(\n    `[integration-setup:${label}] SKIPPED: \"${manifestJson.id}\" is desktop-only (isDesktopOnly: true), `\n      + 'so it has no mobile integration tests to run. No emulator was booted and no Appium server was started.'\n  );\n  throw new DesktopOnlyPluginSkipError(manifestJson.id);\n}\n\n/**\n * Removes the host-side temp directories earlier runs leaked.\n *\n * Runs at both ends of a run: at setup it happens **before** the transport is\n * created, so it does not depend on a healthy Obsidian/WebView \u2014 which is\n * exactly what a failed run no longer has, and why a failed run cannot clean up\n * after itself. Age-gated (see `leftoverMaxAgeInMilliseconds`) because desktop\n * runs are not serialized and every project on the machine shares one temp\n * directory. Best-effort: a sweep never fails the run it is cleaning up for.\n *\n * @param params - The sweep parameters.\n */\nasync function sweepLeftovers(params: SweepLeftoversParams): Promise<void> {\n  const { label, phase, transportOptions } = params;\n  if (!willSweepLeftovers(transportOptions)) {\n    return;\n  }\n\n  try {\n    const result = await sweepHostLeftovers({\n      excludedNames: params.excludedNames,\n      maxAgeInMilliseconds: resolveLeftoverMaxAgeInMilliseconds(transportOptions)\n    });\n    if (result.removedCount > 0 || result.failedCount > 0) {\n      log(\n        `[integration-${phase}:${label}] Swept ${String(result.removedCount)} leftover temp director(ies) `\n          + `from earlier runs (${String(result.failedCount)} still in use).`\n      );\n    }\n  } catch (error: unknown) {\n    log(`[integration-${phase}:${label}] Leftover sweep error (non-fatal): ${errorToString(error)}`);\n  }\n}\n\n/**\n * Performs the async teardown work (vault disposal + transport disposal).\n *\n * @param result - The setup result to tear down.\n */\nasync function teardownAsync(result: CoreSetupResult): Promise<void> {\n  try {\n    await result.temporaryVault.dispose(result.transport);\n  } catch (error: unknown) {\n    log(`[integration-teardown:${result.transportLabel}] Vault cleanup error (non-fatal): ${errorToString(error)}`);\n  }\n\n  try {\n    await result.transport.dispose?.();\n  } catch (error: unknown) {\n    log(`[integration-teardown:${result.transportLabel}] Transport cleanup error (non-fatal): ${errorToString(error)}`);\n  }\n}\n"],
  "mappings": "AAYA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,OAAO,WAAW,mBAAmB;AACrC,SAAS,cAAc,aAAa;AAQpC,SAAS,gCAAgC;AACzC,SAAS,kCAAkC;AAC3C;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,qBAAqB;AAC9B,SAAS,sBAAsB;AAC/B,SAAS,iCAAiC;AAC1C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,WAAW;AACpB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,wBAAwB;AACjC,SAAS,sBAAsB;AAC/B,SAAS,uBAAuB;AAChC,SAAS,2BAA2B;AACpC,SAAS,kCAAkC;AAC3C;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,8BAA8B;AAEvC,MAAM,yBAAyB;AAC/B,MAAM,WAAW;AACjB,MAAM,aAAa;AACnB,MAAM,UAAU;AAQhB,MAAM,eAAe,oBAAI,IAAqB;AAC9C,MAAM,kBAAkB,oBAAI,QAAyB;AACrD,IAAI,6BAA6B;AAOjC,MAAM,aAAa,oBAAI,IAAgC;AAEvD,MAAM,qBAAqB;AAiO3B,eAAsB,UAAU,QAAoD;AAClF,QAAM,cAAc,gBAAgB;AACpC,QAAM,cAAc,KAAK,aAAa,MAAM;AAC5C,MAAI,WAAW,WAAW,GAAG;AAC3B,gBAAY,WAAW;AAAA,EACzB;AAEA,QAAM,mBAAmB,mCAAmC,QAAQ,gBAAgB;AACpF,QAAM,QAAQ,iBAAiB;AAC/B,QAAM,sBAAsB,QAAQ,kBAAkB;AAKtD,QAAM,kBAAkB,EAAE,OAAO,aAAa,qBAAqB,iBAAiB,CAAC;AAErF,QAAM,YAAY,aAAa,gBAAgB;AAE/C,MAAI;AACJ,MAAI,cAAc,QAAW;AAC3B,QAAI,sBAAsB,KAAK,gBAAgB,SAAS,0EAA0E;AAClI,WAAO,MAAM,iBAAiB,EAAE,OAAO,OAAO,UAAU,CAAC;AACzD,QAAI,sBAAsB,KAAK,wBAAwB;AAAA,EACzD;AAEA,QAAM,eAAe,EAAE,OAAO,OAAO,SAAS,iBAAiB,CAAC;AAEhE,MAAI;AACJ,MAAI;AAEJ,MAAI;AACF,QAAI,sBAAsB,KAAK,yBAAyB;AACxD,gBAAY,MAAM,2BAA2B,gBAAgB;AAC7D,QAAI,sBAAsB,KAAK,wBAAwB,UAAU,YAAY,IAAI,EAAE;AAEnF,QAAI,sBAAsB,KAAK,mBAAmB,WAAW,EAAE;AAE/D,qBAAiB,IAAI,eAAe;AACpC,QAAI,sBAAsB,KAAK,yBAAyB,eAAe,IAAI,EAAE;AAO7E,UAAM,kBAAkB,4BAA4B,gBAAgB;AAEpE,QAAI;AAEJ,QAAI,qBAAqB;AACvB,iBAAW,MAAM,oBAAoB,EAAE,iBAAiB,OAAO,aAAa,gBAAgB,UAAU,CAAC;AAAA,IACzG,OAAO;AACL,UAAI,sBAAsB,KAAK,qFAAgF;AAAA,IACjH;AAEA,QAAI,QAAQ,UAAU;AACpB,YAAM,WAAW,yBAAyB,OAAO,UAAU,eAAe;AAC1E,YAAM,aAAa,OAAO,KAAK,QAAQ,EAAE;AACzC,UAAI,sBAAsB,KAAK,2BAA2B,OAAO,UAAU,CAAC,yBAAyB;AACrG,qBAAe,SAAS,QAAQ;AAAA,IAClC;AAEA,UAAM,0BAA0B;AAAA,MAC9B;AAAA,MACA;AAAA,MACA,WAAW,eAAe;AAAA,IAC5B,CAAC;AAID,QAAI,sBAAsB,KAAK,wBAAwB;AACvD,UAAM,eAAe,SAAS,SAAS;AACvC,QAAI,sBAAsB,KAAK,qBAAqB;AAEpD,QAAI,aAAa,QAAW;AAC1B,YAAM,oBAAoB,EAAE,OAAO,UAAU,gBAAgB,WAAW,iBAAiB,CAAC;AAAA,IAC5F;AAEA,UAAM,4BAA4B;AAAA,MAChC;AAAA,MACA,WAAW,QAAQ,0BAA0B,CAAC;AAAA,MAC9C;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC;AAED,UAAM,mBAAmB,wBAAwB,kBAAkB,SAAS;AAC5E,UAAM,SAA0B,EAAE,gBAAgB,WAAW,gBAAgB,OAAO,kBAAkB,iBAAiB;AACvH,iBAAa,IAAI,MAAM;AACvB,QAAI,MAAM;AACR,iBAAW,IAAI,QAAQ,IAAI;AAAA,IAC7B;AACA,kCAA8B;AAC9B,WAAO;AAAA,EACT,SAAS,OAAgB;AACvB,QAAI,sBAAsB,KAAK,gCAAgC;AAC/D,QAAI;AACF,UAAI,kBAAkB,WAAW;AAC/B,cAAM,eAAe,QAAQ,SAAS;AAAA,MACxC;AAAA,IACF,SAAS,cAAuB;AAC9B,UAAI,sBAAsB,KAAK,sCAAsC,cAAc,YAAY,CAAC,EAAE;AAAA,IACpG;AACA,QAAI;AACF,YAAM,WAAW,UAAU;AAAA,IAC7B,SAAS,cAAuB;AAC9B,UAAI,sBAAsB,KAAK,0CAA0C,cAAc,YAAY,CAAC,EAAE;AAAA,IACxG;AAGA,UAAM,QAAQ;AAEd,QAAI,sBAAsB,KAAK,4HAAuH;AACtJ,UAAM;AAAA,EACR;AACF;AASA,eAAsB,aAAa,QAAyC;AAC1E,MAAI,CAAC,UAAU,gBAAgB,IAAI,MAAM,GAAG;AAC1C;AAAA,EACF;AACA,kBAAgB,IAAI,MAAM;AAE1B,MAAI,yBAAyB,OAAO,cAAc,mBAAmB;AAErE,MAAI;AACF,UAAM,cAAc,MAAM;AAAA,EAC5B,SAAS,OAAgB;AACvB,QAAI,yBAAyB,OAAO,cAAc,gCAAgC,cAAc,KAAK,CAAC,EAAE;AAAA,EAC1G,UAAE;AACA,iBAAa,OAAO,MAAM;AAC1B,qBAAiB,MAAM;AAAA,EACzB;AAEA,QAAM,eAAe;AAAA,IACnB,eAAe,CAAC,GAAG,YAAY,EAAE,IAAI,CAAC,gBAAgB,SAAS,YAAY,eAAe,IAAI,CAAC;AAAA,IAC/F,OAAO,OAAO;AAAA,IACd,OAAO;AAAA,IACP,kBAAkB,OAAO;AAAA,EAC3B,CAAC;AACH;AAqBO,SAAS,yBAAyB,UAA+B,iBAA0D;AAChI,MAAI,oBAAoB,UAAa,oBAAoB,0BAA0B;AACjF,WAAO;AAAA,EACT;AAEA,QAAM,SAAS,GAAG,wBAAwB;AAC1C,QAAM,WAAgC,CAAC;AACvC,aAAW,CAAC,MAAM,OAAO,KAAK,OAAO,QAAQ,QAAQ,GAAG;AACtD,aAAS,KAAK,WAAW,MAAM,IAAI,GAAG,eAAe,IAAI,KAAK,MAAM,OAAO,MAAM,CAAC,KAAK,IAAI,IAAI;AAAA,EACjG;AAEA,SAAO;AACT;AAWO,SAAS,mCAAmC,SAA8D;AAC/G,MAAI,SAAS,SAAS,2BAA2B;AAC/C,WAAO;AAAA,EACT;AAEA,SAAO;AAAA,IACL,GAAG;AAAA,IACH,sBAAsB,SAAS,wBAAwB;AAAA,IACvD,MAAM;AAAA,EACR;AACF;AAiBA,SAAS,wBACP,SACA,WACsC;AACtC,MAAI,SAAS,SAAS,6BAA6B,qBAAqB,iBAAiB;AACvF,UAAM,cAAc,UAAU,eAAe;AAC7C,QAAI,sBAAsB,QAAQ,IAAI,mCAAmC,YAAY,SAAS,cAAc,YAAY,QAAQ,EAAE;AAClI,WAAO;AAAA,MACL,GAAG;AAAA,MACH,UAAU,YAAY;AAAA,MACtB,WAAW,YAAY;AAAA,IACzB;AAAA,EACF;AAEA,OAAK,YAAY,UAAa,QAAQ,SAAS,mBAAmB,qBAAqB,qBAAqB;AAC1G,UAAM,WAAW,UAAU,yBAAyB;AACpD,QAAI,UAAU;AACZ,UAAI,sBAAsB,sBAAsB,qCAAqC,SAAS,IAAI,UAAU,OAAO,SAAS,IAAI,CAAC,EAAE;AACnI,aAAO;AAAA,QACL,GAAG;AAAA,QACH,MAAM,SAAS;AAAA,QACf,wBAAwB;AAAA,QACxB,MAAM,SAAS;AAAA,QACf,MAAM;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;AAeA,eAAe,oBAAoB,QAAoD;AACrF,QAAM,EAAE,iBAAiB,OAAO,aAAa,gBAAgB,UAAU,IAAI;AAC3E,QAAM,WAAW,MAAM,gBAAgB,WAAW;AAClD,QAAM,eAAe,KAAK,MAAM,MAAM,SAAS,KAAK,UAAU,eAAe,GAAG,OAAO,CAAC;AACxF,QAAM,WAAW,aAAa;AAK9B,MAAI,UAAU,YAAY,aAAa,eAAe;AACpD,UAAM,IAAI,2BAA2B,QAAQ;AAAA,EAC/C;AAEA,QAAM,SAAS,KAAK,UAAU,OAAO;AACrC,QAAM,YAAY,MAAM,KAAK,MAAM;AACnC,MAAI,sBAAsB,KAAK,WAAW,QAAQ,KAAK,UAAU,MAAM,YAAY,CAAC,0BAA0B;AAE9G,QAAM,uBAAuB,EAAE,iBAAiB,UAAU,UAAU,WAAW,eAAe,KAAK,CAAC;AACpG,MAAI,sBAAsB,KAAK,gBAAgB,QAAQ,UAAU,mBAAmB,wBAAwB,kCAAkC;AAE9I,SAAO;AACT;AASA,eAAe,4BAA4B,QAA0D;AACnG,QAAM,EAAE,OAAO,WAAW,gBAAgB,WAAW,iBAAiB,IAAI;AAC1E,aAAW,YAAY,WAAW;AAChC,QAAI,sBAAsB,KAAK,sCAAsC,QAAQ,MAAM;AACnF,UAAM,oBAAoB,EAAE,OAAO,UAAU,gBAAgB,WAAW,iBAAiB,CAAC;AAAA,EAC5F;AACF;AAWA,eAAe,oBAAoB,QAAkD;AACnF,QAAM,EAAE,OAAO,UAAU,gBAAgB,WAAW,iBAAiB,IAAI;AACzE,MAAI,sBAAsB,KAAK,sBAAsB,QAAQ,MAAM;AASnE,QAAM,gBAAgB,MAAM,UAAU,sBAAsB;AAY5D,QAAM,cAAc,IAAI,8BAA8B,gBAAgB;AACtE,QAAM,0BAA0B,4CAA4C,gBAAgB;AAE5F,WAAS,UAAU,GAAG,WAAW,aAAa,WAAW;AACvD,QAAI;AACJ,QAAI;AACF,eAAS,MAAM,eAAe;AAAA,QAC5B,UAAU;AAAA,QACV,OAAO,EAAE,SAAS;AAAA,QAClB,2BAA2B;AAAA,QAC3B;AAAA,QACA,WAAW,eAAe;AAAA,MAC5B,CAAC;AAAA,IACH,SAAS,OAAO;AAKd,UAAI,UAAU,aAAa;AACzB,cAAM,sBAAsB,kCAAkC,yBAAyB,UAAU,CAAC;AAClG;AAAA,UACE,sBAAsB,KAAK,oBAAoB,OAAO,OAAO,CAAC,IAAI,OAAO,WAAW,CAAC,WAC7E,cAAc,KAAK,CAAC,kBAAkB,OAAO,mBAAmB,CAAC;AAAA,QAC3E;AACA,cAAM,MAAM,mBAAmB;AAC/B;AAAA,MACF;AACA,YAAM;AAAA,IACR;AAMA,UAAM,YAAY,OAAO,gBAAgB,OAAO;AAEhD,QAAI,OAAO,YAAY,CAAC,WAAW;AACjC,YAAM,gBAAgB,UAAU,IAAI,aAAa,OAAO,OAAO,CAAC,IAAI,OAAO,WAAW,CAAC,MAAM;AAC7F,UAAI,sBAAsB,KAAK,aAAa,QAAQ,yBAAyB,aAAa,GAAG;AAC7F;AAAA,IACF;AAGA,QAAI,CAAC,wBAAwB,MAAM,GAAG;AACpC,YAAM,IAAI,MAAM,WAAW,QAAQ,qBAAqB,aAAa,mCAAmC,QAAQ,CAAC,EAAE;AAAA,IACrH;AAGA,QAAI,UAAU,aAAa;AACzB,YAAM,sBAAsB,kCAAkC,yBAAyB,UAAU,CAAC;AAClG;AAAA,QACE,sBAAsB,KAAK,aAAa,QAAQ,qCAChC,OAAO,OAAO,CAAC,IAAI,OAAO,WAAW,CAAC,kBAAkB,OAAO,mBAAmB,CAAC;AAAA,MACrG;AACA,YAAM,MAAM,mBAAmB;AAAA,IACjC;AAAA,EACF;AAOA,QAAM,aAAa,MAAM,UAAU,0BAA0B,aAAa;AAC1E,QAAM,SAAS,cAAc,mCAAmC,QAAQ;AACxE,QAAM,IAAI,MAAM,WAAW,QAAQ,qBAAqB,MAAM,EAAE;AAClE;AAOA,SAAS,kBAA0B;AACjC,MAAI,YAAY,QAAQ,IAAI;AAG5B,SAAO,MAAM;AACX,QAAI,WAAW,KAAK,WAAW,cAAc,CAAC,GAAG;AAC/C,aAAO;AAAA,IACT;AACA,UAAM,SAAS,KAAK,WAAW,IAAI;AACnC,QAAI,WAAW,WAAW;AACxB,YAAM,IAAI,MAAM,sDAAsD;AAAA,IACxE;AACA,gBAAY;AAAA,EACd;AACF;AAaA,SAAS,aAAa,kBAA4E;AAChG,SAAO,kBAAkB,SAAS,4BAA4B,qBAAqB;AACrF;AAsBA,SAAS,gCAAsC;AAC7C,MAAI,4BAA4B;AAC9B;AAAA,EACF;AACA,+BAA6B;AAE7B,UAAQ,GAAG,cAAc,MAAM;AAC7B,QAAI,aAAa,SAAS,GAAG;AAC3B;AAAA,IACF;AAEA,QAAI,+CAA+C,OAAO,aAAa,IAAI,CAAC,yCAAyC;AAErH,eAAW,UAAU,cAAc;AACjC,mBAAa,MAAM,EAAE,MAAM,CAAC,UAAmB;AAC7C,YAAI,yBAAyB,OAAO,cAAc,wCAAwC,cAAc,KAAK,CAAC,EAAE;AAAA,MAClH,CAAC;AAAA,IACH;AAAA,EACF,CAAC;AAED,UAAQ,GAAG,sBAAsB,MAAM;AACrC,QAAI,aAAa,SAAS,GAAG;AAC3B;AAAA,IACF;AAEA,QAAI,qEAAqE,OAAO,aAAa,IAAI,CAAC,qBAAqB;AACvH,eAAW,UAAU,cAAc;AACjC,mBAAa,MAAM,EAAE,MAAM,CAAC,UAAmB;AAC7C,YAAI,yBAAyB,OAAO,cAAc,0CAA0C,cAAc,KAAK,CAAC,EAAE;AAAA,MACpH,CAAC;AAAA,IACH;AAAA,EACF,CAAC;AAED,UAAQ,GAAG,QAAQ,MAAM;AACvB,QAAI,aAAa,SAAS,GAAG;AAC3B;AAAA,IACF;AAEA,QAAI,wCAAwC,OAAO,aAAa,IAAI,CAAC,qBAAqB;AAC1F,eAAW,UAAU,cAAc;AACjC,UAAI;AACF,eAAO,UAAU,cAAc;AAAA,MACjC,SAAS,OAAgB;AACvB,YAAI,yBAAyB,OAAO,cAAc,+CAA+C,cAAc,KAAK,CAAC,EAAE;AAAA,MACzH;AACA,UAAI;AACF,eAAO,OAAO,eAAe,MAAM,EAAE,OAAO,MAAM,WAAW,KAAK,CAAC;AAAA,MACrE,SAAS,OAAgB;AACvB,YAAI,yBAAyB,OAAO,cAAc,2CAA2C,cAAc,KAAK,CAAC,EAAE;AAAA,MACrH;AACA,uBAAiB,MAAM;AAAA,IACzB;AACA,iBAAa,MAAM;AAAA,EACrB,CAAC;AACH;AAOA,SAAS,iBAAiB,QAA+B;AACvD,QAAM,OAAO,WAAW,IAAI,MAAM;AAClC,MAAI,MAAM;AACR,SAAK,QAAQ;AACb,eAAW,OAAO,MAAM;AAAA,EAC1B;AACF;AAWA,eAAe,gBAAgB,aAAsC;AACnE,QAAM,UAAU,KAAK,aAAa,QAAQ;AAC1C,QAAM,YAAY,KAAK,aAAa,UAAU;AAC9C,QAAM,YAAY,KAAK,SAAS,OAAO;AACvC,QAAM,cAAc,KAAK,WAAW,OAAO;AAC3C,QAAM,UAAU,WAAW,SAAS,IAAI,MAAM,KAAK,SAAS,IAAI;AAChE,QAAM,YAAY,WAAW,WAAW,IAAI,MAAM,KAAK,WAAW,IAAI;AAEtE,MAAI,WAAW,WAAW;AACxB,WAAO,QAAQ,QAAQ,UAAU,QAAQ,UAAU;AAAA,EACrD;AAEA,MAAI,SAAS;AACX,WAAO;AAAA,EACT;AAEA,MAAI,WAAW;AACb,WAAO;AAAA,EACT;AAEA,QAAM,IAAI,MAAM,6DAA6D;AAC/E;AAaA,eAAe,kBAAkB,QAAgD;AAC/E,QAAM,EAAE,OAAO,aAAa,qBAAqB,iBAAiB,IAAI;AAEtE,MAAI,CAAC,uBAAuB,CAAC,uBAAuB,gBAAgB,GAAG;AACrE;AAAA,EACF;AAEA,MAAI;AACJ,MAAI;AACF,UAAM,WAAW,MAAM,gBAAgB,WAAW;AAClD,mBAAe,KAAK,MAAM,MAAM,SAAS,KAAK,UAAU,eAAe,GAAG,OAAO,CAAC;AAAA,EACpF,QAAQ;AACN;AAAA,EACF;AAEA,MAAI,CAAC,aAAa,eAAe;AAC/B;AAAA,EACF;AAEA;AAAA,IACE,sBAAsB,KAAK,eAAe,aAAa,EAAE;AAAA,EAE3D;AACA,QAAM,IAAI,2BAA2B,aAAa,EAAE;AACtD;AAcA,eAAe,eAAe,QAA6C;AACzE,QAAM,EAAE,OAAO,OAAO,iBAAiB,IAAI;AAC3C,MAAI,CAAC,mBAAmB,gBAAgB,GAAG;AACzC;AAAA,EACF;AAEA,MAAI;AACF,UAAM,SAAS,MAAM,mBAAmB;AAAA,MACtC,eAAe,OAAO;AAAA,MACtB,sBAAsB,oCAAoC,gBAAgB;AAAA,IAC5E,CAAC;AACD,QAAI,OAAO,eAAe,KAAK,OAAO,cAAc,GAAG;AACrD;AAAA,QACE,gBAAgB,KAAK,IAAI,KAAK,WAAW,OAAO,OAAO,YAAY,CAAC,mDAC1C,OAAO,OAAO,WAAW,CAAC;AAAA,MACtD;AAAA,IACF;AAAA,EACF,SAAS,OAAgB;AACvB,QAAI,gBAAgB,KAAK,IAAI,KAAK,uCAAuC,cAAc,KAAK,CAAC,EAAE;AAAA,EACjG;AACF;AAOA,eAAe,cAAc,QAAwC;AACnE,MAAI;AACF,UAAM,OAAO,eAAe,QAAQ,OAAO,SAAS;AAAA,EACtD,SAAS,OAAgB;AACvB,QAAI,yBAAyB,OAAO,cAAc,sCAAsC,cAAc,KAAK,CAAC,EAAE;AAAA,EAChH;AAEA,MAAI;AACF,UAAM,OAAO,UAAU,UAAU;AAAA,EACnC,SAAS,OAAgB;AACvB,QAAI,yBAAyB,OAAO,cAAc,0CAA0C,cAAc,KAAK,CAAC,EAAE;AAAA,EACpH;AACF;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/global-setup-core.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Framework-agnostic core logic for integration test global setup and teardown.\n *\n * Vitest and Jest adapters delegate to these functions.\n */\n\n/* v8 ignore start -- Integration-time setup covered by integration tests, not unit tests. */\n\nimport type { PluginManifest } from 'obsidian';\n\nimport {\n  existsSync,\n  rmSync\n} from 'node:fs';\nimport {\n  readFile,\n  stat\n} from 'node:fs/promises';\nimport {\n  basename,\n  join\n} from 'node:path';\nimport process, { loadEnvFile } from 'node:process';\nimport { setTimeout as sleep } from 'node:timers/promises';\n\nimport type { EnablePluginResult } from './enable-plugin.mjs';\nimport type { SetupLock } from './setup-lock.mjs';\nimport type { PopulateFilesParams } from './temporary-vault.mjs';\nimport type { ObsidianTransportOptions } from './transport-options.mjs';\nimport type { ObsidianTransport } from './transport.mjs';\n\nimport { DEFAULT_CONFIG_DIRECTORY } from './config-directory.mjs';\nimport { DesktopOnlyPluginSkipError } from './desktop-only-plugin-skip-error.mjs';\nimport {\n  enablePluginWithErrorCapture,\n  getGenericPluginLoadFailureMessage\n} from './enable-plugin.mjs';\nimport { errorToString } from './error-to-string.mjs';\nimport { evalInObsidian } from './eval-in-obsidian.mjs';\nimport { ensureHeadlessVaultConfig } from './headless-vault-config.mjs';\nimport {\n  resolveLeftoverMaxAgeInMilliseconds,\n  sweepHostLeftovers,\n  willSweepLeftovers\n} from './leftover-cleanup.mjs';\nimport { log } from './log.mjs';\nimport {\n  computeBackoffDelayInMilliseconds,\n  resolvePluginEnableRetryCount,\n  resolvePluginEnableRetryDelayInMilliseconds,\n  shouldRetryPluginEnable\n} from './plugin-enable-retry.mjs';\nimport {\n  acquireSetupLock,\n  ANDROID_SETUP_LOCK_SCOPE\n} from './setup-lock.mjs';\nimport { TemporaryVault } from './temporary-vault.mjs';\nimport { AppiumTransport } from './transport-appium.mjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nimport { createTransportFromOptions } from './transport-factory.mjs';\nimport {\n  checkIsMobileTransport,\n  resolveOwnedConfigDirectory\n} from './transport-options.mjs';\nimport { installPluginIntoVault } from './vault-plugin-install.mjs';\n\nconst DEFAULT_TRANSPORT_TYPE = 'obsidian-cdp';\nconst DIST_DEV = 'dist/dev';\nconst DIST_BUILD = 'dist/build';\nconst MAIN_JS = 'main.js';\n\n/**\n * Tracks setups that completed successfully but haven't been torn down yet.\n * Used by the `beforeExit` handler to clean up when a test runner exits\n * without calling teardown (e.g., when one project's setup fails and the\n * runner aborts before tearing down already-initialized projects).\n */\nconst activeSetups = new Set<CoreSetupResult>();\nconst disposedResults = new WeakSet<CoreSetupResult>();\nlet isCleanupHandlerRegistered = false;\n\n/**\n * The cross-process setup lock held by each active setup. Released when the\n * setup is torn down (or by the process cleanup handlers), allowing a competing\n * run to proceed. See {@link acquireSetupLock}.\n */\nconst setupLocks = new Map<CoreSetupResult, SetupLock>();\n\n/**\n * Parameters for {@link coreSetup}.\n */\nexport interface CoreSetupParams {\n  /**\n   * Community-plugin ids to enable in the vault **in addition to** the\n   * plugin-under-test, after it is enabled. Each id's built files must already be\n   * present under `.obsidian/plugins/<id>/` \u2014 seed them via {@link CoreSetupParams.populate}\n   * (e.g. with `buildDemoVaultPopulate`). Enabling goes through the same\n   * retry/load-verify path as the plugin-under-test. Composes with\n   * `installPlugin: false` (enable extras into an otherwise plugin-less vault).\n   */\n  readonly enableCommunityPlugins?: readonly string[] | undefined;\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 (e.g. a typings\n   * crawler) that only needs a registered, empty vault to `evalInObsidian`\n   * against: the plugin `dist`/`manifest.json` read, the copy into the config\n   * folder's `plugins/`, the `community-plugins.json` write, and the enable step\n   * are all skipped, while the transport, temp vault, registration, and\n   * worker-facing endpoint provisioning still run unchanged.\n   */\n  readonly installPlugin?: boolean | undefined;\n\n  /**\n   * Files and folders to write into the vault **before** Obsidian opens it, so\n   * its startup scan indexes them in one pass (see {@link TemporaryVault.populate}).\n   * Use this for large fixtures \u2014 writing thousands of notes after open and\n   * forcing a re-scan is far slower and less reliable.\n   *\n   * Keys naming the config folder are written as `.obsidian/\u2026`; under a\n   * `configDirectory` override {@link remapConfigDirectoryKeys} redirects them to\n   * the folder the vault will actually read, so a map does not have to carry a\n   * second copy of the override.\n   */\n  readonly populate?: PopulateFilesParams | undefined;\n\n  /**\n  Transport options. When omitted, uses an off-screen owned desktop instance.\n   */\n  readonly transportOptions?: ObsidianTransportOptions | undefined;\n}\n\n/**\n * Result returned by {@link coreSetup}, used by framework adapters\n * to pass context to test workers.\n */\nexport interface CoreSetupResult {\n  /**\n  The temporary vault created during setup.\n   */\n  readonly temporaryVault: TemporaryVault;\n\n  /**\n  The transport instance used during setup.\n   */\n  readonly transport: ObsidianTransport;\n\n  /**\n  Short label for log messages (e.g. `\"obsidian-cdp\"`).\n   */\n  readonly transportLabel: string;\n\n  /**\n  The transport options that were resolved.\n   */\n  readonly transportOptions: ObsidianTransportOptions | undefined;\n}\n\n/**\n * Parameters for {@link copyPluginIntoVault}.\n */\ninterface CopyPluginIntoVaultParams {\n  /**\n  The config folder the vault will read, when overridden away from `.obsidian` \u2014 the resolved\n  {@link resolveOwnedConfigDirectory} value, which is `undefined` for Obsidian's own default.\n   */\n  readonly configDirectory: string | undefined;\n\n  /**\n  Short label for log messages.\n   */\n  readonly label: string;\n\n  /**\n  The project root to resolve the built plugin from.\n   */\n  readonly projectRoot: string;\n\n  /**\n  The temp vault to copy the plugin into.\n   */\n  readonly temporaryVault: TemporaryVault;\n\n  /**\n  The transport (used for the mobile/desktop-only compatibility check).\n   */\n  readonly transport: ObsidianTransport;\n}\n\n/**\n * Parameters for {@link enableExtraCommunityPlugins}.\n */\ninterface EnableExtraCommunityPluginsParams {\n  /**\n  Short label for log messages.\n   */\n  readonly label: string;\n\n  /**\n  The ids of the extra community plugins to enable (their binaries must already be in the vault).\n   */\n  readonly pluginIds: readonly string[];\n\n  /**\n  The temp vault the plugins were seeded into.\n   */\n  readonly temporaryVault: TemporaryVault;\n\n  /**\n  The transport to evaluate against.\n   */\n  readonly transport: ObsidianTransport;\n\n  /**\n  The resolved transport options (source of the plugin-enable retry knobs).\n   */\n  readonly transportOptions: null | ObsidianTransportOptions;\n}\n\n/**\n * Parameters for {@link enablePluginInVault}.\n */\ninterface EnablePluginInVaultParams {\n  /**\n  Short label for log messages.\n   */\n  readonly label: string;\n\n  /**\n  The id of the plugin to enable.\n   */\n  readonly pluginId: string;\n\n  /**\n  The temp vault the plugin was copied into.\n   */\n  readonly temporaryVault: TemporaryVault;\n\n  /**\n  The transport to evaluate against.\n   */\n  readonly transport: ObsidianTransport;\n\n  /**\n  The resolved transport options (source of the plugin-enable retry knobs).\n   */\n  readonly transportOptions: null | ObsidianTransportOptions;\n}\n\n/**\n * Parameters for {@link skipIfDesktopOnly}.\n */\ninterface SkipIfDesktopOnlyParams {\n  /**\n  Short label for log messages.\n   */\n  readonly label: string;\n\n  /**\n  The project root to resolve the built plugin's manifest from.\n   */\n  readonly projectRoot: string;\n\n  /**\n  Whether a plugin is being installed at all -- there is nothing to check when the vault stays empty.\n   */\n  readonly shouldInstallPlugin: boolean;\n\n  /**\n  The resolved transport options, whose discriminant says whether this run is mobile.\n   */\n  readonly transportOptions: ObsidianTransportOptions;\n}\n\n/**\n * Parameters for {@link sweepLeftovers}.\n */\ninterface SweepLeftoversParams {\n  /**\n  Directory names to keep regardless of age (e.g. a concurrent setup's vault).\n   */\n  readonly excludedNames?: readonly string[] | undefined;\n\n  /**\n  Short label for log messages.\n   */\n  readonly label: string;\n\n  /**\n  Which end of the run is sweeping, for the log prefix.\n   */\n  readonly phase: 'setup' | 'teardown';\n\n  /**\n  The resolved transport options (source of the sweep knobs).\n   */\n  readonly transportOptions: ObsidianTransportOptions | undefined;\n}\n\n/**\n * Framework-agnostic global setup logic.\n *\n * Loads `.env` from the project root, creates a transport, creates and registers\n * a temporary vault with Obsidian, and \u2014 unless {@link CoreSetupParams.installPlugin}\n * is `false` \u2014 copies the built plugin into the vault and enables it. The\n * plugin-less mode still launches the owned instance and publishes its\n * worker-facing endpoint, so a non-plugin consumer reuses the same attach wiring.\n *\n * @param params - Setup parameters.\n * @returns The setup result containing the temp vault, transport, and resolved options.\n */\nexport async function coreSetup(params?: CoreSetupParams): Promise<CoreSetupResult> {\n  const projectRoot = findProjectRoot();\n  const envFilePath = join(projectRoot, '.env');\n  if (existsSync(envFilePath)) {\n    loadEnvFile(envFilePath);\n  }\n\n  const transportOptions = resolveIntegrationTransportOptions(params?.transportOptions);\n  const label = transportOptions.type;\n  const shouldInstallPlugin = params?.installPlugin !== false;\n\n  // Before the lock, the sweep and above all the transport: creating a mobile transport boots the AVD and\n  // Auto-starts Appium (~70 s) only to reach the same conclusion from `transport.isMobile` further down.\n  // Neither input needs a device -- the manifest is on disk and the discriminant already says mobile.\n  await skipIfDesktopOnly({ label, projectRoot, shouldInstallPlugin, transportOptions });\n\n  const lockScope = getLockScope(transportOptions);\n\n  let lock: SetupLock | undefined;\n  if (lockScope !== undefined) {\n    log(`[integration-setup:${label}] Acquiring '${lockScope}' setup lock (serializes against any concurrent integration-test run)...`);\n    lock = await acquireSetupLock({ label, scope: lockScope });\n    log(`[integration-setup:${label}] Setup lock acquired.`);\n  }\n\n  await sweepLeftovers({ label, phase: 'setup', transportOptions });\n\n  let transport: ObsidianTransport | undefined;\n  let temporaryVault: TemporaryVault | undefined;\n\n  try {\n    log(`[integration-setup:${label}] Creating transport...`);\n    transport = await createTransportFromOptions(transportOptions);\n    log(`[integration-setup:${label}] Transport created: ${transport.constructor.name}`);\n\n    log(`[integration-setup:${label}] Project root: ${projectRoot}`);\n\n    temporaryVault = new TemporaryVault();\n    log(`[integration-setup:${label}] Created temp vault: ${temporaryVault.path}`);\n\n    /*\n     * Which folder this vault will actually read, resolved once and handed to every writer below.\n     * Every pre-open write has to agree on it: one that hardcodes `.obsidian` under an override writes\n     * somewhere nothing looks, and nothing throws to say so.\n     */\n    const configDirectory = resolveOwnedConfigDirectory(transportOptions);\n\n    let pluginId: string | undefined;\n\n    if (shouldInstallPlugin) {\n      pluginId = await copyPluginIntoVault({ configDirectory, label, projectRoot, temporaryVault, transport });\n    } else {\n      log(`[integration-setup:${label}] Skipping plugin install (installPlugin: false) \u2014 registering an empty vault.`);\n    }\n\n    if (params?.populate) {\n      const populate = remapConfigDirectoryKeys(params.populate, configDirectory);\n      const entryCount = Object.keys(populate).length;\n      log(`[integration-setup:${label}] Populating vault with ${String(entryCount)} entries before open...`);\n      temporaryVault.populate(populate);\n    }\n\n    await ensureHeadlessVaultConfig({\n      configDirectory,\n      label,\n      vaultPath: temporaryVault.path\n    });\n\n    // `register` pushes the directory to the device before registering it, so every write above \u2014\n    // The plugin copy, the populate map, and the headless config just written \u2014 reaches the app.\n    log(`[integration-setup:${label}] Registering vault...`);\n    await temporaryVault.register(transport);\n    log(`[integration-setup:${label}] Vault registered.`);\n\n    if (pluginId !== undefined) {\n      await enablePluginInVault({ label, pluginId, temporaryVault, transport, transportOptions });\n    }\n\n    await enableExtraCommunityPlugins({\n      label,\n      pluginIds: params?.enableCommunityPlugins ?? [],\n      temporaryVault,\n      transport,\n      transportOptions\n    });\n\n    const augmentedOptions = augmentTransportOptions(transportOptions, transport);\n    const result: CoreSetupResult = { temporaryVault, transport, transportLabel: label, transportOptions: augmentedOptions };\n    activeSetups.add(result);\n    if (lock) {\n      setupLocks.set(result, lock);\n    }\n    registerProcessCleanupHandler();\n    return result;\n  } catch (error: unknown) {\n    log(`[integration-setup:${label}] Setup failed, cleaning up...`);\n    try {\n      if (temporaryVault && transport) {\n        await temporaryVault.dispose(transport);\n      }\n    } catch (cleanupError: unknown) {\n      log(`[integration-setup:${label}] Vault cleanup error (non-fatal): ${errorToString(cleanupError)}`);\n    }\n    try {\n      await transport?.dispose?.();\n    } catch (cleanupError: unknown) {\n      log(`[integration-setup:${label}] Transport cleanup error (non-fatal): ${errorToString(cleanupError)}`);\n    }\n\n    // Release the lock so a waiting run can proceed even though this run failed.\n    lock?.release();\n\n    log(`[integration-setup:${label}] NOTE: If the test runner reports \"No test files found\", ignore it \u2014 it is a side effect of the setup failure above.`);\n    throw error;\n  }\n}\n\n/**\n * Framework-agnostic global teardown logic.\n *\n * Disposes of the temporary vault and transport created during setup.\n *\n * @param result - The result from {@link coreSetup}. When `undefined`, does nothing.\n */\nexport async function coreTeardown(result?: CoreSetupResult): Promise<void> {\n  if (!result || disposedResults.has(result)) {\n    return;\n  }\n  disposedResults.add(result);\n\n  log(`[integration-teardown:${result.transportLabel}] Tearing down...`);\n\n  try {\n    await teardownAsync(result);\n  } catch (error: unknown) {\n    log(`[integration-teardown:${result.transportLabel}] Cleanup error (non-fatal): ${errorToString(error)}`);\n  } finally {\n    activeSetups.delete(result);\n    releaseSetupLock(result);\n  }\n\n  await sweepLeftovers({\n    excludedNames: [...activeSetups].map((activeSetup) => basename(activeSetup.temporaryVault.path)),\n    label: result.transportLabel,\n    phase: 'teardown',\n    transportOptions: result.transportOptions\n  });\n}\n\n/**\n * Redirects a populate map's config-folder entries to the folder the vault will actually read.\n *\n * A populate map names its destinations vault-relative, and everything that builds one \u2014 including\n * `buildDemoVaultPopulate`, which seeds `.obsidian/*` config files and injected community plugins'\n * binaries \u2014 writes them under a literal `.obsidian/`, because that is the folder Obsidian uses when nothing\n * overrides it. Under a `configDirectory` override those entries land in a folder the vault never opens, and\n * the plugins seeded that way come back as the generic \"enabled but not loaded\" with nothing naming a config\n * folder. Rewriting the key here fixes every consumer at once \u2014 a hand-written map as much as a demo vault's\n * \u2014 and needs no second copy of the override for a caller to keep in sync with their transport options.\n *\n * Safe rather than magic: the vault is one the harness made for this run and has exactly one config folder,\n * so under an override a `.obsidian/` entry is dead weight nothing reads. Only a leading `.obsidian` path\n * SEGMENT moves; a note whose name merely contains the string does not.\n *\n * @param populate - The consumer's populate map.\n * @param configDirectory - The resolved override, or `undefined` for Obsidian's default (a no-op).\n * @returns The map with its config-folder keys redirected, or the original map when there is nothing to move.\n */\nexport function remapConfigDirectoryKeys(populate: PopulateFilesParams, configDirectory: string | undefined): PopulateFilesParams {\n  if (configDirectory === undefined || configDirectory === DEFAULT_CONFIG_DIRECTORY) {\n    return populate;\n  }\n\n  const prefix = `${DEFAULT_CONFIG_DIRECTORY}/`;\n  const remapped: PopulateFilesParams = {};\n  for (const [path, content] of Object.entries(populate)) {\n    remapped[path.startsWith(prefix) ? `${configDirectory}/${path.slice(prefix.length)}` : path] = content;\n  }\n\n  return remapped;\n}\n\n/**\n * Resolves transport options for an integration run.\n *\n * Desktop launches are normally visible, but test setup explicitly keeps its\n * owned instance off-screen so it does not interrupt the developer.\n *\n * @param options - Consumer-provided transport options.\n * @returns Options with the desktop integration visibility default applied.\n */\nexport function resolveIntegrationTransportOptions(options?: ObsidianTransportOptions): ObsidianTransportOptions {\n  if (options?.type === 'obsidian-android-appium') {\n    return options;\n  }\n\n  return {\n    ...options,\n    isObsidianAppVisible: options?.isObsidianAppVisible ?? false,\n    type: 'obsidian-cdp'\n  };\n}\n\n/**\n * Augments transport options with reuse info so test workers can reattach to the\n * instance the global setup already launched instead of creating their own:\n *\n * - **Appium** \u2014 injects the established `sessionId`/`deviceId`.\n * - **Owned desktop CDP** \u2014 injects the owned instance's `host`/`port` (chosen\n *   at launch) plus the internal `isHarnessOwnedInstance` flag, so each worker\n *   **attaches** to that instance over CDP rather than launching (and never\n *   registering) its own \u2014 the bug that otherwise leaves a worker's transport\n *   with no CDP endpoint.\n *\n * @param options - The original transport options.\n * @param transport - The transport instance created during setup.\n * @returns The augmented options, or the original options if not applicable.\n */\nfunction augmentTransportOptions(\n  options: ObsidianTransportOptions | undefined,\n  transport: ObsidianTransport\n): ObsidianTransportOptions | undefined {\n  if (options?.type === 'obsidian-android-appium' && transport instanceof AppiumTransport) {\n    const sessionInfo = transport.getSessionInfo();\n    log(`[integration-setup:${options.type}] Session reuse info: sessionId=${sessionInfo.sessionId}, deviceId=${sessionInfo.deviceId}`);\n    return {\n      ...options,\n      deviceId: sessionInfo.deviceId,\n      sessionId: sessionInfo.sessionId\n    };\n  }\n\n  if ((options === undefined || options.type === 'obsidian-cdp') && transport instanceof DesktopCdpTransport) {\n    const endpoint = transport.getOwnedInstanceEndpoint();\n    if (endpoint) {\n      log(`[integration-setup:${DEFAULT_TRANSPORT_TYPE}] Owned instance reuse info: host=${endpoint.host}, port=${String(endpoint.port)}`);\n      return {\n        ...options,\n        host: endpoint.host,\n        isHarnessOwnedInstance: true,\n        port: endpoint.port,\n        type: 'obsidian-cdp'\n      };\n    }\n  }\n\n  return options;\n}\n\n/**\n * Copies the built plugin into the temp vault and marks it as a community plugin.\n *\n * Reads `manifest.json` from the newer of `dist/dev`/`dist/build`, rejects a\n * desktop-only plugin on a mobile transport, then hands the write itself to\n * {@link installPluginIntoVault} \u2014 which puts the build in\n * `<configDirectory>/plugins/<id>` and writes\n * `<configDirectory>/community-plugins.json`, honouring a `configDirectory`\n * override so the plugin lands where the vault will actually look for it.\n *\n * @param params - The copy parameters.\n * @returns The plugin id read from the manifest.\n */\nasync function copyPluginIntoVault(params: CopyPluginIntoVaultParams): Promise<string> {\n  const { configDirectory, label, projectRoot, temporaryVault, transport } = params;\n  const distPath = await resolveDistPath(projectRoot);\n  const manifestJson = JSON.parse(await readFile(join(distPath, 'manifest.json'), 'utf-8')) as PluginManifest;\n  const pluginId = manifestJson.id;\n\n  // The same refusal {@link skipIfDesktopOnly} already made before the transport existed. Kept as the\n  // Backstop for any caller that reaches here another way, and throwing the same type so both paths read\n  // Identically in the log.\n  if (transport.isMobile && manifestJson.isDesktopOnly) {\n    throw new DesktopOnlyPluginSkipError(pluginId);\n  }\n\n  const mainJs = join(distPath, MAIN_JS);\n  const buildStat = await stat(mainJs);\n  log(`[integration-setup:${label}] Using ${distPath} (${buildStat.mtime.toISOString()}). If outdated, rebuild.`);\n\n  await installPluginIntoVault({ configDirectory, distPath, pluginId, vaultPath: temporaryVault.path });\n  log(`[integration-setup:${label}] Installed \"${pluginId}\" into ${configDirectory ?? DEFAULT_CONFIG_DIRECTORY}/plugins (and enabled it there).`);\n\n  return pluginId;\n}\n\n/**\n * Enables extra community plugins (beyond the plugin-under-test) in the registered vault, each through the\n * same {@link enablePluginInVault} path. Each plugin's built files must already be present in the vault (seed\n * them via {@link CoreSetupParams.populate}). A no-op when the list is empty.\n *\n * @param params - The enable parameters.\n */\nasync function enableExtraCommunityPlugins(params: EnableExtraCommunityPluginsParams): Promise<void> {\n  const { label, pluginIds, temporaryVault, transport, transportOptions } = params;\n  for (const pluginId of pluginIds) {\n    log(`[integration-setup:${label}] Enabling extra community plugin \"${pluginId}\"...`);\n    await enablePluginInVault({ label, pluginId, temporaryVault, transport, transportOptions });\n  }\n}\n\n/**\n * Enables the plugin in the registered vault and verifies it loaded.\n *\n * Obsidian's `enablePlugin()` wraps `loadPlugin()` in a try-catch that swallows\n * errors and returns false, so {@link enablePluginWithErrorCapture} monkey-patches\n * `loadPlugin()` to capture the error before it's swallowed.\n *\n * @param params - The enable parameters.\n */\nasync function enablePluginInVault(params: EnablePluginInVaultParams): Promise<void> {\n  const { label, pluginId, temporaryVault, transport, transportOptions } = params;\n  log(`[integration-setup:${label}] Enabling plugin \"${pluginId}\"...`);\n\n  /*\n   * Open a native console-capture window (Layer 2, Android only) around the\n   * enable so that if Obsidian swallows the load error before the monkey-patch\n   * and the renderer console (Layer 1) came up empty, we can still recover the\n   * real cause from `adb logcat`. No-op (undefined) on transports that don't\n   * implement it (e.g. desktop).\n   */\n  const captureHandle = await transport.beginConsoleCapture?.();\n\n  /*\n   * On a freshly cold-booted emulator the plugin subsystem can still be settling\n   * when we enable the plugin, so a single-shot enable races the load and loses\n   * (the plugin lands in the enabled set but never loads). Retry the enable +\n   * load-verification a few times with exponential backoff, which recovers the\n   * transient race. A captured load error (`realError`) is a deterministic bug \u2014\n   * retrying cannot fix it, so we fail fast. Non-Android transports resolve to\n   * the same defaults but never enter the retry path: their load either succeeds\n   * on the first attempt or throws a captured error.\n   */\n  const maxAttempts = 1 + resolvePluginEnableRetryCount(transportOptions);\n  const baseDelayInMilliseconds = resolvePluginEnableRetryDelayInMilliseconds(transportOptions);\n\n  for (let attempt = 1; attempt <= maxAttempts; attempt++) {\n    let result: EnablePluginResult;\n    try {\n      result = await evalInObsidian({\n        callback: enablePluginWithErrorCapture,\n        input: { pluginId },\n        shouldSkipPreflightChecks: true,\n        transport,\n        vaultPath: temporaryVault.path\n      });\n    } catch (error) {\n      /*\n       * The eval itself threw (e.g. the WebView context was lost mid-execution on\n       * a churning guest) \u2014 a transport-level transient. Retry if attempts remain.\n       */\n      if (attempt < maxAttempts) {\n        const delayInMilliseconds = computeBackoffDelayInMilliseconds(baseDelayInMilliseconds, attempt - 1);\n        log(\n          `[integration-setup:${label}] Enable attempt ${String(attempt)}/${String(maxAttempts)} threw `\n            + `(${errorToString(error)}); retrying in ${String(delayInMilliseconds)}ms...`\n        );\n        await sleep(delayInMilliseconds);\n        continue;\n      }\n      throw error;\n    }\n\n    /*\n     * `errorMessage` is the real throw seen by the monkey-patch;\n     * `rendererConsoleErrors` (Layer 1) is the real cause console-logged in the renderer.\n     */\n    const realError = result.errorMessage ?? result.rendererConsoleErrors;\n\n    if (result.isLoaded && !realError) {\n      const attemptSuffix = attempt > 1 ? ` (attempt ${String(attempt)}/${String(maxAttempts)})` : '';\n      log(`[integration-setup:${label}] Plugin \"${pluginId}\" enabled successfully${attemptSuffix}.`);\n      return;\n    }\n\n    // A captured load error is deterministic \u2014 fail fast rather than retry.\n    if (!shouldRetryPluginEnable(result)) {\n      throw new Error(`Plugin \"${pluginId}\" failed to load: ${realError ?? getGenericPluginLoadFailureMessage(pluginId)}`);\n    }\n\n    // Transient cold-boot race (enabled but not loaded, no cause captured): retry.\n    if (attempt < maxAttempts) {\n      const delayInMilliseconds = computeBackoffDelayInMilliseconds(baseDelayInMilliseconds, attempt - 1);\n      log(\n        `[integration-setup:${label}] Plugin \"${pluginId}\" enabled but not loaded `\n          + `(attempt ${String(attempt)}/${String(maxAttempts)}); retrying in ${String(delayInMilliseconds)}ms...`\n      );\n      await sleep(delayInMilliseconds);\n    }\n  }\n\n  /*\n   * Exhausted every attempt on the transient signature: compose the most\n   * specific detail available (`adb logcat` tail on Android, else the generic\n   * message) \u2014 unchanged from the pre-retry single-shot failure.\n   */\n  const logcatTail = await transport.readConsoleCaptureSince?.(captureHandle);\n  const detail = logcatTail ?? getGenericPluginLoadFailureMessage(pluginId);\n  throw new Error(`Plugin \"${pluginId}\" failed to load: ${detail}`);\n}\n\n/**\n * Finds the project root by walking up from `process.cwd()` looking for `package.json`.\n *\n * @returns The absolute path to the project root.\n */\nfunction findProjectRoot(): string {\n  let directory = process.cwd();\n\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Loop terminates at filesystem root.\n  while (true) {\n    if (existsSync(join(directory, 'package.json'))) {\n      return directory;\n    }\n    const parent = join(directory, '..');\n    if (parent === directory) {\n      throw new Error('Could not find project root (no package.json found).');\n    }\n    directory = parent;\n  }\n}\n\n/**\n * Resolves the cross-process lock scope for a transport, or `undefined` when no\n * lock is needed.\n *\n * Desktop runs use harness-owned, isolated instances (their own user-data dir\n * and CDP port), so they no longer contend and need no lock. Only the Android\n * transport, which shares the single emulator and Appium server, must serialize.\n *\n * @param transportOptions - The resolved transport options.\n * @returns The lock scope string, or `undefined` if no lock is needed.\n */\nfunction getLockScope(transportOptions: ObsidianTransportOptions | undefined): string | undefined {\n  return transportOptions?.type === 'obsidian-android-appium' ? ANDROID_SETUP_LOCK_SCOPE : undefined;\n}\n\n/**\n * Registers cleanup handlers for orphaned setups that were never explicitly\n * torn down.\n *\n * Two handlers cover different exit scenarios:\n *\n * - `beforeExit` \u2014 fires when the event loop drains naturally. Allows full\n *   async teardown (unregister vaults, dispose transports). Does NOT fire\n *   when `process.exit()` is called directly.\n *\n * - `unhandledRejection` \u2014 catches async errors that bypass `coreSetup`'s\n *   catch block. Performs full async teardown while we still can.\n *\n * - `exit` \u2014 fires on every exit, including `process.exit()`. Only synchronous\n *   work is possible, so this handler does best-effort cleanup: kills child\n *   processes via `disposeSync()` and removes temp vault directories with\n *   `rmSync`. Unregistering vaults (which requires IPC with Obsidian) is\n *   skipped \u2014 a stale vault entry is an acceptable trade-off vs. leaked\n *   processes and temp directories.\n */\nfunction registerProcessCleanupHandler(): void {\n  if (isCleanupHandlerRegistered) {\n    return;\n  }\n  isCleanupHandlerRegistered = true;\n\n  process.on('beforeExit', () => {\n    if (activeSetups.size === 0) {\n      return;\n    }\n\n    log(`[integration-teardown] Process exiting with ${String(activeSetups.size)} setup(s) not torn down. Cleaning up...`);\n\n    for (const result of activeSetups) {\n      coreTeardown(result).catch((error: unknown) => {\n        log(`[integration-teardown:${result.transportLabel}] Process cleanup error (non-fatal): ${errorToString(error)}`);\n      });\n    }\n  });\n\n  process.on('unhandledRejection', () => {\n    if (activeSetups.size === 0) {\n      return;\n    }\n\n    log(`[integration-teardown] Unhandled rejection detected. Tearing down ${String(activeSetups.size)} active setup(s)...`);\n    for (const result of activeSetups) {\n      coreTeardown(result).catch((error: unknown) => {\n        log(`[integration-teardown:${result.transportLabel}] Rejection cleanup error (non-fatal): ${errorToString(error)}`);\n      });\n    }\n  });\n\n  process.on('exit', () => {\n    if (activeSetups.size === 0) {\n      return;\n    }\n\n    log(`[integration-teardown] Sync cleanup: ${String(activeSetups.size)} orphaned setup(s).`);\n    for (const result of activeSetups) {\n      try {\n        result.transport.disposeSync?.();\n      } catch (error: unknown) {\n        log(`[integration-teardown:${result.transportLabel}] Sync transport cleanup error (non-fatal): ${errorToString(error)}`);\n      }\n      try {\n        rmSync(result.temporaryVault.path, { force: true, recursive: true });\n      } catch (error: unknown) {\n        log(`[integration-teardown:${result.transportLabel}] Sync vault cleanup error (non-fatal): ${errorToString(error)}`);\n      }\n      releaseSetupLock(result);\n    }\n    activeSetups.clear();\n  });\n}\n\n/**\n * Releases and forgets the setup lock associated with a result, if any.\n *\n * @param result - The setup result whose lock should be released.\n */\nfunction releaseSetupLock(result: CoreSetupResult): void {\n  const lock = setupLocks.get(result);\n  if (lock) {\n    lock.release();\n    setupLocks.delete(result);\n  }\n}\n\n/**\n * Resolves the dist path to use for integration tests.\n *\n * Picks whichever of `dist/dev` and `dist/build` has a newer `main.js`.\n * If only one exists, that one is used. Throws if neither exists.\n *\n * @param projectRoot - The absolute path to the project root.\n * @returns The absolute path to the chosen dist folder.\n */\nasync function resolveDistPath(projectRoot: string): Promise<string> {\n  const devPath = join(projectRoot, DIST_DEV);\n  const buildPath = join(projectRoot, DIST_BUILD);\n  const devMainJs = join(devPath, MAIN_JS);\n  const buildMainJs = join(buildPath, MAIN_JS);\n  const devStat = existsSync(devMainJs) ? await stat(devMainJs) : null;\n  const buildStat = existsSync(buildMainJs) ? await stat(buildMainJs) : null;\n\n  if (devStat && buildStat) {\n    return devStat.mtime > buildStat.mtime ? devPath : buildPath;\n  }\n\n  if (devStat) {\n    return devPath;\n  }\n\n  if (buildStat) {\n    return buildPath;\n  }\n\n  throw new Error('No build found. Run `npm run build` or `npm run dev` first.');\n}\n\n/**\n * Refuses a mobile run for a desktop-only plugin, before anything costly has happened.\n *\n * A no-op unless a plugin is being installed onto a mobile transport. Otherwise reads `manifest.json`\n * out of the newer dist folder \u2014 no device, no lock, no sweep. When there is no readable build the check\n * simply does not fire: a missing or malformed build is a different problem, and {@link resolveDistPath}\n * downstream already reports it in its own words.\n *\n * @param params - The transport label, project root, transport options and whether a plugin is installed.\n * @throws {DesktopOnlyPluginSkipError} When the manifest says `isDesktopOnly: true`.\n */\nasync function skipIfDesktopOnly(params: SkipIfDesktopOnlyParams): Promise<void> {\n  const { label, projectRoot, shouldInstallPlugin, transportOptions } = params;\n\n  if (!shouldInstallPlugin || !checkIsMobileTransport(transportOptions)) {\n    return;\n  }\n\n  let manifestJson: PluginManifest;\n  try {\n    const distPath = await resolveDistPath(projectRoot);\n    manifestJson = JSON.parse(await readFile(join(distPath, 'manifest.json'), 'utf-8')) as PluginManifest;\n  } catch {\n    return;\n  }\n\n  if (!manifestJson.isDesktopOnly) {\n    return;\n  }\n\n  log(\n    `[integration-setup:${label}] SKIPPED: \"${manifestJson.id}\" is desktop-only (isDesktopOnly: true), `\n      + 'so it has no mobile integration tests to run. No emulator was booted and no Appium server was started.'\n  );\n  throw new DesktopOnlyPluginSkipError(manifestJson.id);\n}\n\n/**\n * Removes the host-side temp directories earlier runs leaked.\n *\n * Runs at both ends of a run: at setup it happens **before** the transport is\n * created, so it does not depend on a healthy Obsidian/WebView \u2014 which is\n * exactly what a failed run no longer has, and why a failed run cannot clean up\n * after itself. Age-gated (see `leftoverMaxAgeInMilliseconds`) because desktop\n * runs are not serialized and every project on the machine shares one temp\n * directory. Best-effort: a sweep never fails the run it is cleaning up for.\n *\n * @param params - The sweep parameters.\n */\nasync function sweepLeftovers(params: SweepLeftoversParams): Promise<void> {\n  const { label, phase, transportOptions } = params;\n  if (!willSweepLeftovers(transportOptions)) {\n    return;\n  }\n\n  try {\n    const result = await sweepHostLeftovers({\n      excludedNames: params.excludedNames,\n      maxAgeInMilliseconds: resolveLeftoverMaxAgeInMilliseconds(transportOptions)\n    });\n    if (result.removedCount > 0 || result.failedCount > 0) {\n      log(\n        `[integration-${phase}:${label}] Swept ${String(result.removedCount)} leftover temp director(ies) `\n          + `from earlier runs (${String(result.failedCount)} still in use).`\n      );\n    }\n  } catch (error: unknown) {\n    log(`[integration-${phase}:${label}] Leftover sweep error (non-fatal): ${errorToString(error)}`);\n  }\n}\n\n/**\n * Performs the async teardown work (vault disposal + transport disposal).\n *\n * @param result - The setup result to tear down.\n */\nasync function teardownAsync(result: CoreSetupResult): Promise<void> {\n  try {\n    await result.temporaryVault.dispose(result.transport);\n  } catch (error: unknown) {\n    log(`[integration-teardown:${result.transportLabel}] Vault cleanup error (non-fatal): ${errorToString(error)}`);\n  }\n\n  try {\n    await result.transport.dispose?.();\n  } catch (error: unknown) {\n    log(`[integration-teardown:${result.transportLabel}] Transport cleanup error (non-fatal): ${errorToString(error)}`);\n  }\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/index.d.mts

@@ -5,12 +5,16 @@
  */
 export type { RunAdbParams } from './adb.mjs';
 export { runAdbBinary, runAdbText, runAdbTextWithoutDevice } from './adb.mjs';
+export type { AppConfigParams, AppConfigRestore, SetAppConfigParams, WithAppConfigParams } from './app-config.mjs';
+export { getAppConfig, restoreAppConfig, setAppConfig, withAppConfig } from './app-config.mjs';
 export type { AsarFallback, AsarFallbackTier, ResolveAsarFallbackParams } from './asar-fallback-detection.mjs';
 export { resolveAsarFallback } from './asar-fallback-detection.mjs';
 export type { CaptureObsidianScreenshotOptions } from './capture-obsidian-screenshot.mjs';
 export { captureObsidianScreenshot } from './capture-obsidian-screenshot.mjs';
 export type { CaptureScreenshotParams, PngDimensions } from './capture-screenshot.mjs';
 export { buildDeviceMetricsOverride, decodeBase64Png, isPng, readPngDimensions } from './capture-screenshot.mjs';
+export type { CdpCommandTimeoutErrorConstructorParams } from './cdp-command-timeout-error.mjs';
+export { CdpCommandTimeoutError } from './cdp-command-timeout-error.mjs';
 export type { ConfigDirectoryFallbackErrorConstructorParams } from './config-directory-fallback-error.mjs';
 export { ConfigDirectoryFallbackError } from './config-directory-fallback-error.mjs';
 export { assertValidConfigDirectory, DEFAULT_CONFIG_DIRECTORY } from './config-directory.mjs';
@@ -39,6 +43,9 @@ export type { ElectronCompatibility, ElectronCompatibilityTier, ResolveElectronC
 export { resolveElectronCompatibility } from './electron-compatibility.mjs';
 export type { EmulatorDeviceCandidate, SelectEmulatorDeviceIdParams } from './emulator-device-id.mjs';
 export { selectEmulatorDeviceId } from './emulator-device-id.mjs';
+export type { EvalCapExceededErrorConstructorParams } from './eval-cap-exceeded-error.mjs';
+export { EvalCapExceededError, isScriptTimeoutError } from './eval-cap-exceeded-error.mjs';
+export { DEFAULT_EVAL_CAP_IN_MILLISECONDS } from './eval-cap.mjs';
 export type { ClickElementParams, ClickMouseParams, CommonArguments, CreateNoteParams, EvalInObsidianParams, GenericObject, HoverElementParams, Lib, MouseButton, MoveMouseParams, OpenSettingsTabParams, PressKeyParams, TypeIntoEditorParams, UnhoverElementParams, WaitUntilParams } from './eval-in-obsidian.mjs';
 export { evalInObsidian } from './eval-in-obsidian.mjs';
 export type { ComputeFitToCanvasParams, FitScreenshotToCanvasOptions, FitToCanvasGeometry } from './fit-screenshot.mjs';

package/dist/lib/esm/index.mjs

@@ -3,6 +3,12 @@ import {
   runAdbText,
   runAdbTextWithoutDevice
 } from "./adb.mjs";
+import {
+  getAppConfig,
+  restoreAppConfig,
+  setAppConfig,
+  withAppConfig
+} from "./app-config.mjs";
 import { resolveAsarFallback } from "./asar-fallback-detection.mjs";
 import { captureObsidianScreenshot } from "./capture-obsidian-screenshot.mjs";
 import {
@@ -11,6 +17,7 @@ import {
   isPng,
   readPngDimensions
 } from "./capture-screenshot.mjs";
+import { CdpCommandTimeoutError } from "./cdp-command-timeout-error.mjs";
 import { ConfigDirectoryFallbackError } from "./config-directory-fallback-error.mjs";
 import {
   assertValidConfigDirectory,
@@ -51,6 +58,11 @@ import {
 } from "./device-settings.mjs";
 import { resolveElectronCompatibility } from "./electron-compatibility.mjs";
 import { selectEmulatorDeviceId } from "./emulator-device-id.mjs";
+import {
+  EvalCapExceededError,
+  isScriptTimeoutError
+} from "./eval-cap-exceeded-error.mjs";
+import { DEFAULT_EVAL_CAP_IN_MILLISECONDS } from "./eval-cap.mjs";
 import { evalInObsidian } from "./eval-in-obsidian.mjs";
 import {
   computeFitToCanvas,
@@ -102,9 +114,11 @@ import { DEFAULT_OBSIDIAN_VERSION_SPECS } from "./version-matrix.mjs";
 export {
   AppiumTransport,
   CATALYST_LATEST,
+  CdpCommandTimeoutError,
   ConfigDirectoryFallbackError,
   ContextId,
   DEFAULT_CONFIG_DIRECTORY,
+  DEFAULT_EVAL_CAP_IN_MILLISECONDS,
   DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,
   DEFAULT_OBSIDIAN_VERSION_SPECS,
   DesktopCdpTransport,
@@ -112,6 +126,7 @@ export {
   DeviceSettingNamespace,
   DeviceSettingRestoreKind,
   DeviceSettingVerb,
+  EvalCapExceededError,
   IncompatibleInstallerVersionError,
   IntegrationSetupFailedError,
   OwnedInstanceExitedError,
@@ -140,8 +155,10 @@ export {
   escapeSvgText,
   evalInObsidian,
   fitScreenshotToCanvas,
+  getAppConfig,
   getVersionMetadata,
   isPng,
+  isScriptTimeoutError,
   labelScreenshot,
   openObsidianSettingsTab,
   parseInputMethodState,
@@ -159,17 +176,20 @@ export {
   resolveInstallerCompatibility,
   resolveMissingInjectedPlugins,
   resolveSoftKeyboardTapPoints,
+  restoreAppConfig,
   runAdbBinary,
   runAdbText,
   runAdbTextWithoutDevice,
   runObsidianVersionMatrix,
   selectEmulatorDeviceId,
+  setAppConfig,
   setSetupErrorResolver,
   setTransportOptionsResolver,
   setVaultPathResolver,
   tapDevice,
   unregisterVault,
+  withAppConfig,
   withSoftKeyboardEnabled,
   writeDeviceSetting
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/index.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains the entry point for the integration testing module.\n */\n\nexport type { RunAdbParams } from './adb.mjs';\nexport {\n  runAdbBinary,\n  runAdbText,\n  runAdbTextWithoutDevice\n} from './adb.mjs';\nexport type {\n  AsarFallback,\n  AsarFallbackTier,\n  ResolveAsarFallbackParams\n} from './asar-fallback-detection.mjs';\nexport { resolveAsarFallback } from './asar-fallback-detection.mjs';\nexport type { CaptureObsidianScreenshotOptions } from './capture-obsidian-screenshot.mjs';\nexport { captureObsidianScreenshot } from './capture-obsidian-screenshot.mjs';\nexport type {\n  CaptureScreenshotParams,\n  PngDimensions\n} from './capture-screenshot.mjs';\nexport {\n  buildDeviceMetricsOverride,\n  decodeBase64Png,\n  isPng,\n  readPngDimensions\n} from './capture-screenshot.mjs';\nexport type { ConfigDirectoryFallbackErrorConstructorParams } from './config-directory-fallback-error.mjs';\nexport { ConfigDirectoryFallbackError } from './config-directory-fallback-error.mjs';\nexport {\n  assertValidConfigDirectory,\n  DEFAULT_CONFIG_DIRECTORY\n} from './config-directory.mjs';\nexport type {\n  CdpConnection,\n  ConnectToCdpOptions\n} from './connect-to-cdp.mjs';\nexport { connectToCdp } from './connect-to-cdp.mjs';\nexport type {\n  ContextArguments,\n  ContextOf\n} from './context-id.mjs';\nexport { ContextId } from './context-id.mjs';\nexport type {\n  SetupErrorResolver,\n  TransportOptionsResolver,\n  VaultPathResolver\n} from './context-provider.mjs';\nexport {\n  setSetupErrorResolver,\n  setTransportOptionsResolver,\n  setVaultPathResolver\n} from './context-provider.mjs';\nexport type {\n  BootstrapDemoVaultPluginsParams,\n  BootstrapDemoVaultPluginsResult,\n  InstalledPluginInfo\n} from './demo-vault-bootstrap.mjs';\nexport {\n  bootstrapDemoVaultPlugins,\n  buildDemoVaultPopulateAsync\n} from './demo-vault-bootstrap.mjs';\nexport type {\n  BuildDemoVaultPopulateParams,\n  InjectPluginParams,\n  ResolveMissingInjectedPluginsParams\n} from './demo-vault-populate.mjs';\nexport {\n  buildDemoVaultPopulate,\n  resolveMissingInjectedPlugins\n} from './demo-vault-populate.mjs';\nexport type { ReadDemoVaultTreeParams } from './demo-vault-tree.mjs';\nexport { readDemoVaultTree } from './demo-vault-tree.mjs';\nexport { DesktopOnlyPluginSkipError } from './desktop-only-plugin-skip-error.mjs';\nexport type { CaptureDeviceScreenshotParams } from './device-screenshot.mjs';\nexport { captureDeviceScreenshot } from './device-screenshot.mjs';\nexport type {\n  DeviceSettingRestore,\n  DeviceSettingRestoreDelete,\n  DeviceSettingRestoreWrite\n} from './device-setting-restore.mjs';\nexport {\n  DeviceSettingRestoreKind,\n  resolveDeviceSettingRestore\n} from './device-setting-restore.mjs';\nexport type { BuildDeviceSettingsCommandArgumentsParams } from './device-settings-command.mjs';\nexport {\n  buildDeviceSettingsCommandArguments,\n  DeviceSettingNamespace,\n  DeviceSettingVerb\n} from './device-settings-command.mjs';\nexport type {\n  DeviceSettingParams,\n  WithSoftKeyboardEnabledParams,\n  WriteDeviceSettingParams\n} from './device-settings.mjs';\nexport {\n  deleteDeviceSetting,\n  readDeviceSetting,\n  withSoftKeyboardEnabled,\n  writeDeviceSetting\n} from './device-settings.mjs';\nexport type {\n  ElectronCompatibility,\n  ElectronCompatibilityTier,\n  ResolveElectronCompatibilityParams\n} from './electron-compatibility.mjs';\nexport { resolveElectronCompatibility } from './electron-compatibility.mjs';\nexport type {\n  EmulatorDeviceCandidate,\n  SelectEmulatorDeviceIdParams\n} from './emulator-device-id.mjs';\nexport { selectEmulatorDeviceId } from './emulator-device-id.mjs';\nexport type {\n  ClickElementParams,\n  ClickMouseParams,\n  CommonArguments,\n  CreateNoteParams,\n  EvalInObsidianParams,\n  GenericObject,\n  HoverElementParams,\n  Lib,\n  MouseButton,\n  MoveMouseParams,\n  OpenSettingsTabParams,\n  PressKeyParams,\n  TypeIntoEditorParams,\n  UnhoverElementParams,\n  WaitUntilParams\n} from './eval-in-obsidian.mjs';\nexport { evalInObsidian } from './eval-in-obsidian.mjs';\nexport type {\n  ComputeFitToCanvasParams,\n  FitScreenshotToCanvasOptions,\n  FitToCanvasGeometry\n} from './fit-screenshot.mjs';\nexport {\n  computeFitToCanvas,\n  fitScreenshotToCanvas\n} from './fit-screenshot.mjs';\nexport type { IncompatibleInstallerVersionErrorConstructorParams } from './incompatible-installer-version-error.mjs';\nexport { IncompatibleInstallerVersionError } from './incompatible-installer-version-error.mjs';\nexport type {\n  InstallerCompatibility,\n  InstallerCompatibilityTier,\n  ResolveInstallerCompatibilityParams\n} from './installer-compatibility.mjs';\nexport { resolveInstallerCompatibility } from './installer-compatibility.mjs';\nexport type { IntegrationSetupFailedErrorConstructorParams } from './integration-setup-failed-error.mjs';\nexport { IntegrationSetupFailedError } from './integration-setup-failed-error.mjs';\nexport type {\n  ComputeLabelBandParams,\n  LabelBandGeometry,\n  LabelScreenshotOptions\n} from './label-screenshot.mjs';\nexport {\n  buildLabelSvg,\n  computeLabelBand,\n  escapeSvgText,\n  labelScreenshot\n} from './label-screenshot.mjs';\nexport type { LibResolver } from './lib-registry.mjs';\nexport { registerLibResolver } from './lib-registry.mjs';\nexport type {\n  ObsidianRuntimeVersions,\n  ObsidianVersionChangelogUrls,\n  ObsidianVersionDownloads,\n  ObsidianVersionMetadata\n} from './obsidian-metadata.mjs';\nexport { getVersionMetadata } from './obsidian-metadata.mjs';\nexport {\n  CATALYST_LATEST,\n  PUBLIC_LATEST\n} from './obsidian-version.mjs';\nexport type { OpenObsidianSettingsTabOptions } from './open-obsidian-settings-tab.mjs';\nexport { openObsidianSettingsTab } from './open-obsidian-settings-tab.mjs';\nexport type { OwnedInstanceExitedErrorConstructorParams } from './owned-instance-exited-error.mjs';\nexport { OwnedInstanceExitedError } from './owned-instance-exited-error.mjs';\nexport type { PollInObsidianParams } from './poll-in-obsidian.mjs';\nexport { pollInObsidian } from './poll-in-obsidian.mjs';\nexport { RendererFailedToInitializeError } from './renderer-failed-to-initialize-error.mjs';\nexport type { ResolveEmulatorDeviceIdParams } from './resolve-emulator-device-id.mjs';\nexport { resolveEmulatorDeviceId } from './resolve-emulator-device-id.mjs';\nexport type { RunObsidianVersionMatrixParams } from './run-version-matrix.mjs';\nexport { runObsidianVersionMatrix } from './run-version-matrix.mjs';\nexport type { SilentAsarFallbackErrorConstructorParams } from './silent-asar-fallback-error.mjs';\nexport { SilentAsarFallbackError } from './silent-asar-fallback-error.mjs';\nexport type {\n  BuildSoftKeyboardDiagnosticMessageParams,\n  CheckIsSoftKeyboardUpParams,\n  ElementRect,\n  ResolveSoftKeyboardTapPointsParams,\n  SoftKeyboardTapPoint,\n  SoftKeyboardViewportSnapshot\n} from './soft-keyboard-geometry.mjs';\nexport {\n  buildSoftKeyboardDiagnosticMessage,\n  checkIsSoftKeyboardUp,\n  DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,\n  parseInputMethodState,\n  resolveSoftKeyboardTapPoints\n} from './soft-keyboard-geometry.mjs';\nexport type {\n  RaiseSoftKeyboardParams,\n  TapDeviceParams\n} from './soft-keyboard.mjs';\nexport {\n  raiseSoftKeyboard,\n  tapDevice\n} from './soft-keyboard.mjs';\nexport type {\n  PopulateFileContent,\n  PopulateFilesParams,\n  TemporaryVaultOptions\n} from './temporary-vault.mjs';\nexport { TemporaryVault } from './temporary-vault.mjs';\nexport type {\n  AppiumSessionInfo,\n  AppiumTransportConfig\n} from './transport-appium.mjs';\nexport { AppiumTransport } from './transport-appium.mjs';\nexport type {\n  DesktopCdpTransportConfig,\n  OwnedInstanceAsar,\n  OwnedInstanceConfig,\n  OwnedInstanceEndpoint\n} from './transport-desktop-cdp.mjs';\nexport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nexport { createTransportFromOptions } from './transport-factory.mjs';\nexport type {\n  ObsidianAndroidAppiumTransportOptions,\n  ObsidianCdpTransportOptions,\n  ObsidianTransportOptions\n} from './transport-options.mjs';\nexport { checkIsMobileTransport } from './transport-options.mjs';\nexport type {\n  ConsoleCaptureHandle,\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.mjs';\nexport {\n  registerVault,\n  unregisterVault\n} from './vault-registry.mjs';\nexport type { ObsidianVersionMatrixEntry } from './version-matrix.mjs';\nexport { DEFAULT_OBSIDIAN_VERSION_SPECS } from './version-matrix.mjs';\n"],
  "mappings": "AAOA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAMP,SAAS,2BAA2B;AAEpC,SAAS,iCAAiC;AAK1C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,oCAAoC;AAC7C;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAKP,SAAS,oBAAoB;AAK7B,SAAS,iBAAiB;AAM1B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAMP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAMP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,yBAAyB;AAClC,SAAS,kCAAkC;AAE3C,SAAS,+BAA+B;AAMxC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAMP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAMP,SAAS,oCAAoC;AAK7C,SAAS,8BAA8B;AAkBvC,SAAS,sBAAsB;AAM/B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,yCAAyC;AAMlD,SAAS,qCAAqC;AAE9C,SAAS,mCAAmC;AAM5C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,2BAA2B;AAOpC,SAAS,0BAA0B;AACnC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,+BAA+B;AAExC,SAAS,gCAAgC;AAEzC,SAAS,sBAAsB;AAC/B,SAAS,uCAAuC;AAEhD,SAAS,+BAA+B;AAExC,SAAS,gCAAgC;AAEzC,SAAS,+BAA+B;AASxC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAKP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAMP,SAAS,sBAAsB;AAK/B,SAAS,uBAAuB;AAOhC,SAAS,2BAA2B;AACpC,SAAS,kCAAkC;AAM3C,SAAS,8BAA8B;AAMvC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,sCAAsC;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/index.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains the entry point for the integration testing module.\n */\n\nexport type { RunAdbParams } from './adb.mjs';\nexport {\n  runAdbBinary,\n  runAdbText,\n  runAdbTextWithoutDevice\n} from './adb.mjs';\nexport type {\n  AppConfigParams,\n  AppConfigRestore,\n  SetAppConfigParams,\n  WithAppConfigParams\n} from './app-config.mjs';\nexport {\n  getAppConfig,\n  restoreAppConfig,\n  setAppConfig,\n  withAppConfig\n} from './app-config.mjs';\nexport type {\n  AsarFallback,\n  AsarFallbackTier,\n  ResolveAsarFallbackParams\n} from './asar-fallback-detection.mjs';\nexport { resolveAsarFallback } from './asar-fallback-detection.mjs';\nexport type { CaptureObsidianScreenshotOptions } from './capture-obsidian-screenshot.mjs';\nexport { captureObsidianScreenshot } from './capture-obsidian-screenshot.mjs';\nexport type {\n  CaptureScreenshotParams,\n  PngDimensions\n} from './capture-screenshot.mjs';\nexport {\n  buildDeviceMetricsOverride,\n  decodeBase64Png,\n  isPng,\n  readPngDimensions\n} from './capture-screenshot.mjs';\nexport type { CdpCommandTimeoutErrorConstructorParams } from './cdp-command-timeout-error.mjs';\nexport { CdpCommandTimeoutError } from './cdp-command-timeout-error.mjs';\nexport type { ConfigDirectoryFallbackErrorConstructorParams } from './config-directory-fallback-error.mjs';\nexport { ConfigDirectoryFallbackError } from './config-directory-fallback-error.mjs';\nexport {\n  assertValidConfigDirectory,\n  DEFAULT_CONFIG_DIRECTORY\n} from './config-directory.mjs';\nexport type {\n  CdpConnection,\n  ConnectToCdpOptions\n} from './connect-to-cdp.mjs';\nexport { connectToCdp } from './connect-to-cdp.mjs';\nexport type {\n  ContextArguments,\n  ContextOf\n} from './context-id.mjs';\nexport { ContextId } from './context-id.mjs';\nexport type {\n  SetupErrorResolver,\n  TransportOptionsResolver,\n  VaultPathResolver\n} from './context-provider.mjs';\nexport {\n  setSetupErrorResolver,\n  setTransportOptionsResolver,\n  setVaultPathResolver\n} from './context-provider.mjs';\nexport type {\n  BootstrapDemoVaultPluginsParams,\n  BootstrapDemoVaultPluginsResult,\n  InstalledPluginInfo\n} from './demo-vault-bootstrap.mjs';\nexport {\n  bootstrapDemoVaultPlugins,\n  buildDemoVaultPopulateAsync\n} from './demo-vault-bootstrap.mjs';\nexport type {\n  BuildDemoVaultPopulateParams,\n  InjectPluginParams,\n  ResolveMissingInjectedPluginsParams\n} from './demo-vault-populate.mjs';\nexport {\n  buildDemoVaultPopulate,\n  resolveMissingInjectedPlugins\n} from './demo-vault-populate.mjs';\nexport type { ReadDemoVaultTreeParams } from './demo-vault-tree.mjs';\nexport { readDemoVaultTree } from './demo-vault-tree.mjs';\nexport { DesktopOnlyPluginSkipError } from './desktop-only-plugin-skip-error.mjs';\nexport type { CaptureDeviceScreenshotParams } from './device-screenshot.mjs';\nexport { captureDeviceScreenshot } from './device-screenshot.mjs';\nexport type {\n  DeviceSettingRestore,\n  DeviceSettingRestoreDelete,\n  DeviceSettingRestoreWrite\n} from './device-setting-restore.mjs';\nexport {\n  DeviceSettingRestoreKind,\n  resolveDeviceSettingRestore\n} from './device-setting-restore.mjs';\nexport type { BuildDeviceSettingsCommandArgumentsParams } from './device-settings-command.mjs';\nexport {\n  buildDeviceSettingsCommandArguments,\n  DeviceSettingNamespace,\n  DeviceSettingVerb\n} from './device-settings-command.mjs';\nexport type {\n  DeviceSettingParams,\n  WithSoftKeyboardEnabledParams,\n  WriteDeviceSettingParams\n} from './device-settings.mjs';\nexport {\n  deleteDeviceSetting,\n  readDeviceSetting,\n  withSoftKeyboardEnabled,\n  writeDeviceSetting\n} from './device-settings.mjs';\nexport type {\n  ElectronCompatibility,\n  ElectronCompatibilityTier,\n  ResolveElectronCompatibilityParams\n} from './electron-compatibility.mjs';\nexport { resolveElectronCompatibility } from './electron-compatibility.mjs';\nexport type {\n  EmulatorDeviceCandidate,\n  SelectEmulatorDeviceIdParams\n} from './emulator-device-id.mjs';\nexport { selectEmulatorDeviceId } from './emulator-device-id.mjs';\nexport type { EvalCapExceededErrorConstructorParams } from './eval-cap-exceeded-error.mjs';\nexport {\n  EvalCapExceededError,\n  isScriptTimeoutError\n} from './eval-cap-exceeded-error.mjs';\nexport { DEFAULT_EVAL_CAP_IN_MILLISECONDS } from './eval-cap.mjs';\nexport type {\n  ClickElementParams,\n  ClickMouseParams,\n  CommonArguments,\n  CreateNoteParams,\n  EvalInObsidianParams,\n  GenericObject,\n  HoverElementParams,\n  Lib,\n  MouseButton,\n  MoveMouseParams,\n  OpenSettingsTabParams,\n  PressKeyParams,\n  TypeIntoEditorParams,\n  UnhoverElementParams,\n  WaitUntilParams\n} from './eval-in-obsidian.mjs';\nexport { evalInObsidian } from './eval-in-obsidian.mjs';\nexport type {\n  ComputeFitToCanvasParams,\n  FitScreenshotToCanvasOptions,\n  FitToCanvasGeometry\n} from './fit-screenshot.mjs';\nexport {\n  computeFitToCanvas,\n  fitScreenshotToCanvas\n} from './fit-screenshot.mjs';\nexport type { IncompatibleInstallerVersionErrorConstructorParams } from './incompatible-installer-version-error.mjs';\nexport { IncompatibleInstallerVersionError } from './incompatible-installer-version-error.mjs';\nexport type {\n  InstallerCompatibility,\n  InstallerCompatibilityTier,\n  ResolveInstallerCompatibilityParams\n} from './installer-compatibility.mjs';\nexport { resolveInstallerCompatibility } from './installer-compatibility.mjs';\nexport type { IntegrationSetupFailedErrorConstructorParams } from './integration-setup-failed-error.mjs';\nexport { IntegrationSetupFailedError } from './integration-setup-failed-error.mjs';\nexport type {\n  ComputeLabelBandParams,\n  LabelBandGeometry,\n  LabelScreenshotOptions\n} from './label-screenshot.mjs';\nexport {\n  buildLabelSvg,\n  computeLabelBand,\n  escapeSvgText,\n  labelScreenshot\n} from './label-screenshot.mjs';\nexport type { LibResolver } from './lib-registry.mjs';\nexport { registerLibResolver } from './lib-registry.mjs';\nexport type {\n  ObsidianRuntimeVersions,\n  ObsidianVersionChangelogUrls,\n  ObsidianVersionDownloads,\n  ObsidianVersionMetadata\n} from './obsidian-metadata.mjs';\nexport { getVersionMetadata } from './obsidian-metadata.mjs';\nexport {\n  CATALYST_LATEST,\n  PUBLIC_LATEST\n} from './obsidian-version.mjs';\nexport type { OpenObsidianSettingsTabOptions } from './open-obsidian-settings-tab.mjs';\nexport { openObsidianSettingsTab } from './open-obsidian-settings-tab.mjs';\nexport type { OwnedInstanceExitedErrorConstructorParams } from './owned-instance-exited-error.mjs';\nexport { OwnedInstanceExitedError } from './owned-instance-exited-error.mjs';\nexport type { PollInObsidianParams } from './poll-in-obsidian.mjs';\nexport { pollInObsidian } from './poll-in-obsidian.mjs';\nexport { RendererFailedToInitializeError } from './renderer-failed-to-initialize-error.mjs';\nexport type { ResolveEmulatorDeviceIdParams } from './resolve-emulator-device-id.mjs';\nexport { resolveEmulatorDeviceId } from './resolve-emulator-device-id.mjs';\nexport type { RunObsidianVersionMatrixParams } from './run-version-matrix.mjs';\nexport { runObsidianVersionMatrix } from './run-version-matrix.mjs';\nexport type { SilentAsarFallbackErrorConstructorParams } from './silent-asar-fallback-error.mjs';\nexport { SilentAsarFallbackError } from './silent-asar-fallback-error.mjs';\nexport type {\n  BuildSoftKeyboardDiagnosticMessageParams,\n  CheckIsSoftKeyboardUpParams,\n  ElementRect,\n  ResolveSoftKeyboardTapPointsParams,\n  SoftKeyboardTapPoint,\n  SoftKeyboardViewportSnapshot\n} from './soft-keyboard-geometry.mjs';\nexport {\n  buildSoftKeyboardDiagnosticMessage,\n  checkIsSoftKeyboardUp,\n  DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,\n  parseInputMethodState,\n  resolveSoftKeyboardTapPoints\n} from './soft-keyboard-geometry.mjs';\nexport type {\n  RaiseSoftKeyboardParams,\n  TapDeviceParams\n} from './soft-keyboard.mjs';\nexport {\n  raiseSoftKeyboard,\n  tapDevice\n} from './soft-keyboard.mjs';\nexport type {\n  PopulateFileContent,\n  PopulateFilesParams,\n  TemporaryVaultOptions\n} from './temporary-vault.mjs';\nexport { TemporaryVault } from './temporary-vault.mjs';\nexport type {\n  AppiumSessionInfo,\n  AppiumTransportConfig\n} from './transport-appium.mjs';\nexport { AppiumTransport } from './transport-appium.mjs';\nexport type {\n  DesktopCdpTransportConfig,\n  OwnedInstanceAsar,\n  OwnedInstanceConfig,\n  OwnedInstanceEndpoint\n} from './transport-desktop-cdp.mjs';\nexport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nexport { createTransportFromOptions } from './transport-factory.mjs';\nexport type {\n  ObsidianAndroidAppiumTransportOptions,\n  ObsidianCdpTransportOptions,\n  ObsidianTransportOptions\n} from './transport-options.mjs';\nexport { checkIsMobileTransport } from './transport-options.mjs';\nexport type {\n  ConsoleCaptureHandle,\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.mjs';\nexport {\n  registerVault,\n  unregisterVault\n} from './vault-registry.mjs';\nexport type { ObsidianVersionMatrixEntry } from './version-matrix.mjs';\nexport { DEFAULT_OBSIDIAN_VERSION_SPECS } from './version-matrix.mjs';\n"],
  "mappings": "AAOA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAOP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAMP,SAAS,2BAA2B;AAEpC,SAAS,iCAAiC;AAK1C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,8BAA8B;AAEvC,SAAS,oCAAoC;AAC7C;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAKP,SAAS,oBAAoB;AAK7B,SAAS,iBAAiB;AAM1B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAMP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAMP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,yBAAyB;AAClC,SAAS,kCAAkC;AAE3C,SAAS,+BAA+B;AAMxC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAMP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAMP,SAAS,oCAAoC;AAK7C,SAAS,8BAA8B;AAEvC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,wCAAwC;AAkBjD,SAAS,sBAAsB;AAM/B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,yCAAyC;AAMlD,SAAS,qCAAqC;AAE9C,SAAS,mCAAmC;AAM5C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,2BAA2B;AAOpC,SAAS,0BAA0B;AACnC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,+BAA+B;AAExC,SAAS,gCAAgC;AAEzC,SAAS,sBAAsB;AAC/B,SAAS,uCAAuC;AAEhD,SAAS,+BAA+B;AAExC,SAAS,gCAAgC;AAEzC,SAAS,+BAA+B;AASxC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAKP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAMP,SAAS,sBAAsB;AAK/B,SAAS,uBAAuB;AAOhC,SAAS,2BAA2B;AACpC,SAAS,kCAAkC;AAM3C,SAAS,8BAA8B;AAMvC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,sCAAsC;",
  "names": []
}


package/dist/lib/esm/library.mjs

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