obsidian-integration-testing 12.0.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-arguments.d.mts

@@ -2,6 +2,24 @@
  * @file
  *
  * Builds the argument list for spawning the Android emulator.
+ *
+ * **The harness owns the snapshot it loads, or it loads none.** This file used
+ * to pass `-no-snapshot-save` alone — the one combination that is never
+ * correct. It never *writes* `default_boot`, yet every run *resumed* it, so the
+ * guest each run started from was state nothing had validated since whenever a
+ * human last saved it. Measured 2026-09-03, same AVD back to back:
+ *
+ * | Launch | Result |
+ * | --- | --- |
+ * | snapshot resumed (`-no-snapshot-save` alone) | guest dies ~90s in, every time |
+ * | `-no-snapshot-load` (cold) | booted in 50s, alive at 60/120/180/240s |
+ *
+ * A resumed snapshot rots silently, and the failure it eventually produces —
+ * a device that serves adb, accepts a session and then drops `offline` a
+ * half-minute later — is indistinguishable from a code regression. So the
+ * default is a full cold boot, and snapshot reuse is an explicit opt-in that
+ * takes **both** halves: load and save together, so the snapshot the next run
+ * resumes is one this run wrote.
  */
 /**
  * Parameters for {@link buildEmulatorArguments}.
@@ -16,6 +34,14 @@ export interface BuildEmulatorArgumentsParams {
      * focus. Resolved from the `isEmulatorVisible` transport option.
      */
     readonly isHidden: boolean;
+    /**
+     * Whether the emulator may resume — and refresh — the AVD's saved boot
+     * snapshot. Resolved from the `shouldReuseEmulatorSnapshot` transport option.
+     *
+     * `false` (the default) cold-boots hermetically. `true` buys back the ~112s
+     * boot on a persistent runner, at the cost of test isolation.
+     */
+    readonly shouldReuseSnapshot: boolean;
 }
 /**
  * Builds the argument list for spawning the Android emulator.

package/dist/lib/esm/emulator-arguments.mjs

@@ -1,6 +1,10 @@
 const DNS_SERVER = "8.8.8.8";
 function buildEmulatorArguments(params) {
-  const emulatorArguments = ["-avd", params.avdName, "-no-snapshot-save", "-dns-server", DNS_SERVER];
+  const emulatorArguments = ["-avd", params.avdName];
+  if (!params.shouldReuseSnapshot) {
+    emulatorArguments.push("-no-snapshot-load", "-no-snapshot-save");
+  }
+  emulatorArguments.push("-dns-server", DNS_SERVER);
   if (params.isHidden) {
     emulatorArguments.push("-no-window");
   }
@@ -9,4 +13,4 @@ function buildEmulatorArguments(params) {
 export {
   buildEmulatorArguments
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2VtdWxhdG9yLWFyZ3VtZW50cy50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIEJ1aWxkcyB0aGUgYXJndW1lbnQgbGlzdCBmb3Igc3Bhd25pbmcgdGhlIEFuZHJvaWQgZW11bGF0b3IuXG4gKi9cblxuY29uc3QgRE5TX1NFUlZFUiA9ICc4LjguOC44JztcblxuLyoqXG4gKiBQYXJhbWV0ZXJzIGZvciB7QGxpbmsgYnVpbGRFbXVsYXRvckFyZ3VtZW50c30uXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQnVpbGRFbXVsYXRvckFyZ3VtZW50c1BhcmFtcyB7XG4gIC8qKlxuICBUaGUgQW5kcm9pZCBWaXJ0dWFsIERldmljZSBuYW1lLlxuICAgKi9cbiAgcmVhZG9ubHkgYXZkTmFtZTogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBXaGV0aGVyIHRvIHJ1biB0aGUgZW11bGF0b3IgaGVhZGxlc3MgKGAtbm8td2luZG93YCksIHNvIGl0IG5ldmVyIHN0ZWFsc1xuICAgKiBmb2N1cy4gUmVzb2x2ZWQgZnJvbSB0aGUgYGlzRW11bGF0b3JWaXNpYmxlYCB0cmFuc3BvcnQgb3B0aW9uLlxuICAgKi9cbiAgcmVhZG9ubHkgaXNIaWRkZW46IGJvb2xlYW47XG59XG5cbi8qKlxuICogQnVpbGRzIHRoZSBhcmd1bWVudCBsaXN0IGZvciBzcGF3bmluZyB0aGUgQW5kcm9pZCBlbXVsYXRvci5cbiAqXG4gKiBAcGFyYW0gcGFyYW1zIC0gVGhlIGVtdWxhdG9yIGFyZ3VtZW50IHBhcmFtZXRlcnMuXG4gKiBAcmV0dXJucyBUaGUgYXJndW1lbnQgYXJyYXkgdG8gcGFzcyB0byB0aGUgZW11bGF0b3IgYmluYXJ5LlxuICovXG5leHBvcnQgZnVuY3Rpb24gYnVpbGRFbXVsYXRvckFyZ3VtZW50cyhwYXJhbXM6IEJ1aWxkRW11bGF0b3JBcmd1bWVudHNQYXJhbXMpOiBzdHJpbmdbXSB7XG4gIGNvbnN0IGVtdWxhdG9yQXJndW1lbnRzID0gWyctYXZkJywgcGFyYW1zLmF2ZE5hbWUsICctbm8tc25hcHNob3Qtc2F2ZScsICctZG5zLXNlcnZlcicsIEROU19TRVJWRVJdO1xuICBpZiAocGFyYW1zLmlzSGlkZGVuKSB7XG4gICAgZW11bGF0b3JBcmd1bWVudHMucHVzaCgnLW5vLXdpbmRvdycpO1xuICB9XG4gIHJldHVybiBlbXVsYXRvckFyZ3VtZW50cztcbn1cbiJdLAogICJtYXBwaW5ncyI6ICJBQU1BLE1BQU0sYUFBYTtBQXdCWixTQUFTLHVCQUF1QixRQUFnRDtBQUNyRixRQUFNLG9CQUFvQixDQUFDLFFBQVEsT0FBTyxTQUFTLHFCQUFxQixlQUFlLFVBQVU7QUFDakcsTUFBSSxPQUFPLFVBQVU7QUFDbkIsc0JBQWtCLEtBQUssWUFBWTtBQUFBLEVBQ3JDO0FBQ0EsU0FBTztBQUNUOyIsCiAgIm5hbWVzIjogW10KfQo=
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/emulator-backend.d.mts

@@ -0,0 +1,76 @@
+/**
+ * @file
+ *
+ * Pure helpers for finding the Android emulator process that **outlives the pid
+ * the harness killed**.
+ *
+ * Under `-no-window` the emulator's backend process is
+ * `qemu-system-x86_64-headless` (`qemu-system-x86_64` when windowed), not the
+ * `emulator` launcher the harness spawned and holds a `ChildProcess` for. The
+ * launcher exits or is killed, and the backend is what actually holds the AVD's
+ * `multiinstance.lock` and the console/adb ports — so `taskkill /F /T` against
+ * the launcher's pid reports success while the emulator keeps running. Every
+ * later run against that AVD then dies with `Running multiple emulators with the
+ * same AVD is an experimental feature`, which never reaches the user because the
+ * emulator writes it to its own stdout.
+ *
+ * Note that the obvious filter — `-Name qemu-system-x86_64` / matching that
+ * exact image name — does **not** match the `-headless` build, which is how the
+ * leftover stays invisible through several rounds of "no emulator is running".
+ *
+ * Ownership is decided by a **pre-launch snapshot**: a backend already running
+ * before this run started its own belongs to somebody else (another AVD, or one
+ * the user booted by hand) and is never touched. Kept separate from the
+ * integration-only `transport-factory` so the parsing and the selection stay
+ * unit-testable.
+ */
+/**
+ * One process from a host process listing.
+ */
+export interface ProcessListEntry {
+    /**
+    The process/image name, as the platform's listing reports it.
+     */
+    readonly name: string;
+    /**
+    The process ID.
+     */
+    readonly pid: number;
+}
+/**
+ * Parameters for {@link selectEmulatorBackendPids}.
+ */
+export interface SelectEmulatorBackendPidsParams {
+    /**
+    Emulator backend PIDs seen **before** this run launched its emulator, which it therefore does not own.
+     */
+    readonly knownPids: readonly number[];
+    /**
+    The host's current process listing.
+     */
+    readonly processes: readonly ProcessListEntry[];
+}
+/**
+ * Parses `ps -eo pid=,comm=` output.
+ *
+ * @param processListOutput - Raw stdout of the `ps` listing.
+ * @returns One entry per parsable row, in listed order.
+ */
+export declare function parsePosixProcessList(processListOutput: string): ProcessListEntry[];
+/**
+ * Parses `tasklist /FO CSV /NH` output.
+ *
+ * Only the first two fields are read — the image name and the PID — so the
+ * memory column's own commas cannot confuse the split.
+ *
+ * @param taskListOutput - Raw stdout of the `tasklist` listing.
+ * @returns One entry per parsable row, in listed order.
+ */
+export declare function parseWindowsTaskList(taskListOutput: string): ProcessListEntry[];
+/**
+ * Selects the emulator processes this run is responsible for killing.
+ *
+ * @param params - The current listing plus the PIDs that predate this run's emulator.
+ * @returns The PIDs of emulator processes this run owns, in listed order.
+ */
+export declare function selectEmulatorBackendPids(params: SelectEmulatorBackendPidsParams): number[];

package/dist/lib/esm/emulator-backend.mjs

@@ -0,0 +1,45 @@
+const EMULATOR_BACKEND_NAME_PATTERN = /^(?:emulator|emulator64-[\w.-]+|qemu-system-[\w.-]+)$/;
+const EXECUTABLE_SUFFIX_PATTERN = /\.exe$/;
+const RADIX_DECIMAL = 10;
+const TASK_LIST_FIELDS_READ = 2;
+function parsePosixProcessList(processListOutput) {
+  const entries = [];
+  for (const rawLine of processListOutput.split("\n")) {
+    const line = rawLine.trim();
+    const separatorIndex = line.indexOf(" ");
+    if (separatorIndex === -1) {
+      continue;
+    }
+    const pid = Number.parseInt(line.slice(0, separatorIndex), RADIX_DECIMAL);
+    if (Number.isNaN(pid)) {
+      continue;
+    }
+    entries.push({ name: line.slice(separatorIndex + 1).trim(), pid });
+  }
+  return entries;
+}
+function parseWindowsTaskList(taskListOutput) {
+  const entries = [];
+  for (const rawLine of taskListOutput.split("\n")) {
+    const [rawName = "", rawPid = ""] = rawLine.trim().replaceAll('"', "").split(",", TASK_LIST_FIELDS_READ);
+    const pid = Number.parseInt(rawPid, RADIX_DECIMAL);
+    if (rawName.length === 0 || Number.isNaN(pid)) {
+      continue;
+    }
+    entries.push({ name: rawName, pid });
+  }
+  return entries;
+}
+function selectEmulatorBackendPids(params) {
+  return params.processes.filter((entry) => checkIsEmulatorBackendName(entry.name) && !params.knownPids.includes(entry.pid)).map((entry) => entry.pid);
+}
+function checkIsEmulatorBackendName(name) {
+  const baseName = name.slice(Math.max(name.lastIndexOf("/"), name.lastIndexOf("\\")) + 1);
+  return EMULATOR_BACKEND_NAME_PATTERN.test(baseName.toLowerCase().replace(EXECUTABLE_SUFFIX_PATTERN, ""));
+}
+export {
+  parsePosixProcessList,
+  parseWindowsTaskList,
+  selectEmulatorBackendPids
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/emulator-backend.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure helpers for finding the Android emulator process that **outlives the pid\n * the harness killed**.\n *\n * Under `-no-window` the emulator's backend process is\n * `qemu-system-x86_64-headless` (`qemu-system-x86_64` when windowed), not the\n * `emulator` launcher the harness spawned and holds a `ChildProcess` for. The\n * launcher exits or is killed, and the backend is what actually holds the AVD's\n * `multiinstance.lock` and the console/adb ports \u2014 so `taskkill /F /T` against\n * the launcher's pid reports success while the emulator keeps running. Every\n * later run against that AVD then dies with `Running multiple emulators with the\n * same AVD is an experimental feature`, which never reaches the user because the\n * emulator writes it to its own stdout.\n *\n * Note that the obvious filter \u2014 `-Name qemu-system-x86_64` / matching that\n * exact image name \u2014 does **not** match the `-headless` build, which is how the\n * leftover stays invisible through several rounds of \"no emulator is running\".\n *\n * Ownership is decided by a **pre-launch snapshot**: a backend already running\n * before this run started its own belongs to somebody else (another AVD, or one\n * the user booted by hand) and is never touched. Kept separate from the\n * integration-only `transport-factory` so the parsing and the selection stay\n * unit-testable.\n */\n\n/**\n * One process from a host process listing.\n */\nexport interface ProcessListEntry {\n  /**\n  The process/image name, as the platform's listing reports it.\n   */\n  readonly name: string;\n\n  /**\n  The process ID.\n   */\n  readonly pid: number;\n}\n\n/**\n * Parameters for {@link selectEmulatorBackendPids}.\n */\nexport interface SelectEmulatorBackendPidsParams {\n  /**\n  Emulator backend PIDs seen **before** this run launched its emulator, which it therefore does not own.\n   */\n  readonly knownPids: readonly number[];\n\n  /**\n  The host's current process listing.\n   */\n  readonly processes: readonly ProcessListEntry[];\n}\n\n/**\n * Matches the emulator launcher and both QEMU backend builds \u2014 crucially\n * including the `-headless` suffix `-no-window` runs produce.\n */\nconst EMULATOR_BACKEND_NAME_PATTERN = /^(?:emulator|emulator64-[\\w.-]+|qemu-system-[\\w.-]+)$/;\nconst EXECUTABLE_SUFFIX_PATTERN = /\\.exe$/;\nconst RADIX_DECIMAL = 10;\n/**\n * Only the image name and the PID are read, so the split stops after them.\n */\nconst TASK_LIST_FIELDS_READ = 2;\n\n/**\n * Parses `ps -eo pid=,comm=` output.\n *\n * @param processListOutput - Raw stdout of the `ps` listing.\n * @returns One entry per parsable row, in listed order.\n */\nexport function parsePosixProcessList(processListOutput: string): ProcessListEntry[] {\n  const entries: ProcessListEntry[] = [];\n\n  for (const rawLine of processListOutput.split('\\n')) {\n    const line = rawLine.trim();\n    const separatorIndex = line.indexOf(' ');\n    if (separatorIndex === -1) {\n      continue;\n    }\n\n    const pid = Number.parseInt(line.slice(0, separatorIndex), RADIX_DECIMAL);\n    if (Number.isNaN(pid)) {\n      continue;\n    }\n\n    entries.push({ name: line.slice(separatorIndex + 1).trim(), pid });\n  }\n\n  return entries;\n}\n\n/**\n * Parses `tasklist /FO CSV /NH` output.\n *\n * Only the first two fields are read \u2014 the image name and the PID \u2014 so the\n * memory column's own commas cannot confuse the split.\n *\n * @param taskListOutput - Raw stdout of the `tasklist` listing.\n * @returns One entry per parsable row, in listed order.\n */\nexport function parseWindowsTaskList(taskListOutput: string): ProcessListEntry[] {\n  const entries: ProcessListEntry[] = [];\n\n  for (const rawLine of taskListOutput.split('\\n')) {\n    const [rawName = '', rawPid = ''] = rawLine.trim().replaceAll('\"', '').split(',', TASK_LIST_FIELDS_READ);\n    const pid = Number.parseInt(rawPid, RADIX_DECIMAL);\n    if (rawName.length === 0 || Number.isNaN(pid)) {\n      continue;\n    }\n\n    entries.push({ name: rawName, pid });\n  }\n\n  return entries;\n}\n\n/**\n * Selects the emulator processes this run is responsible for killing.\n *\n * @param params - The current listing plus the PIDs that predate this run's emulator.\n * @returns The PIDs of emulator processes this run owns, in listed order.\n */\nexport function selectEmulatorBackendPids(params: SelectEmulatorBackendPidsParams): number[] {\n  return params.processes\n    .filter((entry) => checkIsEmulatorBackendName(entry.name) && !params.knownPids.includes(entry.pid))\n    .map((entry) => entry.pid);\n}\n\nfunction checkIsEmulatorBackendName(name: string): boolean {\n  const baseName = name.slice(Math.max(name.lastIndexOf('/'), name.lastIndexOf('\\\\')) + 1);\n  return EMULATOR_BACKEND_NAME_PATTERN.test(baseName.toLowerCase().replace(EXECUTABLE_SUFFIX_PATTERN, ''));\n}\n"],
  "mappings": "AA6DA,MAAM,gCAAgC;AACtC,MAAM,4BAA4B;AAClC,MAAM,gBAAgB;AAItB,MAAM,wBAAwB;AAQvB,SAAS,sBAAsB,mBAA+C;AACnF,QAAM,UAA8B,CAAC;AAErC,aAAW,WAAW,kBAAkB,MAAM,IAAI,GAAG;AACnD,UAAM,OAAO,QAAQ,KAAK;AAC1B,UAAM,iBAAiB,KAAK,QAAQ,GAAG;AACvC,QAAI,mBAAmB,IAAI;AACzB;AAAA,IACF;AAEA,UAAM,MAAM,OAAO,SAAS,KAAK,MAAM,GAAG,cAAc,GAAG,aAAa;AACxE,QAAI,OAAO,MAAM,GAAG,GAAG;AACrB;AAAA,IACF;AAEA,YAAQ,KAAK,EAAE,MAAM,KAAK,MAAM,iBAAiB,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;AAAA,EACnE;AAEA,SAAO;AACT;AAWO,SAAS,qBAAqB,gBAA4C;AAC/E,QAAM,UAA8B,CAAC;AAErC,aAAW,WAAW,eAAe,MAAM,IAAI,GAAG;AAChD,UAAM,CAAC,UAAU,IAAI,SAAS,EAAE,IAAI,QAAQ,KAAK,EAAE,WAAW,KAAK,EAAE,EAAE,MAAM,KAAK,qBAAqB;AACvG,UAAM,MAAM,OAAO,SAAS,QAAQ,aAAa;AACjD,QAAI,QAAQ,WAAW,KAAK,OAAO,MAAM,GAAG,GAAG;AAC7C;AAAA,IACF;AAEA,YAAQ,KAAK,EAAE,MAAM,SAAS,IAAI,CAAC;AAAA,EACrC;AAEA,SAAO;AACT;AAQO,SAAS,0BAA0B,QAAmD;AAC3F,SAAO,OAAO,UACX,OAAO,CAAC,UAAU,2BAA2B,MAAM,IAAI,KAAK,CAAC,OAAO,UAAU,SAAS,MAAM,GAAG,CAAC,EACjG,IAAI,CAAC,UAAU,MAAM,GAAG;AAC7B;AAEA,SAAS,2BAA2B,MAAuB;AACzD,QAAM,WAAW,KAAK,MAAM,KAAK,IAAI,KAAK,YAAY,GAAG,GAAG,KAAK,YAAY,IAAI,CAAC,IAAI,CAAC;AACvF,SAAO,8BAA8B,KAAK,SAAS,YAAY,EAAE,QAAQ,2BAA2B,EAAE,CAAC;AACzG;",
  "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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