obsidian-integration-testing 16.0.0 → 17.0.1

package/dist/lib/cjs/index.cjs

@@ -27,6 +27,8 @@ __export(index_exports, {
   DEFAULT_EVAL_CAP_IN_MILLISECONDS: () => import_eval_cap.DEFAULT_EVAL_CAP_IN_MILLISECONDS,
   DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS: () => import_soft_keyboard_geometry.DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,
   DEFAULT_OBSIDIAN_VERSION_SPECS: () => import_version_matrix.DEFAULT_OBSIDIAN_VERSION_SPECS,
+  DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS: () => import_paint_out_status_bar.DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS,
+  DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS: () => import_paint_out_status_bar.DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS,
   DesktopCdpTransport: () => import_transport_desktop_cdp.DesktopCdpTransport,
   DesktopOnlyPluginSkipError: () => import_desktop_only_plugin_skip_error.DesktopOnlyPluginSkipError,
   DeviceSettingNamespace: () => import_device_settings_command.DeviceSettingNamespace,
@@ -49,8 +51,10 @@ __export(index_exports, {
   buildDeviceSettingsCommandArguments: () => import_device_settings_command.buildDeviceSettingsCommandArguments,
   buildLabelSvg: () => import_label_screenshot.buildLabelSvg,
   buildSoftKeyboardDiagnosticMessage: () => import_soft_keyboard_geometry.buildSoftKeyboardDiagnosticMessage,
+  buildStatusBarBandFailureMessage: () => import_paint_out_status_bar.buildStatusBarBandFailureMessage,
   captureDeviceScreenshot: () => import_device_screenshot.captureDeviceScreenshot,
   captureObsidianScreenshot: () => import_capture_obsidian_screenshot.captureObsidianScreenshot,
+  checkIsInputMethodShown: () => import_soft_keyboard_geometry.checkIsInputMethodShown,
   checkIsMobileTransport: () => import_transport_options.checkIsMobileTransport,
   checkIsSoftKeyboardUp: () => import_soft_keyboard_geometry.checkIsSoftKeyboardUp,
   computeFitToCanvas: () => import_fit_screenshot.computeFitToCanvas,
@@ -70,6 +74,7 @@ __export(index_exports, {
   labelScreenshot: () => import_label_screenshot.labelScreenshot,
   measureLabelCaption: () => import_label_screenshot.measureLabelCaption,
   openObsidianSettingsTab: () => import_open_obsidian_settings_tab.openObsidianSettingsTab,
+  paintOutStatusBar: () => import_paint_out_status_bar.paintOutStatusBar,
   parseInputMethodState: () => import_soft_keyboard_geometry.parseInputMethodState,
   pollInObsidian: () => import_poll_in_obsidian.pollInObsidian,
   raiseSoftKeyboard: () => import_soft_keyboard.raiseSoftKeyboard,
@@ -85,6 +90,7 @@ __export(index_exports, {
   resolveInstallerCompatibility: () => import_installer_compatibility.resolveInstallerCompatibility,
   resolveMissingInjectedPlugins: () => import_demo_vault_populate.resolveMissingInjectedPlugins,
   resolveSoftKeyboardTapPoints: () => import_soft_keyboard_geometry.resolveSoftKeyboardTapPoints,
+  resolveStatusBarBand: () => import_paint_out_status_bar.resolveStatusBarBand,
   restoreAppConfig: () => import_app_config.restoreAppConfig,
   runAdbBinary: () => import_adb.runAdbBinary,
   runAdbText: () => import_adb.runAdbText,
@@ -137,6 +143,7 @@ var import_obsidian_metadata = require("./obsidian-metadata.cjs");
 var import_obsidian_version = require("./obsidian-version.cjs");
 var import_open_obsidian_settings_tab = require("./open-obsidian-settings-tab.cjs");
 var import_owned_instance_exited_error = require("./owned-instance-exited-error.cjs");
+var import_paint_out_status_bar = require("./paint-out-status-bar.cjs");
 var import_poll_in_obsidian = require("./poll-in-obsidian.cjs");
 var import_renderer_failed_to_initialize_error = require("./renderer-failed-to-initialize-error.cjs");
 var import_resolve_emulator_device_id = require("./resolve-emulator-device-id.cjs");
@@ -163,6 +170,8 @@ var import_version_matrix = require("./version-matrix.cjs");
   DEFAULT_EVAL_CAP_IN_MILLISECONDS,
   DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,
   DEFAULT_OBSIDIAN_VERSION_SPECS,
+  DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS,
+  DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS,
   DesktopCdpTransport,
   DesktopOnlyPluginSkipError,
   DeviceSettingNamespace,
@@ -185,8 +194,10 @@ var import_version_matrix = require("./version-matrix.cjs");
   buildDeviceSettingsCommandArguments,
   buildLabelSvg,
   buildSoftKeyboardDiagnosticMessage,
+  buildStatusBarBandFailureMessage,
   captureDeviceScreenshot,
   captureObsidianScreenshot,
+  checkIsInputMethodShown,
   checkIsMobileTransport,
   checkIsSoftKeyboardUp,
   computeFitToCanvas,
@@ -206,6 +217,7 @@ var import_version_matrix = require("./version-matrix.cjs");
   labelScreenshot,
   measureLabelCaption,
   openObsidianSettingsTab,
+  paintOutStatusBar,
   parseInputMethodState,
   pollInObsidian,
   raiseSoftKeyboard,
@@ -221,6 +233,7 @@ var import_version_matrix = require("./version-matrix.cjs");
   resolveInstallerCompatibility,
   resolveMissingInjectedPlugins,
   resolveSoftKeyboardTapPoints,
+  resolveStatusBarBand,
   restoreAppConfig,
   runAdbBinary,
   runAdbText,
@@ -237,4 +250,4 @@ var import_version_matrix = require("./version-matrix.cjs");
   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.cjs';\nexport {\n  runAdbBinary,\n  runAdbText,\n  runAdbTextWithoutDevice\n} from './adb.cjs';\nexport type {\n  AppConfigRestore,\n  GetAppConfigParams,\n  SetAppConfigParams,\n  WithAppConfigParams\n} from './app-config.cjs';\nexport {\n  getAppConfig,\n  restoreAppConfig,\n  setAppConfig,\n  withAppConfig\n} from './app-config.cjs';\nexport type {\n  AsarFallback,\n  AsarFallbackTier,\n  ResolveAsarFallbackParams\n} from './asar-fallback-detection.cjs';\nexport { resolveAsarFallback } from './asar-fallback-detection.cjs';\nexport type { CaptureObsidianScreenshotOptions } from './capture-obsidian-screenshot.cjs';\nexport { captureObsidianScreenshot } from './capture-obsidian-screenshot.cjs';\nexport type {\n  CaptureScreenshotParams,\n  PngDimensions\n} from './capture-screenshot.cjs';\nexport {\n  buildDeviceMetricsOverride,\n  decodeBase64Png,\n  isPng,\n  readPngDimensions\n} from './capture-screenshot.cjs';\nexport type { CdpCommandTimeoutErrorConstructorParams } from './cdp-command-timeout-error.cjs';\nexport { CdpCommandTimeoutError } from './cdp-command-timeout-error.cjs';\nexport type { ConfigDirectoryFallbackErrorConstructorParams } from './config-directory-fallback-error.cjs';\nexport { ConfigDirectoryFallbackError } from './config-directory-fallback-error.cjs';\nexport {\n  assertValidConfigDirectory,\n  DEFAULT_CONFIG_DIRECTORY\n} from './config-directory.cjs';\nexport type {\n  CdpConnection,\n  ConnectToCdpOptions\n} from './connect-to-cdp.cjs';\nexport { connectToCdp } from './connect-to-cdp.cjs';\nexport type {\n  ContextArguments,\n  ContextOf\n} from './context-id.cjs';\nexport { ContextId } from './context-id.cjs';\nexport type {\n  SetupErrorResolver,\n  TransportOptionsResolver,\n  VaultPathResolver\n} from './context-provider.cjs';\nexport {\n  setSetupErrorResolver,\n  setTransportOptionsResolver,\n  setVaultPathResolver\n} from './context-provider.cjs';\nexport type {\n  BootstrapDemoVaultPluginsParams,\n  BootstrapDemoVaultPluginsResult,\n  BuildDemoVaultPopulateAsyncParams,\n  InstalledPluginInfo\n} from './demo-vault-bootstrap.cjs';\nexport {\n  bootstrapDemoVaultPlugins,\n  buildDemoVaultPopulateAsync\n} from './demo-vault-bootstrap.cjs';\nexport type {\n  BuildDemoVaultPopulateParams,\n  InjectPluginParams,\n  ResolveMissingInjectedPluginsParams\n} from './demo-vault-populate.cjs';\nexport {\n  buildDemoVaultPopulate,\n  resolveMissingInjectedPlugins\n} from './demo-vault-populate.cjs';\nexport type { ReadDemoVaultTreeParams } from './demo-vault-tree.cjs';\nexport { readDemoVaultTree } from './demo-vault-tree.cjs';\nexport { DesktopOnlyPluginSkipError } from './desktop-only-plugin-skip-error.cjs';\nexport type { CaptureDeviceScreenshotParams } from './device-screenshot.cjs';\nexport { captureDeviceScreenshot } from './device-screenshot.cjs';\nexport type {\n  DeviceSettingRestore,\n  DeviceSettingRestoreDelete,\n  DeviceSettingRestoreWrite\n} from './device-setting-restore.cjs';\nexport {\n  DeviceSettingRestoreKind,\n  resolveDeviceSettingRestore\n} from './device-setting-restore.cjs';\nexport type { BuildDeviceSettingsCommandArgumentsParams } from './device-settings-command.cjs';\nexport {\n  buildDeviceSettingsCommandArguments,\n  DeviceSettingNamespace,\n  DeviceSettingVerb\n} from './device-settings-command.cjs';\nexport type {\n  DeviceSettingParams,\n  WithSoftKeyboardEnabledParams,\n  WriteDeviceSettingParams\n} from './device-settings.cjs';\nexport {\n  deleteDeviceSetting,\n  readDeviceSetting,\n  withSoftKeyboardEnabled,\n  writeDeviceSetting\n} from './device-settings.cjs';\nexport type {\n  ElectronCompatibility,\n  ElectronCompatibilityTier,\n  ResolveElectronCompatibilityParams\n} from './electron-compatibility.cjs';\nexport { resolveElectronCompatibility } from './electron-compatibility.cjs';\nexport type {\n  EmulatorDeviceCandidate,\n  SelectEmulatorDeviceIdParams\n} from './emulator-device-id.cjs';\nexport { selectEmulatorDeviceId } from './emulator-device-id.cjs';\nexport type { EvalCapExceededErrorConstructorParams } from './eval-cap-exceeded-error.cjs';\nexport {\n  EvalCapExceededError,\n  isScriptTimeoutError\n} from './eval-cap-exceeded-error.cjs';\nexport { DEFAULT_EVAL_CAP_IN_MILLISECONDS } from './eval-cap.cjs';\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.cjs';\nexport { evalInObsidian } from './eval-in-obsidian.cjs';\nexport type {\n  ComputeFitToCanvasParams,\n  FitScreenshotToCanvasOptions,\n  FitToCanvasGeometry\n} from './fit-screenshot.cjs';\nexport {\n  computeFitToCanvas,\n  fitScreenshotToCanvas\n} from './fit-screenshot.cjs';\nexport type { HideVaultNameOptions } from './hide-vault-name.cjs';\nexport { hideVaultName } from './hide-vault-name.cjs';\nexport type { IncompatibleInstallerVersionErrorConstructorParams } from './incompatible-installer-version-error.cjs';\nexport { IncompatibleInstallerVersionError } from './incompatible-installer-version-error.cjs';\nexport type {\n  InstallerCompatibility,\n  InstallerCompatibilityTier,\n  ResolveInstallerCompatibilityParams\n} from './installer-compatibility.cjs';\nexport { resolveInstallerCompatibility } from './installer-compatibility.cjs';\nexport type { IntegrationSetupFailedErrorConstructorParams } from './integration-setup-failed-error.cjs';\nexport { IntegrationSetupFailedError } from './integration-setup-failed-error.cjs';\nexport type {\n  ComputeLabelBandParams,\n  LabelBandGeometry,\n  LabelCaptionMeasurement,\n  LabelScreenshotOptions,\n  MeasureLabelCaptionParams\n} from './label-screenshot.cjs';\nexport {\n  buildLabelSvg,\n  computeLabelBand,\n  escapeSvgText,\n  labelScreenshot,\n  measureLabelCaption\n} from './label-screenshot.cjs';\nexport type { LibResolver } from './lib-registry.cjs';\nexport { registerLibResolver } from './lib-registry.cjs';\nexport type {\n  ObsidianRuntimeVersions,\n  ObsidianVersionChangelogUrls,\n  ObsidianVersionDownloads,\n  ObsidianVersionMetadata\n} from './obsidian-metadata.cjs';\nexport { getVersionMetadata } from './obsidian-metadata.cjs';\nexport {\n  CATALYST_LATEST,\n  PUBLIC_LATEST\n} from './obsidian-version.cjs';\nexport type { OpenObsidianSettingsTabParams } from './open-obsidian-settings-tab.cjs';\nexport { openObsidianSettingsTab } from './open-obsidian-settings-tab.cjs';\nexport type { OwnedInstanceExitedErrorConstructorParams } from './owned-instance-exited-error.cjs';\nexport { OwnedInstanceExitedError } from './owned-instance-exited-error.cjs';\nexport type { PollInObsidianParams } from './poll-in-obsidian.cjs';\nexport { pollInObsidian } from './poll-in-obsidian.cjs';\nexport { RendererFailedToInitializeError } from './renderer-failed-to-initialize-error.cjs';\nexport type { ResolveEmulatorDeviceIdParams } from './resolve-emulator-device-id.cjs';\nexport { resolveEmulatorDeviceId } from './resolve-emulator-device-id.cjs';\nexport type { RunObsidianVersionMatrixParams } from './run-version-matrix.cjs';\nexport { runObsidianVersionMatrix } from './run-version-matrix.cjs';\nexport type { SilentAsarFallbackErrorConstructorParams } from './silent-asar-fallback-error.cjs';\nexport { SilentAsarFallbackError } from './silent-asar-fallback-error.cjs';\nexport type {\n  BuildSoftKeyboardDiagnosticMessageParams,\n  CheckIsSoftKeyboardUpParams,\n  ElementRect,\n  ResolveSoftKeyboardTapPointsParams,\n  SoftKeyboardTapPoint,\n  SoftKeyboardViewportSnapshot\n} from './soft-keyboard-geometry.cjs';\nexport {\n  buildSoftKeyboardDiagnosticMessage,\n  checkIsSoftKeyboardUp,\n  DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,\n  parseInputMethodState,\n  resolveSoftKeyboardTapPoints\n} from './soft-keyboard-geometry.cjs';\nexport type {\n  RaiseSoftKeyboardParams,\n  TapDeviceParams\n} from './soft-keyboard.cjs';\nexport {\n  raiseSoftKeyboard,\n  tapDevice\n} from './soft-keyboard.cjs';\nexport type { StaleBuildErrorConstructorParams } from './stale-build-error.cjs';\nexport { StaleBuildError } from './stale-build-error.cjs';\nexport type {\n  PopulateFileContent,\n  PopulateFilesParams,\n  TemporaryVaultConstructorOptions\n} from './temporary-vault.cjs';\nexport { TemporaryVault } from './temporary-vault.cjs';\nexport type {\n  AppiumSessionInfo,\n  AppiumTransportConfig\n} from './transport-appium.cjs';\nexport { AppiumTransport } from './transport-appium.cjs';\nexport type {\n  DesktopCdpTransportConfig,\n  OwnedInstanceAsar,\n  OwnedInstanceConfig,\n  OwnedInstanceEndpoint\n} from './transport-desktop-cdp.cjs';\nexport { DesktopCdpTransport } from './transport-desktop-cdp.cjs';\nexport { createTransportFromOptions } from './transport-factory.cjs';\nexport type {\n  ObsidianAndroidAppiumTransportOptions,\n  ObsidianCdpTransportOptions,\n  ObsidianTransportOptions\n} from './transport-options.cjs';\nexport { checkIsMobileTransport } from './transport-options.cjs';\nexport type {\n  ConsoleCaptureHandle,\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.cjs';\nexport {\n  registerVault,\n  unregisterVault\n} from './vault-registry.cjs';\nexport type { ObsidianVersionMatrixEntry } from './version-matrix.cjs';\nexport { DEFAULT_OBSIDIAN_VERSION_SPECS } from './version-matrix.cjs';\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,iBAIO;AAOP,wBAKO;AAMP,qCAAoC;AAEpC,yCAA0C;AAK1C,gCAKO;AAEP,uCAAuC;AAEvC,6CAA6C;AAC7C,8BAGO;AAKP,4BAA6B;AAK7B,wBAA0B;AAM1B,8BAIO;AAOP,kCAGO;AAMP,iCAGO;AAEP,6BAAkC;AAClC,4CAA2C;AAE3C,+BAAwC;AAMxC,oCAGO;AAEP,qCAIO;AAMP,6BAKO;AAMP,oCAA6C;AAK7C,gCAAuC;AAEvC,qCAGO;AACP,sBAAiD;AAkBjD,8BAA+B;AAM/B,4BAGO;AAEP,6BAA8B;AAE9B,kDAAkD;AAMlD,qCAA8C;AAE9C,4CAA4C;AAQ5C,8BAMO;AAEP,0BAAoC;AAOpC,+BAAmC;AACnC,8BAGO;AAEP,wCAAwC;AAExC,yCAAyC;AAEzC,8BAA+B;AAC/B,iDAAgD;AAEhD,wCAAwC;AAExC,gCAAyC;AAEzC,wCAAwC;AASxC,oCAMO;AAKP,2BAGO;AAEP,+BAAgC;AAMhC,6BAA+B;AAK/B,8BAAgC;AAOhC,mCAAoC;AACpC,+BAA2C;AAM3C,+BAAuC;AAMvC,4BAGO;AAEP,4BAA+C;",
  "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.cjs';\nexport {\n  runAdbBinary,\n  runAdbText,\n  runAdbTextWithoutDevice\n} from './adb.cjs';\nexport type {\n  AppConfigRestore,\n  GetAppConfigParams,\n  SetAppConfigParams,\n  WithAppConfigParams\n} from './app-config.cjs';\nexport {\n  getAppConfig,\n  restoreAppConfig,\n  setAppConfig,\n  withAppConfig\n} from './app-config.cjs';\nexport type {\n  AsarFallback,\n  AsarFallbackTier,\n  ResolveAsarFallbackParams\n} from './asar-fallback-detection.cjs';\nexport { resolveAsarFallback } from './asar-fallback-detection.cjs';\nexport type { CaptureObsidianScreenshotOptions } from './capture-obsidian-screenshot.cjs';\nexport { captureObsidianScreenshot } from './capture-obsidian-screenshot.cjs';\nexport type {\n  CaptureScreenshotParams,\n  PngDimensions\n} from './capture-screenshot.cjs';\nexport {\n  buildDeviceMetricsOverride,\n  decodeBase64Png,\n  isPng,\n  readPngDimensions\n} from './capture-screenshot.cjs';\nexport type { CdpCommandTimeoutErrorConstructorParams } from './cdp-command-timeout-error.cjs';\nexport { CdpCommandTimeoutError } from './cdp-command-timeout-error.cjs';\nexport type { ConfigDirectoryFallbackErrorConstructorParams } from './config-directory-fallback-error.cjs';\nexport { ConfigDirectoryFallbackError } from './config-directory-fallback-error.cjs';\nexport {\n  assertValidConfigDirectory,\n  DEFAULT_CONFIG_DIRECTORY\n} from './config-directory.cjs';\nexport type {\n  CdpConnection,\n  ConnectToCdpOptions\n} from './connect-to-cdp.cjs';\nexport { connectToCdp } from './connect-to-cdp.cjs';\nexport type {\n  ContextArguments,\n  ContextOf\n} from './context-id.cjs';\nexport { ContextId } from './context-id.cjs';\nexport type {\n  SetupErrorResolver,\n  TransportOptionsResolver,\n  VaultPathResolver\n} from './context-provider.cjs';\nexport {\n  setSetupErrorResolver,\n  setTransportOptionsResolver,\n  setVaultPathResolver\n} from './context-provider.cjs';\nexport type {\n  BootstrapDemoVaultPluginsParams,\n  BootstrapDemoVaultPluginsResult,\n  BuildDemoVaultPopulateAsyncParams,\n  InstalledPluginInfo\n} from './demo-vault-bootstrap.cjs';\nexport {\n  bootstrapDemoVaultPlugins,\n  buildDemoVaultPopulateAsync\n} from './demo-vault-bootstrap.cjs';\nexport type {\n  BuildDemoVaultPopulateParams,\n  InjectPluginParams,\n  ResolveMissingInjectedPluginsParams\n} from './demo-vault-populate.cjs';\nexport {\n  buildDemoVaultPopulate,\n  resolveMissingInjectedPlugins\n} from './demo-vault-populate.cjs';\nexport type { ReadDemoVaultTreeParams } from './demo-vault-tree.cjs';\nexport { readDemoVaultTree } from './demo-vault-tree.cjs';\nexport { DesktopOnlyPluginSkipError } from './desktop-only-plugin-skip-error.cjs';\nexport type { CaptureDeviceScreenshotParams } from './device-screenshot.cjs';\nexport { captureDeviceScreenshot } from './device-screenshot.cjs';\nexport type {\n  DeviceSettingRestore,\n  DeviceSettingRestoreDelete,\n  DeviceSettingRestoreWrite\n} from './device-setting-restore.cjs';\nexport {\n  DeviceSettingRestoreKind,\n  resolveDeviceSettingRestore\n} from './device-setting-restore.cjs';\nexport type { BuildDeviceSettingsCommandArgumentsParams } from './device-settings-command.cjs';\nexport {\n  buildDeviceSettingsCommandArguments,\n  DeviceSettingNamespace,\n  DeviceSettingVerb\n} from './device-settings-command.cjs';\nexport type {\n  DeviceSettingParams,\n  WithSoftKeyboardEnabledParams,\n  WriteDeviceSettingParams\n} from './device-settings.cjs';\nexport {\n  deleteDeviceSetting,\n  readDeviceSetting,\n  withSoftKeyboardEnabled,\n  writeDeviceSetting\n} from './device-settings.cjs';\nexport type {\n  ElectronCompatibility,\n  ElectronCompatibilityTier,\n  ResolveElectronCompatibilityParams\n} from './electron-compatibility.cjs';\nexport { resolveElectronCompatibility } from './electron-compatibility.cjs';\nexport type {\n  EmulatorDeviceCandidate,\n  SelectEmulatorDeviceIdParams\n} from './emulator-device-id.cjs';\nexport { selectEmulatorDeviceId } from './emulator-device-id.cjs';\nexport type { EvalCapExceededErrorConstructorParams } from './eval-cap-exceeded-error.cjs';\nexport {\n  EvalCapExceededError,\n  isScriptTimeoutError\n} from './eval-cap-exceeded-error.cjs';\nexport { DEFAULT_EVAL_CAP_IN_MILLISECONDS } from './eval-cap.cjs';\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.cjs';\nexport { evalInObsidian } from './eval-in-obsidian.cjs';\nexport type {\n  ComputeFitToCanvasParams,\n  FitScreenshotToCanvasOptions,\n  FitToCanvasGeometry\n} from './fit-screenshot.cjs';\nexport {\n  computeFitToCanvas,\n  fitScreenshotToCanvas\n} from './fit-screenshot.cjs';\nexport type { HideVaultNameOptions } from './hide-vault-name.cjs';\nexport { hideVaultName } from './hide-vault-name.cjs';\nexport type { IncompatibleInstallerVersionErrorConstructorParams } from './incompatible-installer-version-error.cjs';\nexport { IncompatibleInstallerVersionError } from './incompatible-installer-version-error.cjs';\nexport type {\n  InstallerCompatibility,\n  InstallerCompatibilityTier,\n  ResolveInstallerCompatibilityParams\n} from './installer-compatibility.cjs';\nexport { resolveInstallerCompatibility } from './installer-compatibility.cjs';\nexport type { IntegrationSetupFailedErrorConstructorParams } from './integration-setup-failed-error.cjs';\nexport { IntegrationSetupFailedError } from './integration-setup-failed-error.cjs';\nexport type {\n  ComputeLabelBandParams,\n  LabelBandGeometry,\n  LabelCaptionMeasurement,\n  LabelScreenshotOptions,\n  MeasureLabelCaptionParams\n} from './label-screenshot.cjs';\nexport {\n  buildLabelSvg,\n  computeLabelBand,\n  escapeSvgText,\n  labelScreenshot,\n  measureLabelCaption\n} from './label-screenshot.cjs';\nexport type { LibResolver } from './lib-registry.cjs';\nexport { registerLibResolver } from './lib-registry.cjs';\nexport type {\n  ObsidianRuntimeVersions,\n  ObsidianVersionChangelogUrls,\n  ObsidianVersionDownloads,\n  ObsidianVersionMetadata\n} from './obsidian-metadata.cjs';\nexport { getVersionMetadata } from './obsidian-metadata.cjs';\nexport {\n  CATALYST_LATEST,\n  PUBLIC_LATEST\n} from './obsidian-version.cjs';\nexport type { OpenObsidianSettingsTabParams } from './open-obsidian-settings-tab.cjs';\nexport { openObsidianSettingsTab } from './open-obsidian-settings-tab.cjs';\nexport type { OwnedInstanceExitedErrorConstructorParams } from './owned-instance-exited-error.cjs';\nexport { OwnedInstanceExitedError } from './owned-instance-exited-error.cjs';\nexport type {\n  BuildStatusBarBandFailureMessageParams,\n  PaintOutStatusBarOptions,\n  ResolveStatusBarBandParams,\n  StatusBarBandColor,\n  StatusBarBandVerdict\n} from './paint-out-status-bar.cjs';\nexport {\n  buildStatusBarBandFailureMessage,\n  DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS,\n  DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS,\n  paintOutStatusBar,\n  resolveStatusBarBand\n} from './paint-out-status-bar.cjs';\nexport type { PollInObsidianParams } from './poll-in-obsidian.cjs';\nexport { pollInObsidian } from './poll-in-obsidian.cjs';\nexport { RendererFailedToInitializeError } from './renderer-failed-to-initialize-error.cjs';\nexport type { ResolveEmulatorDeviceIdParams } from './resolve-emulator-device-id.cjs';\nexport { resolveEmulatorDeviceId } from './resolve-emulator-device-id.cjs';\nexport type { RunObsidianVersionMatrixParams } from './run-version-matrix.cjs';\nexport { runObsidianVersionMatrix } from './run-version-matrix.cjs';\nexport type { SilentAsarFallbackErrorConstructorParams } from './silent-asar-fallback-error.cjs';\nexport { SilentAsarFallbackError } from './silent-asar-fallback-error.cjs';\nexport type {\n  BuildSoftKeyboardDiagnosticMessageParams,\n  CheckIsSoftKeyboardUpParams,\n  ElementRect,\n  ResolveSoftKeyboardTapPointsParams,\n  SoftKeyboardTapPoint,\n  SoftKeyboardViewportSnapshot\n} from './soft-keyboard-geometry.cjs';\nexport {\n  buildSoftKeyboardDiagnosticMessage,\n  checkIsInputMethodShown,\n  checkIsSoftKeyboardUp,\n  DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,\n  parseInputMethodState,\n  resolveSoftKeyboardTapPoints\n} from './soft-keyboard-geometry.cjs';\nexport type {\n  RaiseSoftKeyboardParams,\n  TapDeviceParams\n} from './soft-keyboard.cjs';\nexport {\n  raiseSoftKeyboard,\n  tapDevice\n} from './soft-keyboard.cjs';\nexport type { StaleBuildErrorConstructorParams } from './stale-build-error.cjs';\nexport { StaleBuildError } from './stale-build-error.cjs';\nexport type {\n  PopulateFileContent,\n  PopulateFilesParams,\n  TemporaryVaultConstructorOptions\n} from './temporary-vault.cjs';\nexport { TemporaryVault } from './temporary-vault.cjs';\nexport type {\n  AppiumSessionInfo,\n  AppiumTransportConfig\n} from './transport-appium.cjs';\nexport { AppiumTransport } from './transport-appium.cjs';\nexport type {\n  DesktopCdpTransportConfig,\n  OwnedInstanceAsar,\n  OwnedInstanceConfig,\n  OwnedInstanceEndpoint\n} from './transport-desktop-cdp.cjs';\nexport { DesktopCdpTransport } from './transport-desktop-cdp.cjs';\nexport { createTransportFromOptions } from './transport-factory.cjs';\nexport type {\n  ObsidianAndroidAppiumTransportOptions,\n  ObsidianCdpTransportOptions,\n  ObsidianTransportOptions\n} from './transport-options.cjs';\nexport { checkIsMobileTransport } from './transport-options.cjs';\nexport type {\n  ConsoleCaptureHandle,\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.cjs';\nexport {\n  registerVault,\n  unregisterVault\n} from './vault-registry.cjs';\nexport type { ObsidianVersionMatrixEntry } from './version-matrix.cjs';\nexport { DEFAULT_OBSIDIAN_VERSION_SPECS } from './version-matrix.cjs';\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,iBAIO;AAOP,wBAKO;AAMP,qCAAoC;AAEpC,yCAA0C;AAK1C,gCAKO;AAEP,uCAAuC;AAEvC,6CAA6C;AAC7C,8BAGO;AAKP,4BAA6B;AAK7B,wBAA0B;AAM1B,8BAIO;AAOP,kCAGO;AAMP,iCAGO;AAEP,6BAAkC;AAClC,4CAA2C;AAE3C,+BAAwC;AAMxC,oCAGO;AAEP,qCAIO;AAMP,6BAKO;AAMP,oCAA6C;AAK7C,gCAAuC;AAEvC,qCAGO;AACP,sBAAiD;AAkBjD,8BAA+B;AAM/B,4BAGO;AAEP,6BAA8B;AAE9B,kDAAkD;AAMlD,qCAA8C;AAE9C,4CAA4C;AAQ5C,8BAMO;AAEP,0BAAoC;AAOpC,+BAAmC;AACnC,8BAGO;AAEP,wCAAwC;AAExC,yCAAyC;AAQzC,kCAMO;AAEP,8BAA+B;AAC/B,iDAAgD;AAEhD,wCAAwC;AAExC,gCAAyC;AAEzC,wCAAwC;AASxC,oCAOO;AAKP,2BAGO;AAEP,+BAAgC;AAMhC,6BAA+B;AAK/B,8BAAgC;AAOhC,mCAAoC;AACpC,+BAA2C;AAM3C,+BAAuC;AAMvC,4BAGO;AAEP,4BAA+C;",
  "names": []
}


package/dist/lib/cjs/index.d.cts

@@ -69,6 +69,8 @@ export type { OpenObsidianSettingsTabParams } from './open-obsidian-settings-tab
 export { openObsidianSettingsTab } from './open-obsidian-settings-tab.cjs';
 export type { OwnedInstanceExitedErrorConstructorParams } from './owned-instance-exited-error.cjs';
 export { OwnedInstanceExitedError } from './owned-instance-exited-error.cjs';
+export type { BuildStatusBarBandFailureMessageParams, PaintOutStatusBarOptions, ResolveStatusBarBandParams, StatusBarBandColor, StatusBarBandVerdict } from './paint-out-status-bar.cjs';
+export { buildStatusBarBandFailureMessage, DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS, DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS, paintOutStatusBar, resolveStatusBarBand } from './paint-out-status-bar.cjs';
 export type { PollInObsidianParams } from './poll-in-obsidian.cjs';
 export { pollInObsidian } from './poll-in-obsidian.cjs';
 export { RendererFailedToInitializeError } from './renderer-failed-to-initialize-error.cjs';
@@ -79,7 +81,7 @@ export { runObsidianVersionMatrix } from './run-version-matrix.cjs';
 export type { SilentAsarFallbackErrorConstructorParams } from './silent-asar-fallback-error.cjs';
 export { SilentAsarFallbackError } from './silent-asar-fallback-error.cjs';
 export type { BuildSoftKeyboardDiagnosticMessageParams, CheckIsSoftKeyboardUpParams, ElementRect, ResolveSoftKeyboardTapPointsParams, SoftKeyboardTapPoint, SoftKeyboardViewportSnapshot } from './soft-keyboard-geometry.cjs';
-export { buildSoftKeyboardDiagnosticMessage, checkIsSoftKeyboardUp, DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS, parseInputMethodState, resolveSoftKeyboardTapPoints } from './soft-keyboard-geometry.cjs';
+export { buildSoftKeyboardDiagnosticMessage, checkIsInputMethodShown, checkIsSoftKeyboardUp, DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS, parseInputMethodState, resolveSoftKeyboardTapPoints } from './soft-keyboard-geometry.cjs';
 export type { RaiseSoftKeyboardParams, TapDeviceParams } from './soft-keyboard.cjs';
 export { raiseSoftKeyboard, tapDevice } from './soft-keyboard.cjs';
 export type { StaleBuildErrorConstructorParams } from './stale-build-error.cjs';

package/dist/lib/cjs/launched-device-selection.cjs

@@ -0,0 +1,46 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var launched_device_selection_exports = {};
+__export(launched_device_selection_exports, {
+  resolveLaunchedDevice: () => resolveLaunchedDevice,
+  splitNewDevices: () => splitNewDevices
+});
+module.exports = __toCommonJS(launched_device_selection_exports);
+var import_avd_probe_verdict = require("./avd-probe-verdict.cjs");
+function resolveLaunchedDevice(params) {
+  const match = params.candidates.find((candidate) => candidate.probedAvdName === params.avdName);
+  return {
+    deviceId: match?.deviceId,
+    otherAvdDeviceIds: params.candidates.filter((candidate) => candidate.probedAvdName !== void 0 && candidate.probedAvdName !== params.avdName).map((candidate) => candidate.deviceId),
+    unansweredDeviceIds: params.candidates.filter((candidate) => candidate.probedAvdName === void 0).map((candidate) => candidate.deviceId)
+  };
+}
+function splitNewDevices(params) {
+  const newDeviceIds = params.connectedDeviceIds.filter((deviceId) => !params.deviceIdsBefore.includes(deviceId));
+  return {
+    emulatorDeviceIds: newDeviceIds.filter((deviceId) => (0, import_avd_probe_verdict.checkIsEmulatorDeviceId)(deviceId)),
+    nonEmulatorDeviceIds: newDeviceIds.filter((deviceId) => !(0, import_avd_probe_verdict.checkIsEmulatorDeviceId)(deviceId))
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveLaunchedDevice,
+  splitNewDevices
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/launched-device-selection.d.cts

@@ -0,0 +1,112 @@
+/**
+ * @file
+ *
+ * Pure selection of the device an emulator this run just launched produced.
+ *
+ * The wait used to take the first online device that was not listed before the
+ * launch. The "before" snapshot lists online devices only, so a handset that was
+ * `unauthorized`, `offline` or unplugged at that moment — and came online during
+ * the boot, which a USB reconnect or accepting the debugging prompt is enough
+ * for — looked new, and was adopted as the emulator:
+ *
+ * ```text
+ * AVD "obsidian_test" not found on any existing device, starting a new emulator...
+ * Waiting for a new device to appear in ADB ...
+ * Device 3C15BN001Y900000 appeared in ADB, waiting for boot to complete...
+ * Emulator "obsidian_test" started, device 3C15BN001Y900000 is connected (owned emulator PIDs: [])
+ * ```
+ *
+ * The suite then ran on the phone, and the emulator really launched was owned by
+ * nobody. So a new device is the launched emulator only when it is an emulator
+ * **and** it says it is serving the launched AVD — which also keeps a second
+ * emulator another project started concurrently from being adopted.
+ *
+ * Kept separate from the integration-only `transport-factory` so the decision is
+ * unit-testable; the factory does the `adb` round-trips.
+ */
+/**
+ * One new emulator device, with what it answered when asked for its AVD name.
+ */
+export interface LaunchedDeviceCandidate {
+    /**
+     * The device UDID, e.g. `emulator-5554`.
+     */
+    readonly deviceId: string;
+    /**
+     * The AVD the device reported, or `undefined` when it did not answer.
+     */
+    readonly probedAvdName: string | undefined;
+}
+/**
+ * The new devices a poll found, split by whether they can be the launched emulator.
+ */
+export interface NewDeviceSplit {
+    /**
+     * New emulator devices, to be asked which AVD they serve.
+     */
+    readonly emulatorDeviceIds: string[];
+    /**
+     * New devices that are not emulators (a handset, a TCP-attached device) and are never adopted.
+     */
+    readonly nonEmulatorDeviceIds: string[];
+}
+/**
+ * Parameters for {@link resolveLaunchedDevice}.
+ */
+export interface ResolveLaunchedDeviceParams {
+    /**
+     * The AVD this run launched.
+     */
+    readonly avdName: string;
+    /**
+     * The new emulator devices, with their probe answers.
+     */
+    readonly candidates: readonly LaunchedDeviceCandidate[];
+}
+/**
+ * What the probe answers say about the launched emulator's device.
+ */
+export interface ResolveLaunchedDeviceResult {
+    /**
+     * The device serving the launched AVD, or `undefined` when none does yet.
+     */
+    readonly deviceId: string | undefined;
+    /**
+     * Devices that answered with a different AVD: another emulator, never this run's.
+     */
+    readonly otherAvdDeviceIds: string[];
+    /**
+     * Devices that did not answer yet, to be asked again on the next poll.
+     */
+    readonly unansweredDeviceIds: string[];
+}
+/**
+ * Parameters for {@link splitNewDevices}.
+ */
+export interface SplitNewDevicesParams {
+    /**
+     * The devices online now.
+     */
+    readonly connectedDeviceIds: readonly string[];
+    /**
+     * The devices online before the launch.
+     */
+    readonly deviceIdsBefore: readonly string[];
+}
+/**
+ * Picks the new emulator device that serves the launched AVD.
+ *
+ * Silence is not a match: a device that did not answer is asked again, never adopted
+ * on the strength of being new.
+ *
+ * @param params - The launched AVD and the probed candidates.
+ * @returns The matching device, plus the ones ruled out and the ones still unknown.
+ */
+export declare function resolveLaunchedDevice(params: ResolveLaunchedDeviceParams): ResolveLaunchedDeviceResult;
+/**
+ * Splits the devices that were not online before the launch into emulators and everything else.
+ *
+ * @param params - The devices online now and before the launch.
+ * @returns The new devices, split.
+ */
+export declare function splitNewDevices(params: SplitNewDevicesParams): NewDeviceSplit;

package/dist/lib/cjs/library.cjs

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