obsidian-integration-testing 12.1.0 → 12.1.1

package/dist/lib/esm/device-settings-command.d.mts

@@ -0,0 +1,76 @@
+/**
+ * @file
+ *
+ * Builds the `adb shell settings …` argument list.
+ *
+ * Split out of {@link ./device-settings.ts} for the same reason
+ * {@link ./adb-device-list.ts} is split out of the transport factory: the
+ * argument list is pure and worth unit-testing, while the call that runs it is
+ * integration-time code that a unit test cannot reach. Keeping them in one file
+ * would put the namespace default inside a coverage-ignored block, where nothing
+ * checks that it is what the documentation claims.
+ */
+/**
+ * The `settings` namespaces this helper addresses.
+ */
+export declare enum DeviceSettingNamespace {
+    /**
+     * Device-wide settings, e.g. `hide_error_dialogs`.
+     */
+    Global = "global",
+    /**
+     * Per-user settings the system reads, e.g. `show_ime_with_hard_keyboard`.
+     */
+    Secure = "secure",
+    /**
+     * Per-user settings apps may read, e.g. `screen_brightness`.
+     */
+    System = "system"
+}
+/**
+ * The `settings` sub-commands this helper issues.
+ */
+export declare enum DeviceSettingVerb {
+    /**
+     * Removes the setting, returning it to never-having-been-written.
+     */
+    Delete = "delete",
+    /**
+     * Reads the setting, printing `null` when it has never been written.
+     */
+    Get = "get",
+    /**
+     * Writes the setting.
+     */
+    Put = "put"
+}
+/**
+ * Parameters for {@link buildDeviceSettingsCommandArguments}.
+ */
+export interface BuildDeviceSettingsCommandArgumentsParams {
+    /**
+     * The setting's name within {@link namespace}, e.g. `show_ime_with_hard_keyboard`.
+     */
+    readonly name: string;
+    /**
+     * The settings namespace the name lives in.
+     *
+     * @default {@link DeviceSettingNamespace.Secure}
+     */
+    readonly namespace?: DeviceSettingNamespace;
+    /**
+     * The value to write. Meaningful only for {@link DeviceSettingVerb.Put}.
+     */
+    readonly value?: string;
+    /**
+     * The sub-command to issue.
+     */
+    readonly verb: DeviceSettingVerb;
+}
+/**
+ * Builds the arguments for `adb shell settings <verb> <namespace> <name> [value]`.
+ *
+ * @param params - The sub-command, the setting, its namespace and — for a write — its value.
+ * @returns The arguments to hand to `runAdbText`, `shell` included.
+ */
+export declare function buildDeviceSettingsCommandArguments(params: BuildDeviceSettingsCommandArgumentsParams): string[];

package/dist/lib/esm/device-settings-command.mjs

@@ -0,0 +1,23 @@
+var DeviceSettingNamespace = /* @__PURE__ */ ((DeviceSettingNamespace2) => {
+  DeviceSettingNamespace2["Global"] = "global";
+  DeviceSettingNamespace2["Secure"] = "secure";
+  DeviceSettingNamespace2["System"] = "system";
+  return DeviceSettingNamespace2;
+})(DeviceSettingNamespace || {});
+var DeviceSettingVerb = /* @__PURE__ */ ((DeviceSettingVerb2) => {
+  DeviceSettingVerb2["Delete"] = "delete";
+  DeviceSettingVerb2["Get"] = "get";
+  DeviceSettingVerb2["Put"] = "put";
+  return DeviceSettingVerb2;
+})(DeviceSettingVerb || {});
+function buildDeviceSettingsCommandArguments(params) {
+  const namespace = params.namespace ?? "secure" /* Secure */;
+  const value = params.verb === "put" /* Put */ && params.value !== void 0 ? [params.value] : [];
+  return ["shell", "settings", params.verb, namespace, params.name, ...value];
+}
+export {
+  DeviceSettingNamespace,
+  DeviceSettingVerb,
+  buildDeviceSettingsCommandArguments
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/device-settings.d.mts

@@ -0,0 +1,94 @@
+/**
+ * @file
+ *
+ * Reads and writes Android device settings — and wraps the one setting a
+ * screenshot suite has to change.
+ *
+ * The screenshot AVDs are built `hw.keyboard=yes`, so Android suppresses the
+ * on-screen keyboard even where the page asks for one. `show_ime_with_hard_keyboard`
+ * is what turns it back on. {@link withSoftKeyboardEnabled} flips it, runs the
+ * work, and puts the device back exactly as it found it — including restoring a
+ * setting that had never been written, which takes a delete rather than a write
+ * (see `device-setting-restore`).
+ *
+ * Every function here shells out, so the whole module is integration-time code;
+ * the restore decision and the argument list it depends on are unit-tested in
+ * their own modules.
+ */
+import type { DeviceSettingNamespace } from './device-settings-command.mjs';
+/**
+ * Parameters for {@link deleteDeviceSetting} and {@link readDeviceSetting}.
+ */
+export interface DeviceSettingParams {
+    /**
+     * The device to address.
+     */
+    readonly deviceId: string;
+    /**
+     * The setting's name within {@link namespace}, e.g. `show_ime_with_hard_keyboard`.
+     */
+    readonly name: string;
+    /**
+     * The settings namespace the name lives in.
+     *
+     * @default {@link DeviceSettingNamespace.Secure}
+     */
+    readonly namespace?: DeviceSettingNamespace;
+}
+/**
+ * Parameters for {@link withSoftKeyboardEnabled}.
+ *
+ * @typeParam T - What the wrapped work returns.
+ */
+export interface WithSoftKeyboardEnabledParams<T> {
+    /**
+     * The work to run while the on-screen keyboard is permitted.
+     */
+    readonly callback: (this: void) => Promise<T>;
+    /**
+     * The device to address.
+     */
+    readonly deviceId: string;
+}
+/**
+ * Parameters for {@link writeDeviceSetting}.
+ */
+export interface WriteDeviceSettingParams extends DeviceSettingParams {
+    /**
+     * The value to write.
+     */
+    readonly value: string;
+}
+/**
+ * Clears a device setting, returning it to never-having-been-written.
+ *
+ * @param params - The device, the setting and its namespace.
+ * @returns A {@link Promise} that resolves once the setting is gone.
+ */
+export declare function deleteDeviceSetting(params: DeviceSettingParams): Promise<void>;
+/**
+ * Reads a device setting.
+ *
+ * @param params - The device, the setting and its namespace.
+ * @returns A {@link Promise} that resolves to the setting's value, or the literal `null` when it has never
+ *   been written.
+ */
+export declare function readDeviceSetting(params: DeviceSettingParams): Promise<string>;
+/**
+ * Permits the on-screen keyboard for the duration of a callback, then restores the device exactly.
+ *
+ * The restore runs whether the callback succeeded or threw — a suite that dies mid-capture must not leave
+ * the device configured differently than it found it.
+ *
+ * @typeParam T - What the wrapped work returns.
+ * @param params - The device and the work to run.
+ * @returns A {@link Promise} that resolves to whatever the callback returned.
+ */
+export declare function withSoftKeyboardEnabled<T>(params: WithSoftKeyboardEnabledParams<T>): Promise<T>;
+/**
+ * Writes a device setting.
+ *
+ * @param params - The device, the setting, its namespace and the value to write.
+ * @returns A {@link Promise} that resolves once the setting is written.
+ */
+export declare function writeDeviceSetting(params: WriteDeviceSettingParams): Promise<void>;

package/dist/lib/esm/device-settings.mjs

@@ -0,0 +1,67 @@
+import { runAdbText } from "./adb.mjs";
+import {
+  DeviceSettingRestoreKind,
+  resolveDeviceSettingRestore
+} from "./device-setting-restore.mjs";
+import {
+  buildDeviceSettingsCommandArguments,
+  DeviceSettingVerb
+} from "./device-settings-command.mjs";
+const SOFT_KEYBOARD_SETTING_NAME = "show_ime_with_hard_keyboard";
+const SOFT_KEYBOARD_SETTING_ON = "1";
+async function deleteDeviceSetting(params) {
+  await runAdbText({
+    commandArguments: buildDeviceSettingsCommandArguments({
+      name: params.name,
+      ...params.namespace !== void 0 && { namespace: params.namespace },
+      verb: DeviceSettingVerb.Delete
+    }),
+    deviceId: params.deviceId
+  });
+}
+async function readDeviceSetting(params) {
+  return await runAdbText({
+    commandArguments: buildDeviceSettingsCommandArguments({
+      name: params.name,
+      ...params.namespace !== void 0 && { namespace: params.namespace },
+      verb: DeviceSettingVerb.Get
+    }),
+    deviceId: params.deviceId
+  });
+}
+async function withSoftKeyboardEnabled(params) {
+  const settingParams = {
+    deviceId: params.deviceId,
+    name: SOFT_KEYBOARD_SETTING_NAME
+  };
+  const previousValue = await readDeviceSetting(settingParams);
+  await writeDeviceSetting({ ...settingParams, value: SOFT_KEYBOARD_SETTING_ON });
+  try {
+    return await params.callback();
+  } finally {
+    const restore = resolveDeviceSettingRestore(previousValue);
+    if (restore.kind === DeviceSettingRestoreKind.Delete) {
+      await deleteDeviceSetting(settingParams);
+    } else {
+      await writeDeviceSetting({ ...settingParams, value: restore.value });
+    }
+  }
+}
+async function writeDeviceSetting(params) {
+  await runAdbText({
+    commandArguments: buildDeviceSettingsCommandArguments({
+      name: params.name,
+      ...params.namespace !== void 0 && { namespace: params.namespace },
+      value: params.value,
+      verb: DeviceSettingVerb.Put
+    }),
+    deviceId: params.deviceId
+  });
+}
+export {
+  deleteDeviceSetting,
+  readDeviceSetting,
+  withSoftKeyboardEnabled,
+  writeDeviceSetting
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/device-settings.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Reads and writes Android device settings \u2014 and wraps the one setting a\n * screenshot suite has to change.\n *\n * The screenshot AVDs are built `hw.keyboard=yes`, so Android suppresses the\n * on-screen keyboard even where the page asks for one. `show_ime_with_hard_keyboard`\n * is what turns it back on. {@link withSoftKeyboardEnabled} flips it, runs the\n * work, and puts the device back exactly as it found it \u2014 including restoring a\n * setting that had never been written, which takes a delete rather than a write\n * (see `device-setting-restore`).\n *\n * Every function here shells out, so the whole module is integration-time code;\n * the restore decision and the argument list it depends on are unit-tested in\n * their own modules.\n */\n\n/* v8 ignore start -- Integration-time code (shells out to a real device) covered by integration tests, not unit tests. */\n\nimport type { DeviceSettingNamespace } from './device-settings-command.mjs';\n\nimport { runAdbText } from './adb.mjs';\nimport {\n  DeviceSettingRestoreKind,\n  resolveDeviceSettingRestore\n} from './device-setting-restore.mjs';\nimport {\n  buildDeviceSettingsCommandArguments,\n  DeviceSettingVerb\n} from './device-settings-command.mjs';\n\n/**\n * Parameters for {@link deleteDeviceSetting} and {@link readDeviceSetting}.\n */\nexport interface DeviceSettingParams {\n  /**\n   * The device to address.\n   */\n  readonly deviceId: string;\n\n  /**\n   * The setting's name within {@link namespace}, e.g. `show_ime_with_hard_keyboard`.\n   */\n  readonly name: string;\n\n  /**\n   * The settings namespace the name lives in.\n   *\n   * @default {@link DeviceSettingNamespace.Secure}\n   */\n  readonly namespace?: DeviceSettingNamespace;\n}\n\n/**\n * Parameters for {@link withSoftKeyboardEnabled}.\n *\n * @typeParam T - What the wrapped work returns.\n */\nexport interface WithSoftKeyboardEnabledParams<T> {\n  /**\n   * The work to run while the on-screen keyboard is permitted.\n   */\n  readonly callback: (this: void) => Promise<T>;\n\n  /**\n   * The device to address.\n   */\n  readonly deviceId: string;\n}\n\n/**\n * Parameters for {@link writeDeviceSetting}.\n */\nexport interface WriteDeviceSettingParams extends DeviceSettingParams {\n  /**\n   * The value to write.\n   */\n  readonly value: string;\n}\n\n/**\n * The setting deciding whether Android draws a keyboard while a hardware one is attached.\n */\nconst SOFT_KEYBOARD_SETTING_NAME = 'show_ime_with_hard_keyboard';\n\nconst SOFT_KEYBOARD_SETTING_ON = '1';\n\n/**\n * Clears a device setting, returning it to never-having-been-written.\n *\n * @param params - The device, the setting and its namespace.\n * @returns A {@link Promise} that resolves once the setting is gone.\n */\nexport async function deleteDeviceSetting(params: DeviceSettingParams): Promise<void> {\n  await runAdbText({\n    commandArguments: buildDeviceSettingsCommandArguments({\n      name: params.name,\n      ...(params.namespace !== undefined && { namespace: params.namespace }),\n      verb: DeviceSettingVerb.Delete\n    }),\n    deviceId: params.deviceId\n  });\n}\n\n/**\n * Reads a device setting.\n *\n * @param params - The device, the setting and its namespace.\n * @returns A {@link Promise} that resolves to the setting's value, or the literal `null` when it has never\n *   been written.\n */\nexport async function readDeviceSetting(params: DeviceSettingParams): Promise<string> {\n  return await runAdbText({\n    commandArguments: buildDeviceSettingsCommandArguments({\n      name: params.name,\n      ...(params.namespace !== undefined && { namespace: params.namespace }),\n      verb: DeviceSettingVerb.Get\n    }),\n    deviceId: params.deviceId\n  });\n}\n\n/**\n * Permits the on-screen keyboard for the duration of a callback, then restores the device exactly.\n *\n * The restore runs whether the callback succeeded or threw \u2014 a suite that dies mid-capture must not leave\n * the device configured differently than it found it.\n *\n * @typeParam T - What the wrapped work returns.\n * @param params - The device and the work to run.\n * @returns A {@link Promise} that resolves to whatever the callback returned.\n */\nexport async function withSoftKeyboardEnabled<T>(params: WithSoftKeyboardEnabledParams<T>): Promise<T> {\n  const settingParams: DeviceSettingParams = {\n    deviceId: params.deviceId,\n    name: SOFT_KEYBOARD_SETTING_NAME\n  };\n\n  const previousValue = await readDeviceSetting(settingParams);\n  await writeDeviceSetting({ ...settingParams, value: SOFT_KEYBOARD_SETTING_ON });\n\n  try {\n    return await params.callback();\n  } finally {\n    const restore = resolveDeviceSettingRestore(previousValue);\n    if (restore.kind === DeviceSettingRestoreKind.Delete) {\n      await deleteDeviceSetting(settingParams);\n    } else {\n      await writeDeviceSetting({ ...settingParams, value: restore.value });\n    }\n  }\n}\n\n/**\n * Writes a device setting.\n *\n * @param params - The device, the setting, its namespace and the value to write.\n * @returns A {@link Promise} that resolves once the setting is written.\n */\nexport async function writeDeviceSetting(params: WriteDeviceSettingParams): Promise<void> {\n  await runAdbText({\n    commandArguments: buildDeviceSettingsCommandArguments({\n      name: params.name,\n      ...(params.namespace !== undefined && { namespace: params.namespace }),\n      value: params.value,\n      verb: DeviceSettingVerb.Put\n    }),\n    deviceId: params.deviceId\n  });\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AAsBA,SAAS,kBAAkB;AAC3B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAsDP,MAAM,6BAA6B;AAEnC,MAAM,2BAA2B;AAQjC,eAAsB,oBAAoB,QAA4C;AACpF,QAAM,WAAW;AAAA,IACf,kBAAkB,oCAAoC;AAAA,MACpD,MAAM,OAAO;AAAA,MACb,GAAI,OAAO,cAAc,UAAa,EAAE,WAAW,OAAO,UAAU;AAAA,MACpE,MAAM,kBAAkB;AAAA,IAC1B,CAAC;AAAA,IACD,UAAU,OAAO;AAAA,EACnB,CAAC;AACH;AASA,eAAsB,kBAAkB,QAA8C;AACpF,SAAO,MAAM,WAAW;AAAA,IACtB,kBAAkB,oCAAoC;AAAA,MACpD,MAAM,OAAO;AAAA,MACb,GAAI,OAAO,cAAc,UAAa,EAAE,WAAW,OAAO,UAAU;AAAA,MACpE,MAAM,kBAAkB;AAAA,IAC1B,CAAC;AAAA,IACD,UAAU,OAAO;AAAA,EACnB,CAAC;AACH;AAYA,eAAsB,wBAA2B,QAAsD;AACrG,QAAM,gBAAqC;AAAA,IACzC,UAAU,OAAO;AAAA,IACjB,MAAM;AAAA,EACR;AAEA,QAAM,gBAAgB,MAAM,kBAAkB,aAAa;AAC3D,QAAM,mBAAmB,EAAE,GAAG,eAAe,OAAO,yBAAyB,CAAC;AAE9E,MAAI;AACF,WAAO,MAAM,OAAO,SAAS;AAAA,EAC/B,UAAE;AACA,UAAM,UAAU,4BAA4B,aAAa;AACzD,QAAI,QAAQ,SAAS,yBAAyB,QAAQ;AACpD,YAAM,oBAAoB,aAAa;AAAA,IACzC,OAAO;AACL,YAAM,mBAAmB,EAAE,GAAG,eAAe,OAAO,QAAQ,MAAM,CAAC;AAAA,IACrE;AAAA,EACF;AACF;AAQA,eAAsB,mBAAmB,QAAiD;AACxF,QAAM,WAAW;AAAA,IACf,kBAAkB,oCAAoC;AAAA,MACpD,MAAM,OAAO;AAAA,MACb,GAAI,OAAO,cAAc,UAAa,EAAE,WAAW,OAAO,UAAU;AAAA,MACpE,OAAO,OAAO;AAAA,MACd,MAAM,kBAAkB;AAAA,IAC1B,CAAC;AAAA,IACD,UAAU,OAAO;AAAA,EACnB,CAAC;AACH;",
  "names": []
}


package/dist/lib/esm/emulator-device-id.d.mts

@@ -0,0 +1,49 @@
+/**
+ * @file
+ *
+ * Picks the running emulator that belongs to a named AVD.
+ *
+ * A capture suite must never take "the first device `adb devices` lists". Two
+ * things routinely make that the wrong device on this fleet: a physical phone is
+ * often plugged into the same machine, and the harness's own `obsidian_test` AVD
+ * runs at a different geometry than the `obsidian_screenshots` AVD sized to the
+ * store's frame. Picking by position silently photographs the wrong screen at
+ * the wrong size, and the dimension assertion that would have caught it fires
+ * several minutes later, after the run.
+ *
+ * Pure and unit-tested; the `adb` round-trips that gather the AVD names live in
+ * `resolve-emulator-device-id`.
+ */
+/**
+ * One running emulator, paired with the AVD it was started from.
+ */
+export interface EmulatorDeviceCandidate {
+    /**
+     * The AVD name the emulator reports, e.g. `obsidian_screenshots`.
+     */
+    readonly avdName: string;
+    /**
+     * The device UDID, e.g. `emulator-5554`.
+     */
+    readonly deviceId: string;
+}
+/**
+ * Parameters for {@link selectEmulatorDeviceId}.
+ */
+export interface SelectEmulatorDeviceIdParams {
+    /**
+     * The AVD name to match.
+     */
+    readonly avdName: string;
+    /**
+     * Every running emulator, with the AVD each was started from.
+     */
+    readonly candidates: readonly EmulatorDeviceCandidate[];
+}
+/**
+ * Picks the emulator started from a named AVD.
+ *
+ * @param params - The AVD to match and the running emulators to match against.
+ * @returns The matching device UDID, or `null` when no running emulator carries that AVD name.
+ */
+export declare function selectEmulatorDeviceId(params: SelectEmulatorDeviceIdParams): null | string;

package/dist/lib/esm/emulator-device-id.mjs

@@ -0,0 +1,8 @@
+function selectEmulatorDeviceId(params) {
+  const match = params.candidates.find((candidate) => candidate.avdName === params.avdName);
+  return match ? match.deviceId : null;
+}
+export {
+  selectEmulatorDeviceId
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -3,6 +3,8 @@
  *
  * Contains the entry point for the integration testing module.
  */
+export type { RunAdbParams } from './adb.mjs';
+export { runAdbBinary, runAdbText, runAdbTextWithoutDevice } from './adb.mjs';
 export type { AsarFallback, AsarFallbackTier, ResolveAsarFallbackParams } from './asar-fallback-detection.mjs';
 export { resolveAsarFallback } from './asar-fallback-detection.mjs';
 export type { CaptureObsidianScreenshotOptions } from './capture-obsidian-screenshot.mjs';
@@ -25,8 +27,18 @@ export { buildDemoVaultPopulate, resolveMissingInjectedPlugins } from './demo-va
 export type { ReadDemoVaultTreeParams } from './demo-vault-tree.mjs';
 export { readDemoVaultTree } from './demo-vault-tree.mjs';
 export { DesktopOnlyPluginSkipError } from './desktop-only-plugin-skip-error.mjs';
+export type { CaptureDeviceScreenshotParams } from './device-screenshot.mjs';
+export { captureDeviceScreenshot } from './device-screenshot.mjs';
+export type { DeviceSettingRestore, DeviceSettingRestoreDelete, DeviceSettingRestoreWrite } from './device-setting-restore.mjs';
+export { DeviceSettingRestoreKind, resolveDeviceSettingRestore } from './device-setting-restore.mjs';
+export type { BuildDeviceSettingsCommandArgumentsParams } from './device-settings-command.mjs';
+export { buildDeviceSettingsCommandArguments, DeviceSettingNamespace, DeviceSettingVerb } from './device-settings-command.mjs';
+export type { DeviceSettingParams, WithSoftKeyboardEnabledParams, WriteDeviceSettingParams } from './device-settings.mjs';
+export { deleteDeviceSetting, readDeviceSetting, withSoftKeyboardEnabled, writeDeviceSetting } from './device-settings.mjs';
 export type { ElectronCompatibility, ElectronCompatibilityTier, ResolveElectronCompatibilityParams } from './electron-compatibility.mjs';
 export { resolveElectronCompatibility } from './electron-compatibility.mjs';
+export type { EmulatorDeviceCandidate, SelectEmulatorDeviceIdParams } from './emulator-device-id.mjs';
+export { selectEmulatorDeviceId } from './emulator-device-id.mjs';
 export type { ClickElementParams, ClickMouseParams, CommonArguments, CreateNoteParams, EvalInObsidianParams, GenericObject, HoverElementParams, Lib, MouseButton, MoveMouseParams, OpenSettingsTabParams, PressKeyParams, TypeIntoEditorParams, UnhoverElementParams, WaitUntilParams } from './eval-in-obsidian.mjs';
 export { evalInObsidian } from './eval-in-obsidian.mjs';
 export type { ComputeFitToCanvasParams, FitScreenshotToCanvasOptions, FitToCanvasGeometry } from './fit-screenshot.mjs';
@@ -51,10 +63,16 @@ export { OwnedInstanceExitedError } from './owned-instance-exited-error.mjs';
 export type { PollInObsidianParams } from './poll-in-obsidian.mjs';
 export { pollInObsidian } from './poll-in-obsidian.mjs';
 export { RendererFailedToInitializeError } from './renderer-failed-to-initialize-error.mjs';
+export type { ResolveEmulatorDeviceIdParams } from './resolve-emulator-device-id.mjs';
+export { resolveEmulatorDeviceId } from './resolve-emulator-device-id.mjs';
 export type { RunObsidianVersionMatrixParams } from './run-version-matrix.mjs';
 export { runObsidianVersionMatrix } from './run-version-matrix.mjs';
 export type { SilentAsarFallbackErrorConstructorParams } from './silent-asar-fallback-error.mjs';
 export { SilentAsarFallbackError } from './silent-asar-fallback-error.mjs';
+export type { BuildSoftKeyboardDiagnosticMessageParams, CheckIsSoftKeyboardUpParams, ElementRect, ResolveSoftKeyboardTapPointsParams, SoftKeyboardTapPoint, SoftKeyboardViewportSnapshot } from './soft-keyboard-geometry.mjs';
+export { buildSoftKeyboardDiagnosticMessage, checkIsSoftKeyboardUp, DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS, parseInputMethodState, resolveSoftKeyboardTapPoints } from './soft-keyboard-geometry.mjs';
+export type { RaiseSoftKeyboardParams, TapDeviceParams } from './soft-keyboard.mjs';
+export { raiseSoftKeyboard, tapDevice } from './soft-keyboard.mjs';
 export type { PopulateFileContent, PopulateFilesParams, TemporaryVaultOptions } from './temporary-vault.mjs';
 export { TemporaryVault } from './temporary-vault.mjs';
 export type { AppiumSessionInfo, AppiumTransportConfig } from './transport-appium.mjs';

package/dist/lib/esm/index.mjs

@@ -1,3 +1,8 @@
+import {
+  runAdbBinary,
+  runAdbText,
+  runAdbTextWithoutDevice
+} from "./adb.mjs";
 import { resolveAsarFallback } from "./asar-fallback-detection.mjs";
 import { captureObsidianScreenshot } from "./capture-obsidian-screenshot.mjs";
 import {
@@ -28,7 +33,24 @@ import {
 } from "./demo-vault-populate.mjs";
 import { readDemoVaultTree } from "./demo-vault-tree.mjs";
 import { DesktopOnlyPluginSkipError } from "./desktop-only-plugin-skip-error.mjs";
+import { captureDeviceScreenshot } from "./device-screenshot.mjs";
+import {
+  DeviceSettingRestoreKind,
+  resolveDeviceSettingRestore
+} from "./device-setting-restore.mjs";
+import {
+  buildDeviceSettingsCommandArguments,
+  DeviceSettingNamespace,
+  DeviceSettingVerb
+} from "./device-settings-command.mjs";
+import {
+  deleteDeviceSetting,
+  readDeviceSetting,
+  withSoftKeyboardEnabled,
+  writeDeviceSetting
+} from "./device-settings.mjs";
 import { resolveElectronCompatibility } from "./electron-compatibility.mjs";
+import { selectEmulatorDeviceId } from "./emulator-device-id.mjs";
 import { evalInObsidian } from "./eval-in-obsidian.mjs";
 import {
   computeFitToCanvas,
@@ -53,8 +75,20 @@ 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 { resolveEmulatorDeviceId } from "./resolve-emulator-device-id.mjs";
 import { runObsidianVersionMatrix } from "./run-version-matrix.mjs";
 import { SilentAsarFallbackError } from "./silent-asar-fallback-error.mjs";
+import {
+  buildSoftKeyboardDiagnosticMessage,
+  checkIsSoftKeyboardUp,
+  DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,
+  parseInputMethodState,
+  resolveSoftKeyboardTapPoints
+} from "./soft-keyboard-geometry.mjs";
+import {
+  raiseSoftKeyboard,
+  tapDevice
+} from "./soft-keyboard.mjs";
 import { TemporaryVault } from "./temporary-vault.mjs";
 import { AppiumTransport } from "./transport-appium.mjs";
 import { DesktopCdpTransport } from "./transport-desktop-cdp.mjs";
@@ -71,9 +105,13 @@ export {
   ConfigDirectoryFallbackError,
   ContextId,
   DEFAULT_CONFIG_DIRECTORY,
+  DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,
   DEFAULT_OBSIDIAN_VERSION_SPECS,
   DesktopCdpTransport,
   DesktopOnlyPluginSkipError,
+  DeviceSettingNamespace,
+  DeviceSettingRestoreKind,
+  DeviceSettingVerb,
   IncompatibleInstallerVersionError,
   IntegrationSetupFailedError,
   OwnedInstanceExitedError,
@@ -86,14 +124,19 @@ export {
   buildDemoVaultPopulate,
   buildDemoVaultPopulateAsync,
   buildDeviceMetricsOverride,
+  buildDeviceSettingsCommandArguments,
   buildLabelSvg,
+  buildSoftKeyboardDiagnosticMessage,
+  captureDeviceScreenshot,
   captureObsidianScreenshot,
   checkIsMobileTransport,
+  checkIsSoftKeyboardUp,
   computeFitToCanvas,
   computeLabelBand,
   connectToCdp,
   createTransportFromOptions,
   decodeBase64Png,
+  deleteDeviceSetting,
   escapeSvgText,
   evalInObsidian,
   fitScreenshotToCanvas,
@@ -101,19 +144,32 @@ export {
   isPng,
   labelScreenshot,
   openObsidianSettingsTab,
+  parseInputMethodState,
   pollInObsidian,
+  raiseSoftKeyboard,
   readDemoVaultTree,
+  readDeviceSetting,
   readPngDimensions,
   registerLibResolver,
   registerVault,
   resolveAsarFallback,
+  resolveDeviceSettingRestore,
   resolveElectronCompatibility,
+  resolveEmulatorDeviceId,
   resolveInstallerCompatibility,
   resolveMissingInjectedPlugins,
+  resolveSoftKeyboardTapPoints,
+  runAdbBinary,
+  runAdbText,
+  runAdbTextWithoutDevice,
   runObsidianVersionMatrix,
+  selectEmulatorDeviceId,
   setSetupErrorResolver,
   setTransportOptionsResolver,
   setVaultPathResolver,
-  unregisterVault
+  tapDevice,
+  unregisterVault,
+  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 {\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": []
}

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


package/dist/lib/esm/library.mjs

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

package/dist/lib/esm/resolve-emulator-device-id.d.mts

@@ -0,0 +1,28 @@
+/**
+ * @file
+ *
+ * Asks the running emulators which AVD each was started from, and resolves one
+ * by name through {@link ./emulator-device-id.ts}'s selection.
+ *
+ * Every function here shells out, so the whole module is integration-time code
+ * — which is exactly why the selection it delegates to lives in its own module
+ * and stays unit-tested.
+ */
+/**
+ * Parameters for {@link resolveEmulatorDeviceId}.
+ */
+export interface ResolveEmulatorDeviceIdParams {
+    /**
+     * The AVD name to match, e.g. `obsidian_screenshots`.
+     */
+    readonly avdName: string;
+}
+/**
+ * Finds the running emulator whose AVD is the named one.
+ *
+ * @param params - The AVD to match.
+ * @returns A {@link Promise} that resolves to the device UDID to address it by.
+ * @throws Error if no running emulator was started from that AVD. The message lists what IS running, since
+ *   "the wrong emulator is up" and "no emulator is up" need different answers.
+ */
+export declare function resolveEmulatorDeviceId(params: ResolveEmulatorDeviceIdParams): Promise<string>;

package/dist/lib/esm/resolve-emulator-device-id.mjs

@@ -0,0 +1,33 @@
+import { listOnlineDeviceIds } from "./adb-device-list.mjs";
+import {
+  runAdbText,
+  runAdbTextWithoutDevice
+} from "./adb.mjs";
+import { selectEmulatorDeviceId } from "./emulator-device-id.mjs";
+const EMULATOR_DEVICE_ID_PREFIX = "emulator-";
+async function resolveEmulatorDeviceId(params) {
+  const candidates = await listEmulatorDeviceCandidates();
+  const deviceId = selectEmulatorDeviceId({ avdName: params.avdName, candidates });
+  if (!deviceId) {
+    const listed = candidates.map((candidate) => `${candidate.deviceId} (${candidate.avdName})`).join(", ") || "none";
+    throw new Error(
+      `resolveEmulatorDeviceId: no running emulator for AVD "${params.avdName}". Running emulators: ${listed}. Start it, or run this project once to have the harness start it.`
+    );
+  }
+  return deviceId;
+}
+async function listEmulatorDeviceCandidates() {
+  const devicesOutput = await runAdbTextWithoutDevice(["devices"]);
+  const deviceIds = listOnlineDeviceIds(devicesOutput).filter((deviceId) => deviceId.startsWith(EMULATOR_DEVICE_ID_PREFIX));
+  const candidates = [];
+  for (const deviceId of deviceIds) {
+    const output = await runAdbText({ commandArguments: ["emu", "avd", "name"], deviceId });
+    const avdName = output.split("\n", 1)[0]?.trim() ?? "";
+    candidates.push({ avdName, deviceId });
+  }
+  return candidates;
+}
+export {
+  resolveEmulatorDeviceId
+};
+//# sourceMappingURL=data:application/json;base64,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