obsidian-integration-testing 11.0.0 → 12.1.0

package/dist/lib/esm/index.mjs

@@ -6,13 +6,26 @@ import {
   isPng,
   readPngDimensions
 } from "./capture-screenshot.mjs";
+import { ConfigDirectoryFallbackError } from "./config-directory-fallback-error.mjs";
+import {
+  assertValidConfigDirectory,
+  DEFAULT_CONFIG_DIRECTORY
+} from "./config-directory.mjs";
 import { connectToCdp } from "./connect-to-cdp.mjs";
 import { ContextId } from "./context-id.mjs";
 import {
+  setSetupErrorResolver,
   setTransportOptionsResolver,
   setVaultPathResolver
 } from "./context-provider.mjs";
-import { buildDemoVaultPopulate } from "./demo-vault-populate.mjs";
+import {
+  bootstrapDemoVaultPlugins,
+  buildDemoVaultPopulateAsync
+} from "./demo-vault-bootstrap.mjs";
+import {
+  buildDemoVaultPopulate,
+  resolveMissingInjectedPlugins
+} from "./demo-vault-populate.mjs";
 import { readDemoVaultTree } from "./demo-vault-tree.mjs";
 import { DesktopOnlyPluginSkipError } from "./desktop-only-plugin-skip-error.mjs";
 import { resolveElectronCompatibility } from "./electron-compatibility.mjs";
@@ -23,6 +36,7 @@ import {
 } from "./fit-screenshot.mjs";
 import { IncompatibleInstallerVersionError } from "./incompatible-installer-version-error.mjs";
 import { resolveInstallerCompatibility } from "./installer-compatibility.mjs";
+import { IntegrationSetupFailedError } from "./integration-setup-failed-error.mjs";
 import {
   buildLabelSvg,
   computeLabelBand,
@@ -36,6 +50,7 @@ import {
   PUBLIC_LATEST
 } from "./obsidian-version.mjs";
 import { openObsidianSettingsTab } from "./open-obsidian-settings-tab.mjs";
+import { OwnedInstanceExitedError } from "./owned-instance-exited-error.mjs";
 import { pollInObsidian } from "./poll-in-obsidian.mjs";
 import { RendererFailedToInitializeError } from "./renderer-failed-to-initialize-error.mjs";
 import { runObsidianVersionMatrix } from "./run-version-matrix.mjs";
@@ -53,16 +68,23 @@ import { DEFAULT_OBSIDIAN_VERSION_SPECS } from "./version-matrix.mjs";
 export {
   AppiumTransport,
   CATALYST_LATEST,
+  ConfigDirectoryFallbackError,
   ContextId,
+  DEFAULT_CONFIG_DIRECTORY,
   DEFAULT_OBSIDIAN_VERSION_SPECS,
   DesktopCdpTransport,
   DesktopOnlyPluginSkipError,
   IncompatibleInstallerVersionError,
+  IntegrationSetupFailedError,
+  OwnedInstanceExitedError,
   PUBLIC_LATEST,
   RendererFailedToInitializeError,
   SilentAsarFallbackError,
   TemporaryVault,
+  assertValidConfigDirectory,
+  bootstrapDemoVaultPlugins,
   buildDemoVaultPopulate,
+  buildDemoVaultPopulateAsync,
   buildDeviceMetricsOverride,
   buildLabelSvg,
   captureObsidianScreenshot,
@@ -87,9 +109,11 @@ export {
   resolveAsarFallback,
   resolveElectronCompatibility,
   resolveInstallerCompatibility,
+  resolveMissingInjectedPlugins,
   runObsidianVersionMatrix,
+  setSetupErrorResolver,
   setTransportOptionsResolver,
   setVaultPathResolver,
   unregisterVault
 };
-//# 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 {\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 {\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  TransportOptionsResolver,\n  VaultPathResolver\n} from './context-provider.mjs';\nexport {\n  setTransportOptionsResolver,\n  setVaultPathResolver\n} from './context-provider.mjs';\nexport type {\n  BuildDemoVaultPopulateParams,\n  InjectPluginParams\n} from './demo-vault-populate.mjs';\nexport { buildDemoVaultPopulate } 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 {\n  ElectronCompatibility,\n  ElectronCompatibilityTier,\n  ResolveElectronCompatibilityParams\n} from './electron-compatibility.mjs';\nexport { resolveElectronCompatibility } from './electron-compatibility.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 {\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 { PollInObsidianParams } from './poll-in-obsidian.mjs';\nexport { pollInObsidian } from './poll-in-obsidian.mjs';\nexport { RendererFailedToInitializeError } from './renderer-failed-to-initialize-error.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  PopulateFileContent,\n  PopulateFilesParams\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": "AAWA,SAAS,2BAA2B;AAEpC,SAAS,iCAAiC;AAK1C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAKP,SAAS,oBAAoB;AAK7B,SAAS,iBAAiB;AAK1B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAKP,SAAS,8BAA8B;AAEvC,SAAS,yBAAyB;AAClC,SAAS,kCAAkC;AAM3C,SAAS,oCAAoC;AAkB7C,SAAS,sBAAsB;AAM/B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,yCAAyC;AAMlD,SAAS,qCAAqC;AAM9C;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,sBAAsB;AAC/B,SAAS,uCAAuC;AAEhD,SAAS,gCAAgC;AAEzC,SAAS,+BAA+B;AAKxC,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 {\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 {\n  ElectronCompatibility,\n  ElectronCompatibilityTier,\n  ResolveElectronCompatibilityParams\n} from './electron-compatibility.mjs';\nexport { resolveElectronCompatibility } from './electron-compatibility.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 { 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  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": "AAWA,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;AAM3C,SAAS,oCAAoC;AAkB7C,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,gCAAgC;AAEzC,SAAS,+BAA+B;AAMxC,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/installer-asset.d.mts

@@ -25,7 +25,7 @@
  * 32-bit / arm64 / all-users sibling assets are deliberately rejected.
  *
  * When the version is present in the baked `metadata.json` catalog (from
- * upstream `obsidian-versions.json`), its exact installer URL is already known;
+ * the `obsidianmd/obsidian-releases` release assets), its exact installer URL is already known;
  * {@link selectInstallerDownloadUrl} picks the platform-correct one and the
  * downloader uses it directly, skipping the release-API lookup and the
  * name-templating fallback entirely.

package/dist/lib/esm/installer-asset.mjs

@@ -65,4 +65,4 @@ export {
   selectInstallerAssetName,
   selectInstallerDownloadUrl
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/installer-asset.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure helpers for resolving which GitHub release asset is the desktop\n * **installer** for a given Obsidian version and platform.\n *\n * Obsidian changed its installer asset naming convention partway through its\n * history, so a version cannot be turned into an asset name by string\n * templating alone:\n *\n * - **Dot** separator on older releases: `Obsidian.<ver>.exe` (verified 0.14.5\n *   through 1.5.12), with a `-universal` infix on the macOS dmg\n *   (`Obsidian-<ver>-universal.dmg`).\n * - **Hyphen** separator on newer releases: `Obsidian-<ver>.exe`,\n *   `Obsidian-<ver>.dmg` (verified 1.6.7 onward; the transition is around 1.6.0).\n *\n * The integration-time downloader (`obsidian-installer.ts`) queries the\n * release's real asset list and picks the platform-correct one with\n * {@link selectInstallerAssetName}; if that network call is unavailable it\n * falls back to trying every {@link buildInstallerAssetNameCandidates} form.\n * Both helpers are pure so the separator/arch matrix stays unit-tested (the\n * downloader itself needs the network and is excluded from unit tests).\n *\n * Only the x64 installer is resolved \u2014 the extraction path is x64-only \u2014 so the\n * 32-bit / arm64 / all-users sibling assets are deliberately rejected.\n *\n * When the version is present in the baked `metadata.json` catalog (from\n * upstream `obsidian-versions.json`), its exact installer URL is already known;\n * {@link selectInstallerDownloadUrl} picks the platform-correct one and the\n * downloader uses it directly, skipping the release-API lookup and the\n * name-templating fallback entirely.\n */\n\nimport type { ObsidianVersionDownloads } from './obsidian-metadata.mjs';\n\n/**\n * The platform-specific shape of an Obsidian installer asset name.\n */\ninterface PlatformInstallerAssetShape {\n  /**\n  Leading token of the asset name: `Obsidian` (Windows/macOS) or `obsidian` (Linux).\n   */\n  readonly baseName: string;\n\n  /**\n  File extension without the leading dot, e.g. `exe`, `dmg`, `tar.gz`.\n   */\n  readonly extension: string;\n\n  /**\n   * Infixes permitted between the version and the extension for the primary\n   * (non-arch) asset, e.g. `-universal` on the older macOS dmg. An empty array\n   * means the version is immediately followed by the extension.\n   */\n  readonly optionalInfixes: readonly string[];\n}\n\nconst WINDOWS_ASSET_SHAPE: PlatformInstallerAssetShape = {\n  baseName: 'Obsidian',\n  extension: 'exe',\n  optionalInfixes: []\n};\n\nconst MAC_ASSET_SHAPE: PlatformInstallerAssetShape = {\n  baseName: 'Obsidian',\n  extension: 'dmg',\n  optionalInfixes: ['-universal']\n};\n\nconst LINUX_ASSET_SHAPE: PlatformInstallerAssetShape = {\n  baseName: 'obsidian',\n  extension: 'tar.gz',\n  optionalInfixes: []\n};\n\n/**\nSeparator forms tried, hyphen (newer) first, when falling back to templated names.\n */\nconst ASSET_NAME_SEPARATORS = ['-', '.'] as const;\n\n/**\n * Parameters for {@link buildInstallerAssetNameCandidates}.\n */\nexport interface BuildInstallerAssetNameCandidatesParams {\n  /**\n  The platform to build candidate names for.\n   */\n  readonly platform: NodeJS.Platform;\n\n  /**\n  The concrete `x.y.z` version.\n   */\n  readonly version: string;\n}\n\n/**\n * Parameters for {@link selectInstallerAssetName}.\n */\nexport interface SelectInstallerAssetNameParams {\n  /**\n  The release's asset names (e.g. from the GitHub release API).\n   */\n  readonly assetNames: readonly string[];\n\n  /**\n  The platform whose installer asset to select.\n   */\n  readonly platform: NodeJS.Platform;\n\n  /**\n  The concrete `x.y.z` version.\n   */\n  readonly version: string;\n}\n\n/**\n * Parameters for {@link selectInstallerDownloadUrl}.\n */\nexport interface SelectInstallerDownloadUrlParams {\n  /**\n  The version's baked download URLs, or `undefined` when it is absent from the catalog.\n   */\n  readonly downloads: ObsidianVersionDownloads | undefined;\n\n  /**\n  The platform whose installer URL to select.\n   */\n  readonly platform: NodeJS.Platform;\n}\n\n/**\n * Builds the fallback list of installer asset names to try when the release's\n * real asset list cannot be fetched, covering both separator forms (and, on\n * macOS, the `-universal` infix).\n *\n * @param params - The platform and version.\n * @returns Candidate asset names, hyphen-separated forms first.\n */\nexport function buildInstallerAssetNameCandidates(params: BuildInstallerAssetNameCandidatesParams): string[] {\n  const shape = getPlatformAssetShape(params.platform);\n  const infixes = shape.optionalInfixes.length > 0 ? ['', ...shape.optionalInfixes] : [''];\n  const candidates: string[] = [];\n  for (const separator of ASSET_NAME_SEPARATORS) {\n    for (const infix of infixes) {\n      candidates.push(`${shape.baseName}${separator}${params.version}${infix}.${shape.extension}`);\n    }\n  }\n  return candidates;\n}\n\n/**\n * Selects the platform-correct x64 installer asset name from a release's asset\n * list, tolerating both the dot- and hyphen-separated naming conventions and\n * rejecting the 32-bit / arm64 / all-users sibling assets.\n *\n * @param params - The asset list, platform, and version.\n * @returns The matching asset name, or `undefined` if none matches (e.g. a\n *   catalyst release that ships no installer).\n */\nexport function selectInstallerAssetName(params: SelectInstallerAssetNameParams): string | undefined {\n  const pattern = buildAssetNamePattern(getPlatformAssetShape(params.platform), params.version);\n  return params.assetNames.find((name) => pattern.test(name));\n}\n\n/**\n * Selects the platform-correct x64 installer download URL from a version's\n * baked catalog entry.\n *\n * @param params - The baked download URLs and the platform.\n * @returns The installer URL for the platform, or `undefined` when the version\n *   has no catalog entry or ships no desktop installer for it (e.g. a catalyst\n *   build, or a Linux `.tar.gz` that was never published).\n */\nexport function selectInstallerDownloadUrl(params: SelectInstallerDownloadUrlParams): string | undefined {\n  const { downloads } = params;\n  if (!downloads) {\n    return undefined;\n  }\n\n  if (params.platform === 'win32') {\n    return downloads.exe;\n  }\n\n  if (params.platform === 'darwin') {\n    return downloads.dmg;\n  }\n\n  return downloads.tar;\n}\n\n/**\n * Builds an anchored regular expression matching the primary installer asset\n * for a platform shape and version, across both separator conventions.\n *\n * @param shape - The platform asset shape.\n * @param version - The concrete `x.y.z` version.\n * @returns The matching pattern.\n */\nfunction buildAssetNamePattern(shape: PlatformInstallerAssetShape, version: string): RegExp {\n  const infixGroup = shape.optionalInfixes.length > 0\n    ? `(?:${shape.optionalInfixes.map((infix) => escapeRegExp(infix)).join('|')})?`\n    : '';\n  return new RegExp(\n    String.raw`^${escapeRegExp(shape.baseName)}[.-]${escapeRegExp(version)}${infixGroup}\\.${escapeRegExp(shape.extension)}$`\n  );\n}\n\n/**\n * Escapes a string for literal use inside a regular expression.\n *\n * @param value - The raw string.\n * @returns The escaped string.\n */\nfunction escapeRegExp(value: string): string {\n  return value.replaceAll(/[.*+?^${}()|[\\]\\\\]/g, String.raw`\\$&`);\n}\n\n/**\n * Resolves the installer asset shape for a platform.\n *\n * @param platform - The Node.js platform identifier.\n * @returns The asset shape (Linux `.tar.gz` for any non-Windows/macOS platform).\n */\nfunction getPlatformAssetShape(platform: NodeJS.Platform): PlatformInstallerAssetShape {\n  if (platform === 'win32') {\n    return WINDOWS_ASSET_SHAPE;\n  }\n\n  if (platform === 'darwin') {\n    return MAC_ASSET_SHAPE;\n  }\n\n  return LINUX_ASSET_SHAPE;\n}\n"],
  "mappings": "AAyDA,MAAM,sBAAmD;AAAA,EACvD,UAAU;AAAA,EACV,WAAW;AAAA,EACX,iBAAiB,CAAC;AACpB;AAEA,MAAM,kBAA+C;AAAA,EACnD,UAAU;AAAA,EACV,WAAW;AAAA,EACX,iBAAiB,CAAC,YAAY;AAChC;AAEA,MAAM,oBAAiD;AAAA,EACrD,UAAU;AAAA,EACV,WAAW;AAAA,EACX,iBAAiB,CAAC;AACpB;AAKA,MAAM,wBAAwB,CAAC,KAAK,GAAG;AA4DhC,SAAS,kCAAkC,QAA2D;AAC3G,QAAM,QAAQ,sBAAsB,OAAO,QAAQ;AACnD,QAAM,UAAU,MAAM,gBAAgB,SAAS,IAAI,CAAC,IAAI,GAAG,MAAM,eAAe,IAAI,CAAC,EAAE;AACvF,QAAM,aAAuB,CAAC;AAC9B,aAAW,aAAa,uBAAuB;AAC7C,eAAW,SAAS,SAAS;AAC3B,iBAAW,KAAK,GAAG,MAAM,QAAQ,GAAG,SAAS,GAAG,OAAO,OAAO,GAAG,KAAK,IAAI,MAAM,SAAS,EAAE;AAAA,IAC7F;AAAA,EACF;AACA,SAAO;AACT;AAWO,SAAS,yBAAyB,QAA4D;AACnG,QAAM,UAAU,sBAAsB,sBAAsB,OAAO,QAAQ,GAAG,OAAO,OAAO;AAC5F,SAAO,OAAO,WAAW,KAAK,CAAC,SAAS,QAAQ,KAAK,IAAI,CAAC;AAC5D;AAWO,SAAS,2BAA2B,QAA8D;AACvG,QAAM,EAAE,UAAU,IAAI;AACtB,MAAI,CAAC,WAAW;AACd,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,aAAa,SAAS;AAC/B,WAAO,UAAU;AAAA,EACnB;AAEA,MAAI,OAAO,aAAa,UAAU;AAChC,WAAO,UAAU;AAAA,EACnB;AAEA,SAAO,UAAU;AACnB;AAUA,SAAS,sBAAsB,OAAoC,SAAyB;AAC1F,QAAM,aAAa,MAAM,gBAAgB,SAAS,IAC9C,MAAM,MAAM,gBAAgB,IAAI,CAAC,UAAU,aAAa,KAAK,CAAC,EAAE,KAAK,GAAG,CAAC,OACzE;AACJ,SAAO,IAAI;AAAA,IACT,OAAO,OAAO,aAAa,MAAM,QAAQ,CAAC,OAAO,aAAa,OAAO,CAAC,GAAG,UAAU,KAAK,aAAa,MAAM,SAAS,CAAC;AAAA,EACvH;AACF;AAQA,SAAS,aAAa,OAAuB;AAC3C,SAAO,MAAM,WAAW,uBAAuB,OAAO,QAAQ;AAChE;AAQA,SAAS,sBAAsB,UAAwD;AACrF,MAAI,aAAa,SAAS;AACxB,WAAO;AAAA,EACT;AAEA,MAAI,aAAa,UAAU;AACzB,WAAO;AAAA,EACT;AAEA,SAAO;AACT;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/installer-asset.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure helpers for resolving which GitHub release asset is the desktop\n * **installer** for a given Obsidian version and platform.\n *\n * Obsidian changed its installer asset naming convention partway through its\n * history, so a version cannot be turned into an asset name by string\n * templating alone:\n *\n * - **Dot** separator on older releases: `Obsidian.<ver>.exe` (verified 0.14.5\n *   through 1.5.12), with a `-universal` infix on the macOS dmg\n *   (`Obsidian-<ver>-universal.dmg`).\n * - **Hyphen** separator on newer releases: `Obsidian-<ver>.exe`,\n *   `Obsidian-<ver>.dmg` (verified 1.6.7 onward; the transition is around 1.6.0).\n *\n * The integration-time downloader (`obsidian-installer.ts`) queries the\n * release's real asset list and picks the platform-correct one with\n * {@link selectInstallerAssetName}; if that network call is unavailable it\n * falls back to trying every {@link buildInstallerAssetNameCandidates} form.\n * Both helpers are pure so the separator/arch matrix stays unit-tested (the\n * downloader itself needs the network and is excluded from unit tests).\n *\n * Only the x64 installer is resolved \u2014 the extraction path is x64-only \u2014 so the\n * 32-bit / arm64 / all-users sibling assets are deliberately rejected.\n *\n * When the version is present in the baked `metadata.json` catalog (from\n * the `obsidianmd/obsidian-releases` release assets), its exact installer URL is already known;\n * {@link selectInstallerDownloadUrl} picks the platform-correct one and the\n * downloader uses it directly, skipping the release-API lookup and the\n * name-templating fallback entirely.\n */\n\nimport type { ObsidianVersionDownloads } from './obsidian-metadata.mjs';\n\n/**\n * The platform-specific shape of an Obsidian installer asset name.\n */\ninterface PlatformInstallerAssetShape {\n  /**\n  Leading token of the asset name: `Obsidian` (Windows/macOS) or `obsidian` (Linux).\n   */\n  readonly baseName: string;\n\n  /**\n  File extension without the leading dot, e.g. `exe`, `dmg`, `tar.gz`.\n   */\n  readonly extension: string;\n\n  /**\n   * Infixes permitted between the version and the extension for the primary\n   * (non-arch) asset, e.g. `-universal` on the older macOS dmg. An empty array\n   * means the version is immediately followed by the extension.\n   */\n  readonly optionalInfixes: readonly string[];\n}\n\nconst WINDOWS_ASSET_SHAPE: PlatformInstallerAssetShape = {\n  baseName: 'Obsidian',\n  extension: 'exe',\n  optionalInfixes: []\n};\n\nconst MAC_ASSET_SHAPE: PlatformInstallerAssetShape = {\n  baseName: 'Obsidian',\n  extension: 'dmg',\n  optionalInfixes: ['-universal']\n};\n\nconst LINUX_ASSET_SHAPE: PlatformInstallerAssetShape = {\n  baseName: 'obsidian',\n  extension: 'tar.gz',\n  optionalInfixes: []\n};\n\n/**\nSeparator forms tried, hyphen (newer) first, when falling back to templated names.\n */\nconst ASSET_NAME_SEPARATORS = ['-', '.'] as const;\n\n/**\n * Parameters for {@link buildInstallerAssetNameCandidates}.\n */\nexport interface BuildInstallerAssetNameCandidatesParams {\n  /**\n  The platform to build candidate names for.\n   */\n  readonly platform: NodeJS.Platform;\n\n  /**\n  The concrete `x.y.z` version.\n   */\n  readonly version: string;\n}\n\n/**\n * Parameters for {@link selectInstallerAssetName}.\n */\nexport interface SelectInstallerAssetNameParams {\n  /**\n  The release's asset names (e.g. from the GitHub release API).\n   */\n  readonly assetNames: readonly string[];\n\n  /**\n  The platform whose installer asset to select.\n   */\n  readonly platform: NodeJS.Platform;\n\n  /**\n  The concrete `x.y.z` version.\n   */\n  readonly version: string;\n}\n\n/**\n * Parameters for {@link selectInstallerDownloadUrl}.\n */\nexport interface SelectInstallerDownloadUrlParams {\n  /**\n  The version's baked download URLs, or `undefined` when it is absent from the catalog.\n   */\n  readonly downloads: ObsidianVersionDownloads | undefined;\n\n  /**\n  The platform whose installer URL to select.\n   */\n  readonly platform: NodeJS.Platform;\n}\n\n/**\n * Builds the fallback list of installer asset names to try when the release's\n * real asset list cannot be fetched, covering both separator forms (and, on\n * macOS, the `-universal` infix).\n *\n * @param params - The platform and version.\n * @returns Candidate asset names, hyphen-separated forms first.\n */\nexport function buildInstallerAssetNameCandidates(params: BuildInstallerAssetNameCandidatesParams): string[] {\n  const shape = getPlatformAssetShape(params.platform);\n  const infixes = shape.optionalInfixes.length > 0 ? ['', ...shape.optionalInfixes] : [''];\n  const candidates: string[] = [];\n  for (const separator of ASSET_NAME_SEPARATORS) {\n    for (const infix of infixes) {\n      candidates.push(`${shape.baseName}${separator}${params.version}${infix}.${shape.extension}`);\n    }\n  }\n  return candidates;\n}\n\n/**\n * Selects the platform-correct x64 installer asset name from a release's asset\n * list, tolerating both the dot- and hyphen-separated naming conventions and\n * rejecting the 32-bit / arm64 / all-users sibling assets.\n *\n * @param params - The asset list, platform, and version.\n * @returns The matching asset name, or `undefined` if none matches (e.g. a\n *   catalyst release that ships no installer).\n */\nexport function selectInstallerAssetName(params: SelectInstallerAssetNameParams): string | undefined {\n  const pattern = buildAssetNamePattern(getPlatformAssetShape(params.platform), params.version);\n  return params.assetNames.find((name) => pattern.test(name));\n}\n\n/**\n * Selects the platform-correct x64 installer download URL from a version's\n * baked catalog entry.\n *\n * @param params - The baked download URLs and the platform.\n * @returns The installer URL for the platform, or `undefined` when the version\n *   has no catalog entry or ships no desktop installer for it (e.g. a catalyst\n *   build, or a Linux `.tar.gz` that was never published).\n */\nexport function selectInstallerDownloadUrl(params: SelectInstallerDownloadUrlParams): string | undefined {\n  const { downloads } = params;\n  if (!downloads) {\n    return undefined;\n  }\n\n  if (params.platform === 'win32') {\n    return downloads.exe;\n  }\n\n  if (params.platform === 'darwin') {\n    return downloads.dmg;\n  }\n\n  return downloads.tar;\n}\n\n/**\n * Builds an anchored regular expression matching the primary installer asset\n * for a platform shape and version, across both separator conventions.\n *\n * @param shape - The platform asset shape.\n * @param version - The concrete `x.y.z` version.\n * @returns The matching pattern.\n */\nfunction buildAssetNamePattern(shape: PlatformInstallerAssetShape, version: string): RegExp {\n  const infixGroup = shape.optionalInfixes.length > 0\n    ? `(?:${shape.optionalInfixes.map((infix) => escapeRegExp(infix)).join('|')})?`\n    : '';\n  return new RegExp(\n    String.raw`^${escapeRegExp(shape.baseName)}[.-]${escapeRegExp(version)}${infixGroup}\\.${escapeRegExp(shape.extension)}$`\n  );\n}\n\n/**\n * Escapes a string for literal use inside a regular expression.\n *\n * @param value - The raw string.\n * @returns The escaped string.\n */\nfunction escapeRegExp(value: string): string {\n  return value.replaceAll(/[.*+?^${}()|[\\]\\\\]/g, String.raw`\\$&`);\n}\n\n/**\n * Resolves the installer asset shape for a platform.\n *\n * @param platform - The Node.js platform identifier.\n * @returns The asset shape (Linux `.tar.gz` for any non-Windows/macOS platform).\n */\nfunction getPlatformAssetShape(platform: NodeJS.Platform): PlatformInstallerAssetShape {\n  if (platform === 'win32') {\n    return WINDOWS_ASSET_SHAPE;\n  }\n\n  if (platform === 'darwin') {\n    return MAC_ASSET_SHAPE;\n  }\n\n  return LINUX_ASSET_SHAPE;\n}\n"],
  "mappings": "AAyDA,MAAM,sBAAmD;AAAA,EACvD,UAAU;AAAA,EACV,WAAW;AAAA,EACX,iBAAiB,CAAC;AACpB;AAEA,MAAM,kBAA+C;AAAA,EACnD,UAAU;AAAA,EACV,WAAW;AAAA,EACX,iBAAiB,CAAC,YAAY;AAChC;AAEA,MAAM,oBAAiD;AAAA,EACrD,UAAU;AAAA,EACV,WAAW;AAAA,EACX,iBAAiB,CAAC;AACpB;AAKA,MAAM,wBAAwB,CAAC,KAAK,GAAG;AA4DhC,SAAS,kCAAkC,QAA2D;AAC3G,QAAM,QAAQ,sBAAsB,OAAO,QAAQ;AACnD,QAAM,UAAU,MAAM,gBAAgB,SAAS,IAAI,CAAC,IAAI,GAAG,MAAM,eAAe,IAAI,CAAC,EAAE;AACvF,QAAM,aAAuB,CAAC;AAC9B,aAAW,aAAa,uBAAuB;AAC7C,eAAW,SAAS,SAAS;AAC3B,iBAAW,KAAK,GAAG,MAAM,QAAQ,GAAG,SAAS,GAAG,OAAO,OAAO,GAAG,KAAK,IAAI,MAAM,SAAS,EAAE;AAAA,IAC7F;AAAA,EACF;AACA,SAAO;AACT;AAWO,SAAS,yBAAyB,QAA4D;AACnG,QAAM,UAAU,sBAAsB,sBAAsB,OAAO,QAAQ,GAAG,OAAO,OAAO;AAC5F,SAAO,OAAO,WAAW,KAAK,CAAC,SAAS,QAAQ,KAAK,IAAI,CAAC;AAC5D;AAWO,SAAS,2BAA2B,QAA8D;AACvG,QAAM,EAAE,UAAU,IAAI;AACtB,MAAI,CAAC,WAAW;AACd,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,aAAa,SAAS;AAC/B,WAAO,UAAU;AAAA,EACnB;AAEA,MAAI,OAAO,aAAa,UAAU;AAChC,WAAO,UAAU;AAAA,EACnB;AAEA,SAAO,UAAU;AACnB;AAUA,SAAS,sBAAsB,OAAoC,SAAyB;AAC1F,QAAM,aAAa,MAAM,gBAAgB,SAAS,IAC9C,MAAM,MAAM,gBAAgB,IAAI,CAAC,UAAU,aAAa,KAAK,CAAC,EAAE,KAAK,GAAG,CAAC,OACzE;AACJ,SAAO,IAAI;AAAA,IACT,OAAO,OAAO,aAAa,MAAM,QAAQ,CAAC,OAAO,aAAa,OAAO,CAAC,GAAG,UAAU,KAAK,aAAa,MAAM,SAAS,CAAC;AAAA,EACvH;AACF;AAQA,SAAS,aAAa,OAAuB;AAC3C,SAAO,MAAM,WAAW,uBAAuB,OAAO,QAAQ;AAChE;AAQA,SAAS,sBAAsB,UAAwD;AACrF,MAAI,aAAa,SAAS;AACxB,WAAO;AAAA,EACT;AAEA,MAAI,aAAa,UAAU;AACzB,WAAO;AAAA,EACT;AAEA,SAAO;AACT;",
  "names": []
}


package/dist/lib/esm/integration-setup-failed-error.d.mts

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

package/dist/lib/esm/integration-setup-failed-error.mjs

@@ -0,0 +1,38 @@
+class IntegrationSetupFailedError extends Error {
+  /**
+  The `name` of the original error the global setup threw.
+   */
+  errorName;
+  /**
+  The original setup failure, as stringified by the adapter that caught it.
+   */
+  originalMessage;
+  /**
+  The transport the failed project is configured for.
+   */
+  transportLabel;
+  /**
+   * Creates the error from the failure the global setup published to its workers.
+   *
+   * @param params - The configured transport plus the original error's name and message.
+   */
+  constructor(params) {
+    const {
+      errorName,
+      message,
+      transportLabel
+    } = params;
+    super(
+      `Integration setup for transport "${transportLabel}" failed, so its tests cannot run. Original error: ${message}`
+    );
+    this.name = "IntegrationSetupFailedError";
+    this.errorName = errorName;
+    this.originalMessage = message;
+    this.transportLabel = transportLabel;
+    this.stack = `${this.name}: ${this.message}`;
+  }
+}
+export {
+  IntegrationSetupFailedError
+};
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

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

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


package/dist/lib/esm/kill-process-tree.d.mts

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

package/dist/lib/esm/kill-process-tree.mjs

@@ -5,19 +5,29 @@ function killProcessTree(child) {
   if (child.pid === void 0) {
     return;
   }
+  killProcessTreeByPid(child.pid);
+}
+function killProcessTreeByPid(pid) {
   if (process.platform === "win32") {
     try {
-      execFileSync("taskkill", ["/F", "/T", "/PID", String(child.pid)], { stdio: "ignore" });
+      execFileSync("taskkill", ["/F", "/T", "/PID", String(pid)], { stdio: "ignore" });
     } catch (error) {
       log(
-        `[kill-process-tree] taskkill for PID ${String(child.pid)} failed (may have already exited): ${error instanceof Error ? error.message : "unknown error"}`
+        `[kill-process-tree] taskkill for PID ${String(pid)} failed (may have already exited): ${error instanceof Error ? error.message : "unknown error"}`
       );
     }
-  } else {
-    child.kill("SIGKILL");
+    return;
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch (error) {
+    log(
+      `[kill-process-tree] SIGKILL for PID ${String(pid)} failed (may have already exited): ${error instanceof Error ? error.message : "unknown error"}`
+    );
   }
 }
 export {
-  killProcessTree
+  killProcessTree,
+  killProcessTreeByPid
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/library.mjs

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

package/dist/lib/esm/mobile-input.d.mts

@@ -0,0 +1,156 @@
+/**
+ * @file
+ *
+ * Translates a mobile trusted-input request into the ordered Chrome DevTools Protocol `Input.*` commands
+ * that realize it (see **L39**).
+ *
+ * Pure and synchronous by design: the WebView connection ({@link WebViewCdpConnection}) sends whatever this
+ * returns, so every decision that is worth a test — the touch pair a tap expands into, the dwell a
+ * long-press adds, the `rawKeyDown` → `char` → `keyUp` shape a key press mirrors from the desktop twin, the
+ * modifier bitmask — lives here rather than inside the transport's I/O path.
+ *
+ * The request travels renderer → host as JSON (the renderer computes the coordinates, because only it can
+ * see the DOM), so both the request and the command shapes are deliberately plain data.
+ */
+/**
+ * The name of the `Runtime.addBinding` function the host exposes on the page so the renderer can hand it an
+ * input request mid-closure.
+ *
+ * It is passed *into* the serialized bootstrap closure as data rather than referenced from it, because that
+ * closure may not read outer scope (**L15**) — so this stays the single definition.
+ */
+export declare const MOBILE_INPUT_BINDING_NAME = "__obsidianIntegrationTestingInput";
+/**
+ * How long the renderer waits for the host to service one input request before giving up.
+ *
+ * Generous relative to the work (a tap is two CDP commands; a long-press adds a 600ms dwell): the point is
+ * to fail with a legible error rather than hang the closure until the whole run times out. Passed into the
+ * bootstrap closure as data, for the same reason as {@link MOBILE_INPUT_BINDING_NAME}.
+ */
+export declare const MOBILE_INPUT_TIMEOUT_IN_MILLISECONDS = 15000;
+/**
+ * A single Chrome DevTools Protocol command.
+ *
+ * It once also carried a `delayBeforeInMilliseconds`, so the host would sleep between the two halves of a
+ * long-press. That dwell is gone: the gesture is now one `Input.synthesizeTapGesture` that holds itself
+ * for its own `duration`, so no command in any sequence needs to be spaced from the one before it, and a
+ * knob nothing sets is worse than no knob.
+ */
+export interface CdpInputCommand {
+    /**
+     * The CDP method name, e.g. `Input.dispatchTouchEvent`.
+     */
+    readonly method: string;
+    /**
+     * The CDP method parameters.
+     */
+    readonly params: Record<string, unknown>;
+}
+/**
+ * What the renderer hands to the host binding: one request, plus the id to answer it on.
+ *
+ * The renderer builds this literal inside the serialized bootstrap closure, which cannot import (**L15**),
+ * so the shape is declared here and mirrored there. They are one wire format; change them together.
+ */
+export interface MobileInputEnvelope {
+    /**
+     * The request id the renderer is waiting on.
+     */
+    readonly id: string;
+    /**
+     * What to inject.
+     */
+    readonly request: MobileInputRequest;
+}
+/**
+ * Anything the renderer can ask the host to inject.
+ */
+export type MobileInputRequest = MobileKeyInputRequest | MobilePointerInputRequest;
+/**
+ * A trusted key press to inject on mobile.
+ */
+export interface MobileKeyInputRequest {
+    /**
+     * The key to press, in the same spelling the desktop twin takes: either a named key
+     * (`Enter`, `Escape`, `Tab`, `Backspace`, `Delete`, an arrow) or a single printable character.
+     */
+    readonly key: string;
+    /**
+     * Discriminant.
+     */
+    readonly kind: 'key';
+    /**
+     * Modifiers already resolved to their platform-independent lowercase names by the renderer's
+     * `toElectronModifiers` — the one mapping a key press and a click share, so `'Mod'` cannot mean two
+     * different things (**L17**).
+     */
+    readonly modifiers: readonly string[];
+}
+/**
+ * A trusted pointer gesture to inject on mobile, in CSS pixels within the WebView's own viewport.
+ *
+ * No device-pixel conversion is involved: CDP takes page coordinates, so `devicePixelRatio` and the
+ * WebView's offset under the status bar never enter the picture (they would for native injection).
+ */
+export interface MobilePointerInputRequest {
+    /**
+     * `tap` is the touch analog of a left click; `longPress` is the mobile context-menu gesture, i.e. what a
+     * desktop right click means here.
+     */
+    readonly kind: 'longPress' | 'tap';
+    /**
+     * See {@link MobileKeyInputRequest.modifiers}.
+     */
+    readonly modifiers: readonly string[];
+    /**
+     * The viewport x coordinate, in CSS pixels.
+     */
+    readonly x: number;
+    /**
+     * The viewport y coordinate, in CSS pixels.
+     */
+    readonly y: number;
+}
+/**
+ * Builds the expression the host evaluates to answer one input request.
+ *
+ * Optional chaining throughout: by the time the host answers, the page may have navigated and dropped the
+ * namespace, and a `TypeError` inside this evaluate would be reported as an injection failure that already
+ * succeeded.
+ *
+ * @param id - The request id the renderer is waiting on.
+ * @param errorMessage - Why the injection failed, when it did. Omit on success.
+ * @returns A self-contained expression to pass to `Runtime.evaluate`.
+ */
+export declare function buildResolveInputExpression(id: string, errorMessage?: string): string;
+/**
+ * The first code point of a non-empty string.
+ *
+ * `String.prototype.codePointAt` is typed `number | undefined`, so every call site would otherwise carry a
+ * `?? fallback` that no input can ever reach — a dead branch under the 100% coverage gate. Throwing here
+ * keeps that impossible case in ONE place, where a unit test can reach it directly, instead of spreading
+ * unreachable fallbacks (or coverage suppressions) across the module.
+ *
+ * @param text - A non-empty string.
+ * @returns Its first code point.
+ * @throws When `text` is empty.
+ */
+export declare function codePointOf(text: string): number;
+/**
+ * Translates a mobile input request into the ordered CDP commands that realize it.
+ *
+ * @param request - What the renderer asked the host to inject.
+ * @returns The commands to send, in order.
+ */
+export declare function toCdpInputCommands(request: MobileInputRequest): CdpInputCommand[];
+/**
+ * Folds resolved modifier names into CDP's bitmask.
+ *
+ * Unknown names are ignored rather than throwing: the renderer's `toElectronModifiers` is exhaustive over
+ * Obsidian's `Modifier` union, so an unknown name here would mean the two copies have already drifted, and
+ * failing the whole gesture is a worse outcome than pressing it unmodified.
+ *
+ * @param modifiers - Resolved lowercase modifier names.
+ * @returns The CDP modifier bitmask.
+ */
+export declare function toCdpModifiers(modifiers: readonly string[]): number;