obsidian-integration-testing 4.2.2 → 4.2.3

package/README.md

@@ -387,13 +387,10 @@ Connects via WebSocket to Obsidian `Chrome DevTools Protocol` (`CDP`) endpoint.
 1. Launch Obsidian with the `--remote-debugging-port` flag:
 
    ```powershell
-   # Windows (PowerShell)
-   & "$env:LOCALAPPDATA\Programs\Obsidian\Obsidian.exe" --remote-debugging-port=8315
-   ```
-
-   ```cmd
-   # Windows (CMD)
-   "%LOCALAPPDATA%\Programs\Obsidian\Obsidian.exe" --remote-debugging-port=8315
+   # Windows (PowerShell) — uses Obsidian from PATH (e.g. scoop), falling back to the installer location
+   $obsidian = (Get-Command Obsidian.exe -ErrorAction SilentlyContinue).Source
+   if (-not $obsidian) { $obsidian = "$env:LOCALAPPDATA\Programs\Obsidian\Obsidian.exe" }
+   Start-Process $obsidian -ArgumentList '--remote-debugging-port=8315'
    ```
 
    ```bash

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" : "4.2.1";
+const LIBRARY_VERSION = false ? "dev" : "4.2.2";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LIBRARY_VERSION

package/dist/lib/cjs/strict-proxy.cjs

@@ -0,0 +1,97 @@
+"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 strict_proxy_exports = {};
+__export(strict_proxy_exports, {
+  bypassStrictProxy: () => bypassStrictProxy,
+  strictProxy: () => strictProxy
+});
+module.exports = __toCommonJS(strict_proxy_exports);
+var import_type_guards = require("./type-guards.cjs");
+const STRICT_PROXY_TARGET_SYMBOL = /* @__PURE__ */ Symbol.for("strictProxyTarget");
+const PASSTHROUGH_PROPS = /* @__PURE__ */ new Set([
+  Symbol.iterator,
+  Symbol.toPrimitive,
+  Symbol.toStringTag,
+  "then",
+  "toJSON"
+]);
+function bypassStrictProxy(obj) {
+  if (!isObjectLike(obj)) {
+    return obj;
+  }
+  if (!(STRICT_PROXY_TARGET_SYMBOL in obj)) {
+    return obj;
+  }
+  return obj[STRICT_PROXY_TARGET_SYMBOL];
+}
+function strictProxy(value, mockClass) {
+  return wrapProxy(value, mockClass);
+}
+function isObjectLike(value) {
+  return value !== null && typeof value === "object";
+}
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype;
+}
+function wrapProxy(value, mockClass) {
+  if (!isObjectLike(value)) {
+    return value;
+  }
+  if (STRICT_PROXY_TARGET_SYMBOL in value) {
+    return value;
+  }
+  Object.defineProperty(value, STRICT_PROXY_TARGET_SYMBOL, { value });
+  const isClass = !isPlainObject(value);
+  const className = mockClass?.name ?? (isClass ? value.constructor.name : "");
+  const mockProto = mockClass ? (0, import_type_guards.ensureGenericObject)(mockClass.prototype) : null;
+  const proxiedChildren = isClass ? null : /* @__PURE__ */ new Map();
+  return new Proxy(value, {
+    get(target, prop, receiver) {
+      if (prop in target) {
+        if (proxiedChildren?.has(prop)) {
+          return proxiedChildren.get(prop);
+        }
+        const val = Reflect.get(target, prop, receiver);
+        if (proxiedChildren && isPlainObject(val)) {
+          const result = wrapProxy(val);
+          proxiedChildren.set(prop, result);
+          return result;
+        }
+        return val;
+      }
+      if (mockProto && typeof prop === "string" && prop.endsWith("__") && prop in mockProto) {
+        const val = mockProto[prop];
+        if (typeof val === "function") {
+          return val.bind(receiver);
+        }
+        return val;
+      }
+      if (typeof prop === "symbol" || PASSTHROUGH_PROPS.has(prop)) {
+        return Reflect.get(target, prop, receiver);
+      }
+      throw new Error(`Property "${prop}" is not mocked in ${className}. To override, assign a value first: mock.${prop} = ...`);
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bypassStrictProxy,
+  strictProxy
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/strict-proxy.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Strict proxy for mock objects.\n *\n * Wraps an object in a `Proxy` that throws a descriptive error when any\n * unmocked property is accessed, instead of silently returning `undefined`.\n *\n * - Idempotent (double-wrapping is a no-op).\n * - Passthrough for well-known props (`then`, `toJSON`, `Symbol.iterator`, etc.).\n * - Class-name-aware error messages for class instances.\n * - Recursive proxying of nested plain objects (for partial mocks only).\n *\n * Overloads:\n * 1. `strictProxy(value, MockClass)` \u2014 infers `T` from `MockClass.prototype`,\n *    overlays `__`-suffixed methods via the proxy.\n * 2. `strictProxy(value: T)` \u2014 infers `T` from the argument.\n * 3. `strictProxy<T>(partial)` \u2014 test mocking: typed via `PartialDeep<T>`.\n * 4. `strictProxy<T>(value)` \u2014 explicit `T`, unchecked value (cross-type cast).\n */\n\nimport type { PartialDeep } from 'type-fest';\n\nimport type { GenericObject } from './type-guards.cjs';\n\nimport { ensureGenericObject } from './type-guards.cjs';\n\nconst STRICT_PROXY_TARGET_SYMBOL = Symbol.for('strictProxyTarget');\n\nconst PASSTHROUGH_PROPS = new Set<string | symbol>([\n  Symbol.iterator,\n  Symbol.toPrimitive,\n  Symbol.toStringTag,\n  'then',\n  'toJSON'\n]);\n\ntype MockClassLike<T> = { prototype: T } & MockClassRef;\n\ninterface MockClassRef {\n  name: string;\n  prototype: object;\n}\n\n/**\n * Unwraps a strict-proxied object, returning the underlying target.\n *\n * Accessing unmocked properties on the returned object yields `undefined`\n * instead of throwing. Non-proxied values are returned as-is.\n *\n * @typeParam T - The type of the object.\n * @param obj - The object to unwrap.\n * @returns The underlying target, or `obj` if it is not a strict proxy.\n */\nexport function bypassStrictProxy<T>(obj: T): T {\n  if (!isObjectLike(obj)) {\n    return obj;\n  }\n  if (!(STRICT_PROXY_TARGET_SYMBOL in obj)) {\n    return obj;\n  }\n  return obj[STRICT_PROXY_TARGET_SYMBOL] as T;\n}\n\n// eslint-disable-next-line @typescript-eslint/unified-signatures -- This overload infers T from mockClass; the `unknown` overload below requires explicit T. They cannot be combined.\nexport function strictProxy<T>(value: unknown, mockClass: MockClassLike<T>): T;\nexport function strictProxy<T extends object>(value: T): T;\nexport function strictProxy<T>(value: PartialDeep<T>): T;\n// eslint-disable-next-line @typescript-eslint/unified-signatures, @typescript-eslint/no-unnecessary-type-parameters -- PartialDeep<T> above gives type safety for partial mocks; this overload accepts an explicit T with an unchecked value for cross-type casts.\nexport function strictProxy<T>(value: unknown): T;\n/**\n * Wraps a mock object in a strict {@link Proxy} that throws on unmocked access.\n *\n * @typeParam T - The type the proxy presents.\n * @param value - The object (or partial mock) to wrap.\n * @param mockClass - Optional mock class providing `__`-suffixed overlay methods.\n * @returns The wrapped value typed as `T`.\n */\nexport function strictProxy<T>(value: unknown, mockClass?: MockClassRef): T {\n  return wrapProxy<T>(value, mockClass);\n}\n\n/**\n * Checks whether a value is a non-`null` object.\n *\n * @param value - The value to check.\n * @returns `true` if the value is a non-`null` object.\n */\nfunction isObjectLike(value: unknown): value is object {\n  return value !== null && typeof value === 'object';\n}\n\n/**\n * Checks whether a value is a plain object (prototype is `Object.prototype`).\n *\n * @param value - The value to check.\n * @returns `true` if the value is a plain object.\n */\nfunction isPlainObject(value: unknown): value is GenericObject {\n  return value !== null && typeof value === 'object' && Object.getPrototypeOf(value) === Object.prototype;\n}\n\n/**\n * Implements the strict-proxy wrapping logic shared by all overloads.\n *\n * @typeParam T - The type the proxy presents.\n * @param value - The object to wrap.\n * @param mockClass - Optional mock class providing `__`-suffixed overlay methods.\n * @returns The wrapped value typed as `T`.\n */\n// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- T provides return-type inference at the call sites.\nfunction wrapProxy<T>(value: unknown, mockClass?: MockClassRef): T {\n  if (!isObjectLike(value)) {\n    return value as T;\n  }\n\n  if (STRICT_PROXY_TARGET_SYMBOL in value) {\n    return value as T;\n  }\n  Object.defineProperty(value, STRICT_PROXY_TARGET_SYMBOL, { value });\n\n  const isClass = !isPlainObject(value);\n  const className = mockClass?.name ?? (isClass ? value.constructor.name : '');\n  const mockProto = mockClass ? ensureGenericObject(mockClass.prototype) : null;\n  const proxiedChildren = isClass ? null : new Map<string | symbol>();\n\n  return new Proxy(value, {\n    get(target, prop, receiver): unknown {\n      // 1. Own properties and prototype chain of the original object.\n      if (prop in target) {\n        if (proxiedChildren?.has(prop)) {\n          return proxiedChildren.get(prop);\n        }\n\n        const val: unknown = Reflect.get(target, prop, receiver);\n        if (proxiedChildren && isPlainObject(val)) {\n          const result = wrapProxy<unknown>(val);\n          proxiedChildren.set(prop, result);\n          return result;\n        }\n        return val;\n      }\n\n      // 2. Mock prototype chain (for __ methods on the mock class).\n      if (mockProto && typeof prop === 'string' && prop.endsWith('__') && prop in mockProto) {\n        const val: unknown = mockProto[prop];\n        if (typeof val === 'function') {\n          return val.bind(receiver);\n        }\n        return val;\n      }\n\n      // 3. Passthrough props (symbols, then, toJSON, etc.).\n      if (typeof prop === 'symbol' || PASSTHROUGH_PROPS.has(prop)) {\n        return Reflect.get(target, prop, receiver);\n      }\n\n      throw new Error(`Property \"${prop}\" is not mocked in ${className}. To override, assign a value first: mock.${prop} = ...`);\n    }\n  }) as T;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAyBA,yBAAoC;AAEpC,MAAM,6BAA6B,uBAAO,IAAI,mBAAmB;AAEjE,MAAM,oBAAoB,oBAAI,IAAqB;AAAA,EACjD,OAAO;AAAA,EACP,OAAO;AAAA,EACP,OAAO;AAAA,EACP;AAAA,EACA;AACF,CAAC;AAmBM,SAAS,kBAAqB,KAAW;AAC9C,MAAI,CAAC,aAAa,GAAG,GAAG;AACtB,WAAO;AAAA,EACT;AACA,MAAI,EAAE,8BAA8B,MAAM;AACxC,WAAO;AAAA,EACT;AACA,SAAO,IAAI,0BAA0B;AACvC;AAgBO,SAAS,YAAe,OAAgB,WAA6B;AAC1E,SAAO,UAAa,OAAO,SAAS;AACtC;AAQA,SAAS,aAAa,OAAiC;AACrD,SAAO,UAAU,QAAQ,OAAO,UAAU;AAC5C;AAQA,SAAS,cAAc,OAAwC;AAC7D,SAAO,UAAU,QAAQ,OAAO,UAAU,YAAY,OAAO,eAAe,KAAK,MAAM,OAAO;AAChG;AAWA,SAAS,UAAa,OAAgB,WAA6B;AACjE,MAAI,CAAC,aAAa,KAAK,GAAG;AACxB,WAAO;AAAA,EACT;AAEA,MAAI,8BAA8B,OAAO;AACvC,WAAO;AAAA,EACT;AACA,SAAO,eAAe,OAAO,4BAA4B,EAAE,MAAM,CAAC;AAElE,QAAM,UAAU,CAAC,cAAc,KAAK;AACpC,QAAM,YAAY,WAAW,SAAS,UAAU,MAAM,YAAY,OAAO;AACzE,QAAM,YAAY,gBAAY,wCAAoB,UAAU,SAAS,IAAI;AACzE,QAAM,kBAAkB,UAAU,OAAO,oBAAI,IAAqB;AAElE,SAAO,IAAI,MAAM,OAAO;AAAA,IACtB,IAAI,QAAQ,MAAM,UAAmB;AAEnC,UAAI,QAAQ,QAAQ;AAClB,YAAI,iBAAiB,IAAI,IAAI,GAAG;AAC9B,iBAAO,gBAAgB,IAAI,IAAI;AAAA,QACjC;AAEA,cAAM,MAAe,QAAQ,IAAI,QAAQ,MAAM,QAAQ;AACvD,YAAI,mBAAmB,cAAc,GAAG,GAAG;AACzC,gBAAM,SAAS,UAAmB,GAAG;AACrC,0BAAgB,IAAI,MAAM,MAAM;AAChC,iBAAO;AAAA,QACT;AACA,eAAO;AAAA,MACT;AAGA,UAAI,aAAa,OAAO,SAAS,YAAY,KAAK,SAAS,IAAI,KAAK,QAAQ,WAAW;AACrF,cAAM,MAAe,UAAU,IAAI;AACnC,YAAI,OAAO,QAAQ,YAAY;AAC7B,iBAAO,IAAI,KAAK,QAAQ;AAAA,QAC1B;AACA,eAAO;AAAA,MACT;AAGA,UAAI,OAAO,SAAS,YAAY,kBAAkB,IAAI,IAAI,GAAG;AAC3D,eAAO,QAAQ,IAAI,QAAQ,MAAM,QAAQ;AAAA,MAC3C;AAEA,YAAM,IAAI,MAAM,aAAa,IAAI,sBAAsB,SAAS,6CAA6C,IAAI,QAAQ;AAAA,IAC3H;AAAA,EACF,CAAC;AACH;",
  "names": []
}


package/dist/lib/cjs/strict-proxy.d.cts

@@ -0,0 +1,44 @@
+/**
+ * @file
+ *
+ * Strict proxy for mock objects.
+ *
+ * Wraps an object in a `Proxy` that throws a descriptive error when any
+ * unmocked property is accessed, instead of silently returning `undefined`.
+ *
+ * - Idempotent (double-wrapping is a no-op).
+ * - Passthrough for well-known props (`then`, `toJSON`, `Symbol.iterator`, etc.).
+ * - Class-name-aware error messages for class instances.
+ * - Recursive proxying of nested plain objects (for partial mocks only).
+ *
+ * Overloads:
+ * 1. `strictProxy(value, MockClass)` — infers `T` from `MockClass.prototype`,
+ *    overlays `__`-suffixed methods via the proxy.
+ * 2. `strictProxy(value: T)` — infers `T` from the argument.
+ * 3. `strictProxy<T>(partial)` — test mocking: typed via `PartialDeep<T>`.
+ * 4. `strictProxy<T>(value)` — explicit `T`, unchecked value (cross-type cast).
+ */
+import type { PartialDeep } from 'type-fest';
+type MockClassLike<T> = {
+    prototype: T;
+} & MockClassRef;
+interface MockClassRef {
+    name: string;
+    prototype: object;
+}
+/**
+ * Unwraps a strict-proxied object, returning the underlying target.
+ *
+ * Accessing unmocked properties on the returned object yields `undefined`
+ * instead of throwing. Non-proxied values are returned as-is.
+ *
+ * @typeParam T - The type of the object.
+ * @param obj - The object to unwrap.
+ * @returns The underlying target, or `obj` if it is not a strict proxy.
+ */
+export declare function bypassStrictProxy<T>(obj: T): T;
+export declare function strictProxy<T>(value: unknown, mockClass: MockClassLike<T>): T;
+export declare function strictProxy<T extends object>(value: T): T;
+export declare function strictProxy<T>(value: PartialDeep<T>): T;
+export declare function strictProxy<T>(value: unknown): T;
+export {};

package/dist/lib/cjs/transport-factory.cjs

@@ -95,7 +95,8 @@ class AppiumTransportFactory {
       logLevel: "warn",
       path: url.pathname,
       port,
-      sessionId
+      sessionId,
+      transformRequest: stripForbiddenFetchHeaders
     });
     this.log("Reattached to Appium session.");
     return new import_transport_appium.AppiumTransport({
@@ -486,4 +487,4 @@ function stripForbiddenFetchHeaders(requestOptions) {
   createTransportFromOptions,
   getOrCreateTransport
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/transport-factory.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Factory for creating transport instances from {@link ObsidianTransportOptions}.\n */\n\n/* v8 ignore start -- Integration-time factory covered by integration tests, not unit tests. */\n\nimport type { ChildProcess } from 'node:child_process';\n\nimport {\n  execFile,\n  execFileSync,\n  spawn\n} from 'node:child_process';\nimport http from 'node:http';\nimport { join } from 'node:path';\nimport process from 'node:process';\nimport {\n  attach,\n  remote\n} from 'webdriverio';\n\nimport type {\n  ObsidianAndroidAppiumTransportOptions,\n  ObsidianTransportOptions\n} from './transport-options.cjs';\nimport type { ObsidianTransport } from './transport.cjs';\n\nimport { buildEmulatorArgs } from './emulator-args.cjs';\nimport { log } from './log.cjs';\nimport { AppiumTransport } from './transport-appium.cjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.cjs';\nimport { DesktopCliTransport } from './transport-desktop-cli.cjs';\n\nconst APP_PACKAGE = 'md.obsidian';\nconst APP_ACTIVITY = `${APP_PACKAGE}.MainActivity`;\nconst ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS = 5000;\nconst APPIUM_CONNECTION_RETRY_COUNT = 3;\nconst APPIUM_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS = 180000;\nconst APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS = 5000;\nconst APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst APPIUM_START_TIMEOUT_IN_MILLISECONDS = 60000;\nconst CDP_DEFAULT_PORT = 8315;\n// Appium insecure feature letting the UiAutomator2 driver auto-download a\n// Chromedriver matching Obsidian's WebView Chrome version. Enabling it on the\n// Appium server (it has no effect as a capability) avoids the failure\n// \"No Chromedriver found that can automate Chrome ...\".\nconst CHROMEDRIVER_AUTODOWNLOAD_FEATURE = 'uiautomator2:chromedriver_autodownload';\nconst COMMAND_TIMEOUT_IN_MILLISECONDS = 300;\nconst DEFAULT_TRANSPORT_TYPE = 'obsidian-cli';\nconst EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS = 2000;\nconst EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS = 120000;\nconst KEYCODE_MENU = 82;\nconst KEYCODE_WAKEUP = 224;\nconst SERVER_INSTALL_TIMEOUT_IN_MILLISECONDS = 120000;\nconst SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS = 120000;\n\n/**\n * Result of {@link AppiumTransportFactory.ensureDeviceConnected}.\n */\ninterface EnsureDeviceConnectedResult {\n  /** The actual device ID that is connected (may differ from the requested one). */\n  actualDeviceId: string;\n\n  /** The emulator process, if one was auto-started. */\n  emulatorProcess?: ChildProcess | undefined;\n}\n\n/**\n * Parameters for {@link AppiumTransportFactory.startAppiumAndEmulator}.\n */\ninterface StartAppiumAndEmulatorParams {\n  /** The Appium server URL. */\n  appiumUrl: URL;\n\n  /** AVD name to start. */\n  avdName: string;\n\n  /** The Appium server port. */\n  port: number;\n\n  /** Whether Appium auto-start is allowed. */\n  shouldAutoStartAppium?: boolean | undefined;\n}\n\n/**\n * Result of {@link AppiumTransportFactory.startAppiumAndEmulator}.\n */\ninterface StartAppiumAndEmulatorResult {\n  /** The actual device ID that is connected (may differ from the requested one). */\n  actualDeviceId: string;\n\n  /** The Appium server process, if one was auto-started. */\n  appiumProcess?: ChildProcess | undefined;\n\n  /** The emulator process, if one was auto-started. */\n  emulatorProcess?: ChildProcess | undefined;\n}\n\nlet cachedTransport: ObsidianTransport | undefined;\n\n/**\n * Encapsulates all Appium transport creation logic, including Appium server\n * startup, emulator management, and WebDriverIO session establishment.\n *\n * Using a class avoids threading the transport `type` label through every\n * helper function \u2014 `this.log()` automatically prefixes it.\n */\nclass AppiumTransportFactory {\n  private readonly type: string;\n\n  public constructor(type: string) {\n    this.type = type;\n  }\n\n  /**\n   * Creates an Appium transport by establishing a WebDriverIO session.\n   *\n   * If `options.sessionId` is present, reattaches to the existing session\n   * instead of creating a new one. This avoids duplicate Appium/ADB connections\n   * when test workers reuse the global setup's session.\n   *\n   * @param options - Android Appium transport options.\n   * @returns A configured Appium transport.\n   */\n  public async create(options: ObsidianAndroidAppiumTransportOptions): Promise<ObsidianTransport> {\n    if (options.sessionId !== undefined && options.deviceId !== undefined) {\n      return this.attachToExistingSession(options.sessionId, options.deviceId, options);\n    }\n\n    return this.createNewSession(options);\n  }\n\n  private async attachToExistingSession(\n    sessionId: string,\n    deviceId: string,\n    options: ObsidianAndroidAppiumTransportOptions\n  ): Promise<ObsidianTransport> {\n    const url = new URL(options.appiumUrl);\n    const port = Number(url.port);\n    const appId = options.appId ?? APP_PACKAGE;\n\n    this.log(`Reattaching to existing Appium session ${sessionId} (device=${deviceId})`);\n\n    const browser = await attach({\n      capabilities: {\n        platformName: 'Android'\n      },\n      hostname: url.hostname,\n      logLevel: 'warn',\n      path: url.pathname,\n      port,\n      sessionId\n    });\n\n    this.log('Reattached to Appium session.');\n\n    return new AppiumTransport({\n      appId,\n      browser,\n      deviceId,\n      isSessionOwner: false,\n      platform: 'android',\n      ...(options.vaultBasePath !== undefined && { vaultBasePath: options.vaultBasePath }),\n      ...(options.webviewTimeoutInMilliseconds !== undefined && { webviewTimeoutInMilliseconds: options.webviewTimeoutInMilliseconds })\n    });\n  }\n\n  private checkAppiumReachable(url: URL): Promise<void> {\n    return new Promise((resolve, reject) => {\n      const statusUrl = new URL('/status', url);\n      const req = http.get(statusUrl, { timeout: APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS }, (res) => {\n        res.resume();\n        resolve();\n      });\n      req.on('timeout', () => {\n        req.destroy();\n        reject(\n          new Error(\n            `Appium server at ${url.origin} did not respond within ${String(APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS)}ms. Is the Appium server running?`\n          )\n        );\n      });\n      req.on('error', (err) => {\n        reject(\n          new Error(\n            `Cannot reach Appium server at ${url.origin}: ${err.message}. Is the Appium server running?`\n          )\n        );\n      });\n    });\n  }\n\n  private async createNewSession(options: ObsidianAndroidAppiumTransportOptions): Promise<ObsidianTransport> {\n    this.log(`Creating AppiumTransport (url=${options.appiumUrl}, avd=${options.avdName})`);\n\n    const url = new URL(options.appiumUrl);\n\n    const port = Number(url.port);\n    if (isNaN(port)) {\n      throw new Error(`Invalid port in appiumUrl: ${url.port}`);\n    }\n\n    const appId = options.appId ?? APP_PACKAGE;\n\n    let appiumProcess: ChildProcess | undefined;\n    let emulatorProcess: ChildProcess | undefined;\n\n    try {\n      const result = await this.startAppiumAndEmulator({\n        appiumUrl: url,\n        avdName: options.avdName,\n        port,\n        shouldAutoStartAppium: options.shouldAutoStartAppium\n      });\n\n      appiumProcess = result.appiumProcess;\n      emulatorProcess = result.emulatorProcess;\n      const actualDeviceId = result.actualDeviceId;\n\n      this.log(\n        `Connecting to Appium (device=${actualDeviceId}, app=${appId}, retryTimeout: ${String(APPIUM_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS)}ms, retries: ${\n          String(APPIUM_CONNECTION_RETRY_COUNT)\n        })...`\n      );\n      const browser = await remote({\n        capabilities: {\n          'appium:appActivity': APP_ACTIVITY,\n          'appium:appPackage': appId,\n          'appium:autoGrantPermissions': true,\n          'appium:automationName': 'UiAutomator2',\n          'appium:newCommandTimeout': COMMAND_TIMEOUT_IN_MILLISECONDS,\n          'appium:noReset': true,\n          'appium:udid': actualDeviceId,\n          'appium:uiautomator2ServerInstallTimeout': SERVER_INSTALL_TIMEOUT_IN_MILLISECONDS,\n          'appium:uiautomator2ServerLaunchTimeout': SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS,\n          'platformName': 'Android'\n        },\n        connectionRetryCount: APPIUM_CONNECTION_RETRY_COUNT,\n        connectionRetryTimeout: APPIUM_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS,\n        hostname: url.hostname,\n        logLevel: 'warn',\n        path: url.pathname,\n        port,\n        transformRequest: stripForbiddenFetchHeaders\n      });\n\n      this.log('Appium session established.');\n      const appiumTransport = new AppiumTransport({\n        appId,\n        browser,\n        deviceId: actualDeviceId,\n        platform: 'android',\n        ...(options.vaultBasePath !== undefined && { vaultBasePath: options.vaultBasePath }),\n        ...(options.webviewTimeoutInMilliseconds !== undefined && { webviewTimeoutInMilliseconds: options.webviewTimeoutInMilliseconds })\n      });\n\n      const originalDispose = appiumTransport.dispose.bind(appiumTransport);\n      const transport: ObsidianTransport = appiumTransport;\n      transport.dispose = async (): Promise<void> => {\n        try {\n          await originalDispose();\n        } finally {\n          killAutoStartedProcesses();\n        }\n      };\n\n      transport.disposeSync = (): void => {\n        killAutoStartedProcesses();\n      };\n\n      return transport;\n\n      function killAutoStartedProcesses(): void {\n        if (appiumProcess) {\n          killProcessTree(appiumProcess);\n          // Cannot use this.log inside nested function \u2014 `this` is not captured.\n          log(`[transport-factory:${options.type}] Auto-started Appium server stopped.`);\n        }\n        if (emulatorProcess) {\n          killProcessTree(emulatorProcess);\n          log(`[transport-factory:${options.type}] Auto-started emulator stopped.`);\n        }\n      }\n    } catch (error: unknown) {\n      if (appiumProcess) {\n        killProcessTree(appiumProcess);\n        this.log('Killed auto-started Appium server after connection failure.');\n      }\n      if (emulatorProcess) {\n        killProcessTree(emulatorProcess);\n        this.log('Killed auto-started emulator after connection failure.');\n      }\n      throw error;\n    }\n  }\n\n  private async ensureDeviceConnected(avdName: string): Promise<EnsureDeviceConnectedResult> {\n    const deviceIdsBefore = await this.getConnectedDeviceIds();\n    this.log(`Checking existing devices for AVD \"${avdName}\"... (connected: [${deviceIdsBefore.join(', ')}])`);\n\n    const existingDeviceId = await this.findDeviceByAvdName(avdName, deviceIdsBefore);\n\n    if (existingDeviceId) {\n      this.log(`AVD \"${avdName}\" is already running on device ${existingDeviceId}, reusing.`);\n      return { actualDeviceId: existingDeviceId };\n    }\n\n    this.log(`AVD \"${avdName}\" not found on any existing device, starting a new emulator...`);\n    const emulatorProcess = this.startEmulator(avdName);\n    const actualDeviceId = await this.waitForNewDevice(deviceIdsBefore);\n    this.log(`Emulator \"${avdName}\" started, device ${actualDeviceId} is connected.`);\n    return { actualDeviceId, emulatorProcess };\n  }\n\n  private async findDeviceByAvdName(avdName: string, deviceIds: string[]): Promise<string | undefined> {\n    for (const deviceId of deviceIds) {\n      const runningAvd = await new Promise<string>((resolve) => {\n        execFile(\n          'adb',\n          ['-s', deviceId, 'emu', 'avd', 'name'],\n          { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n          (_error, stdout) => {\n            resolve(stdout.split('\\n')[0]?.trim() ?? '');\n          }\n        );\n      });\n\n      if (runningAvd === avdName) {\n        return deviceId;\n      }\n    }\n\n    return undefined;\n  }\n\n  private async getConnectedDeviceIds(): Promise<string[]> {\n    const output = await new Promise<string>((resolve, reject) => {\n      execFile('adb', ['devices'], { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS }, (error, stdout, stderr) => {\n        if (error) {\n          reject(new Error(`Failed to run 'adb devices': ${error.message}. Is ADB installed and in PATH?`));\n          return;\n        }\n        if (stderr) {\n          this.log(`ADB stderr: ${stderr.trim()}`);\n        }\n        resolve(stdout);\n      });\n    });\n\n    const lines = output.split('\\n').map((line) => line.trim()).filter((line) => line.length > 0);\n    return lines\n      .filter((line) => line.includes('\\tdevice'))\n      .map((line) => line.split('\\t')[0] ?? '');\n  }\n\n  private log(message: string): void {\n    log(`[transport-factory:${this.type}] ${message}`);\n  }\n\n  private resolveEmulatorBinary(): string {\n    const sdkRoot = process.env['ANDROID_HOME'] ?? process.env['ANDROID_SDK_ROOT'];\n    if (!sdkRoot) {\n      throw new Error(\n        'Cannot find Android emulator: neither ANDROID_HOME nor ANDROID_SDK_ROOT environment variable is set.'\n      );\n    }\n    return join(sdkRoot, 'emulator', 'emulator');\n  }\n\n  private async sendKeyEvent(deviceId: string, keyCode: number, description: string): Promise<void> {\n    await new Promise<void>((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'input', 'keyevent', String(keyCode)],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error) => {\n          if (error) {\n            this.log(\n              `Warning: failed to ${description} (keyevent ${String(keyCode)}): ${error instanceof Error ? error.message : 'unknown error'}`\n            );\n          }\n\n          resolve();\n        }\n      );\n    });\n  }\n\n  private async startAppiumAndEmulator(params: StartAppiumAndEmulatorParams): Promise<StartAppiumAndEmulatorResult> {\n    const { appiumUrl, avdName, port, shouldAutoStartAppium } = params;\n\n    let needsAppiumStart = false;\n\n    this.log(`Checking Appium server at ${appiumUrl.href}...`);\n    try {\n      await this.checkAppiumReachable(appiumUrl);\n      this.log('Appium server is reachable.');\n    } catch (error: unknown) {\n      if (shouldAutoStartAppium === false) {\n        throw error;\n      }\n      needsAppiumStart = true;\n    }\n\n    let appiumProcess: ChildProcess | undefined;\n\n    if (needsAppiumStart) {\n      this.log(`Appium not reachable, auto-starting on port ${String(port)}...`);\n      appiumProcess = this.startAppiumServer(port);\n    }\n\n    try {\n      const [, deviceResult] = await Promise.all([\n        needsAppiumStart\n          ? this.waitForAppiumReady(appiumUrl).then(() => {\n            this.log('Auto-started Appium server is ready.');\n          })\n          : Promise.resolve(),\n        this.ensureDeviceConnected(avdName)\n      ]);\n\n      return {\n        actualDeviceId: deviceResult.actualDeviceId,\n        appiumProcess,\n        emulatorProcess: deviceResult.emulatorProcess\n      };\n    } catch (error: unknown) {\n      if (appiumProcess) {\n        killProcessTree(appiumProcess);\n        this.log('Killed auto-started Appium server after startup failure.');\n      }\n      throw error;\n    }\n  }\n\n  private startAppiumServer(port: number): ChildProcess {\n    const child = spawn(`npx appium --log-timestamp --port ${String(port)} --allow-insecure=${CHROMEDRIVER_AUTODOWNLOAD_FEATURE}`, {\n      detached: true,\n      shell: true,\n      stdio: ['ignore', 'inherit', 'inherit']\n    });\n\n    child.unref();\n    return child;\n  }\n\n  private startEmulator(avdName: string): ChildProcess {\n    const emulatorBinary = this.resolveEmulatorBinary();\n    const args = buildEmulatorArgs(avdName);\n    this.log(`Running: ${emulatorBinary} ${args.join(' ')}`);\n    const child = spawn(emulatorBinary, args, {\n      detached: true,\n      stdio: ['ignore', 'ignore', 'ignore']\n    });\n\n    child.unref();\n    return child;\n  }\n\n  private async waitForAppiumReady(url: URL): Promise<void> {\n    this.log(\n      `Waiting for Appium at ${url.href} (timeout: ${String(APPIUM_START_TIMEOUT_IN_MILLISECONDS)}ms, poll: ${\n        String(APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS)\n      }ms)...`\n    );\n    const deadline = Date.now() + APPIUM_START_TIMEOUT_IN_MILLISECONDS;\n\n    while (Date.now() < deadline) {\n      try {\n        await this.checkAppiumReachable(url);\n        return;\n      } catch {\n        await new Promise((resolve) => {\n          setTimeout(resolve, APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS);\n        });\n      }\n    }\n\n    throw new Error(\n      `Auto-started Appium server did not become ready within ${String(APPIUM_START_TIMEOUT_IN_MILLISECONDS)}ms`\n    );\n  }\n\n  private async waitForBoot(deviceId: string, deadline: number): Promise<void> {\n    const remainingMs = Math.max(0, deadline - Date.now());\n    this.log(\n      `Waiting for device ${deviceId} to finish booting (remaining: ${String(remainingMs)}ms, poll: ${\n        String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)\n      }ms)...`\n    );\n\n    while (Date.now() < deadline) {\n      const isBooted = await new Promise<boolean>((resolve) => {\n        execFile(\n          'adb',\n          ['-s', deviceId, 'shell', 'getprop', 'sys.boot_completed'],\n          { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n          (_error, stdout) => {\n            resolve(stdout.trim() === '1');\n          }\n        );\n      });\n\n      if (isBooted) {\n        this.log(`Device ${deviceId} boot completed.`);\n        return;\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    throw new Error(\n      `Device \"${deviceId}\" connected but did not finish booting within ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms.`\n    );\n  }\n\n  private async waitForNewDevice(deviceIdsBefore: string[]): Promise<string> {\n    this.log(\n      `Waiting for a new device to appear in ADB (timeout: ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms, poll: ${\n        String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)\n      }ms)...`\n    );\n    const deadline = Date.now() + EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS;\n\n    while (Date.now() < deadline) {\n      const currentIds = await this.getConnectedDeviceIds();\n      const newIds = currentIds.filter((id) => !deviceIdsBefore.includes(id));\n\n      if (newIds.length > 0) {\n        const actualDeviceId = newIds[0] ?? '';\n        this.log(`Device ${actualDeviceId} appeared in ADB, waiting for boot to complete...`);\n        await this.waitForBoot(actualDeviceId, deadline);\n        await this.wakeScreen(actualDeviceId);\n        return actualDeviceId;\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    throw new Error(\n      `No new emulator device appeared within ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms.`\n    );\n  }\n\n  private async wakeScreen(deviceId: string): Promise<void> {\n    this.log(`Waking screen on device ${deviceId}...`);\n\n    await this.sendKeyEvent(deviceId, KEYCODE_WAKEUP, 'wake screen');\n    await this.sendKeyEvent(deviceId, KEYCODE_MENU, 'dismiss lock screen');\n\n    this.log(`Screen wake complete on device ${deviceId}.`);\n  }\n}\n\n/**\n * Creates a new transport instance from the given options.\n *\n * @param options - Transport configuration. Defaults to CLI transport.\n * @returns A new transport instance.\n */\nexport async function createTransportFromOptions(options?: ObsidianTransportOptions): Promise<ObsidianTransport> {\n  const type = options?.type ?? DEFAULT_TRANSPORT_TYPE;\n\n  if (!options || options.type === 'obsidian-cli') {\n    log(`[transport-factory:${type}] Creating DesktopCliTransport`);\n    return new DesktopCliTransport();\n  }\n\n  if (options.type === 'obsidian-cdp') {\n    log(`[transport-factory:${type}] Creating DesktopCdpTransport (host=${options.host ?? 'localhost'}, port=${String(options.port ?? CDP_DEFAULT_PORT)})`);\n    return new DesktopCdpTransport({\n      ...(options.host !== undefined && { cdpHost: options.host }),\n      ...(options.port !== undefined && { cdpPort: options.port }),\n      ...(options.commandTimeoutInMilliseconds !== undefined && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds })\n    });\n  }\n\n  const factory = new AppiumTransportFactory(type);\n  return factory.create(options);\n}\n\n/**\n * Returns a cached transport instance, creating one from the given options\n * if not already cached.\n *\n * The transport is cached per worker process so WebSocket/Appium sessions\n * are reused across calls within the same test worker.\n *\n * @param options - Transport configuration. Defaults to CLI transport.\n * @returns The cached or newly created transport.\n */\nexport async function getOrCreateTransport(options?: ObsidianTransportOptions): Promise<ObsidianTransport> {\n  if (cachedTransport) {\n    return cachedTransport;\n  }\n\n  const result = await createTransportFromOptions(options);\n  // eslint-disable-next-line require-atomic-updates -- Single-threaded worker; no concurrent writes.\n  cachedTransport = result;\n  return result;\n}\n\n/**\n * Kills a child process and its entire process tree.\n *\n * On Windows, `child.kill()` only sends SIGTERM to the direct process,\n * leaving spawned grandchildren (e.g. QEMU, UiAutomator) alive.\n * `taskkill /F /T /PID` forcefully terminates the entire tree.\n *\n * @param child - The child process to kill.\n */\nfunction killProcessTree(child: ChildProcess): void {\n  if (child.pid === undefined) {\n    return;\n  }\n\n  if (process.platform === 'win32') {\n    try {\n      execFileSync('taskkill', ['/F', '/T', '/PID', String(child.pid)], { stdio: 'ignore' });\n    } catch (error: unknown) {\n      log(\n        `[transport-factory] taskkill for PID ${String(child.pid)} failed (may have already exited): ${\n          error instanceof Error ? error.message : 'unknown error'\n        }`\n      );\n    }\n  } else {\n    child.kill('SIGKILL');\n  }\n}\n\n/**\n * Removes `Connection` and `Content-Length` from a WebDriver request's headers.\n *\n * The bundled `webdriver` package sets both headers explicitly. They are\n * forbidden request headers per the Fetch spec: Node up to 25 accepted them\n * silently, but Node 26 rejects them with `UND_ERR_INVALID_ARG`, breaking the\n * Appium `/session` request. The transport layer manages connection reuse and\n * the Fetch API computes `Content-Length` from the body, so dropping both is\n * safe on every Node version. See {@link https://github.com/webdriverio/webdriverio/issues/15265}.\n *\n * @param requestOptions - The request options about to be sent by WebDriverIO.\n * @returns The same request options with the forbidden headers removed.\n */\nfunction stripForbiddenFetchHeaders(requestOptions: RequestInit): RequestInit {\n  if (requestOptions.headers instanceof Headers) {\n    requestOptions.headers.delete('Connection');\n    requestOptions.headers.delete('Content-Length');\n  }\n\n  return requestOptions;\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["http", "killAutoStartedProcesses", "process"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/transport-factory.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Factory for creating transport instances from {@link ObsidianTransportOptions}.\n */\n\n/* v8 ignore start -- Integration-time factory covered by integration tests, not unit tests. */\n\nimport type { ChildProcess } from 'node:child_process';\n\nimport {\n  execFile,\n  execFileSync,\n  spawn\n} from 'node:child_process';\nimport http from 'node:http';\nimport { join } from 'node:path';\nimport process from 'node:process';\nimport {\n  attach,\n  remote\n} from 'webdriverio';\n\nimport type {\n  ObsidianAndroidAppiumTransportOptions,\n  ObsidianTransportOptions\n} from './transport-options.cjs';\nimport type { ObsidianTransport } from './transport.cjs';\n\nimport { buildEmulatorArgs } from './emulator-args.cjs';\nimport { log } from './log.cjs';\nimport { AppiumTransport } from './transport-appium.cjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.cjs';\nimport { DesktopCliTransport } from './transport-desktop-cli.cjs';\n\nconst APP_PACKAGE = 'md.obsidian';\nconst APP_ACTIVITY = `${APP_PACKAGE}.MainActivity`;\nconst ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS = 5000;\nconst APPIUM_CONNECTION_RETRY_COUNT = 3;\nconst APPIUM_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS = 180000;\nconst APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS = 5000;\nconst APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst APPIUM_START_TIMEOUT_IN_MILLISECONDS = 60000;\nconst CDP_DEFAULT_PORT = 8315;\n// Appium insecure feature letting the UiAutomator2 driver auto-download a\n// Chromedriver matching Obsidian's WebView Chrome version. Enabling it on the\n// Appium server (it has no effect as a capability) avoids the failure\n// \"No Chromedriver found that can automate Chrome ...\".\nconst CHROMEDRIVER_AUTODOWNLOAD_FEATURE = 'uiautomator2:chromedriver_autodownload';\nconst COMMAND_TIMEOUT_IN_MILLISECONDS = 300;\nconst DEFAULT_TRANSPORT_TYPE = 'obsidian-cli';\nconst EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS = 2000;\nconst EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS = 120000;\nconst KEYCODE_MENU = 82;\nconst KEYCODE_WAKEUP = 224;\nconst SERVER_INSTALL_TIMEOUT_IN_MILLISECONDS = 120000;\nconst SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS = 120000;\n\n/**\n * Result of {@link AppiumTransportFactory.ensureDeviceConnected}.\n */\ninterface EnsureDeviceConnectedResult {\n  /** The actual device ID that is connected (may differ from the requested one). */\n  actualDeviceId: string;\n\n  /** The emulator process, if one was auto-started. */\n  emulatorProcess?: ChildProcess | undefined;\n}\n\n/**\n * Parameters for {@link AppiumTransportFactory.startAppiumAndEmulator}.\n */\ninterface StartAppiumAndEmulatorParams {\n  /** The Appium server URL. */\n  appiumUrl: URL;\n\n  /** AVD name to start. */\n  avdName: string;\n\n  /** The Appium server port. */\n  port: number;\n\n  /** Whether Appium auto-start is allowed. */\n  shouldAutoStartAppium?: boolean | undefined;\n}\n\n/**\n * Result of {@link AppiumTransportFactory.startAppiumAndEmulator}.\n */\ninterface StartAppiumAndEmulatorResult {\n  /** The actual device ID that is connected (may differ from the requested one). */\n  actualDeviceId: string;\n\n  /** The Appium server process, if one was auto-started. */\n  appiumProcess?: ChildProcess | undefined;\n\n  /** The emulator process, if one was auto-started. */\n  emulatorProcess?: ChildProcess | undefined;\n}\n\nlet cachedTransport: ObsidianTransport | undefined;\n\n/**\n * Encapsulates all Appium transport creation logic, including Appium server\n * startup, emulator management, and WebDriverIO session establishment.\n *\n * Using a class avoids threading the transport `type` label through every\n * helper function \u2014 `this.log()` automatically prefixes it.\n */\nclass AppiumTransportFactory {\n  private readonly type: string;\n\n  public constructor(type: string) {\n    this.type = type;\n  }\n\n  /**\n   * Creates an Appium transport by establishing a WebDriverIO session.\n   *\n   * If `options.sessionId` is present, reattaches to the existing session\n   * instead of creating a new one. This avoids duplicate Appium/ADB connections\n   * when test workers reuse the global setup's session.\n   *\n   * @param options - Android Appium transport options.\n   * @returns A configured Appium transport.\n   */\n  public async create(options: ObsidianAndroidAppiumTransportOptions): Promise<ObsidianTransport> {\n    if (options.sessionId !== undefined && options.deviceId !== undefined) {\n      return this.attachToExistingSession(options.sessionId, options.deviceId, options);\n    }\n\n    return this.createNewSession(options);\n  }\n\n  private async attachToExistingSession(\n    sessionId: string,\n    deviceId: string,\n    options: ObsidianAndroidAppiumTransportOptions\n  ): Promise<ObsidianTransport> {\n    const url = new URL(options.appiumUrl);\n    const port = Number(url.port);\n    const appId = options.appId ?? APP_PACKAGE;\n\n    this.log(`Reattaching to existing Appium session ${sessionId} (device=${deviceId})`);\n\n    const browser = await attach({\n      capabilities: {\n        platformName: 'Android'\n      },\n      hostname: url.hostname,\n      logLevel: 'warn',\n      path: url.pathname,\n      port,\n      sessionId,\n      transformRequest: stripForbiddenFetchHeaders\n    });\n\n    this.log('Reattached to Appium session.');\n\n    return new AppiumTransport({\n      appId,\n      browser,\n      deviceId,\n      isSessionOwner: false,\n      platform: 'android',\n      ...(options.vaultBasePath !== undefined && { vaultBasePath: options.vaultBasePath }),\n      ...(options.webviewTimeoutInMilliseconds !== undefined && { webviewTimeoutInMilliseconds: options.webviewTimeoutInMilliseconds })\n    });\n  }\n\n  private checkAppiumReachable(url: URL): Promise<void> {\n    return new Promise((resolve, reject) => {\n      const statusUrl = new URL('/status', url);\n      const req = http.get(statusUrl, { timeout: APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS }, (res) => {\n        res.resume();\n        resolve();\n      });\n      req.on('timeout', () => {\n        req.destroy();\n        reject(\n          new Error(\n            `Appium server at ${url.origin} did not respond within ${String(APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS)}ms. Is the Appium server running?`\n          )\n        );\n      });\n      req.on('error', (err) => {\n        reject(\n          new Error(\n            `Cannot reach Appium server at ${url.origin}: ${err.message}. Is the Appium server running?`\n          )\n        );\n      });\n    });\n  }\n\n  private async createNewSession(options: ObsidianAndroidAppiumTransportOptions): Promise<ObsidianTransport> {\n    this.log(`Creating AppiumTransport (url=${options.appiumUrl}, avd=${options.avdName})`);\n\n    const url = new URL(options.appiumUrl);\n\n    const port = Number(url.port);\n    if (isNaN(port)) {\n      throw new Error(`Invalid port in appiumUrl: ${url.port}`);\n    }\n\n    const appId = options.appId ?? APP_PACKAGE;\n\n    let appiumProcess: ChildProcess | undefined;\n    let emulatorProcess: ChildProcess | undefined;\n\n    try {\n      const result = await this.startAppiumAndEmulator({\n        appiumUrl: url,\n        avdName: options.avdName,\n        port,\n        shouldAutoStartAppium: options.shouldAutoStartAppium\n      });\n\n      appiumProcess = result.appiumProcess;\n      emulatorProcess = result.emulatorProcess;\n      const actualDeviceId = result.actualDeviceId;\n\n      this.log(\n        `Connecting to Appium (device=${actualDeviceId}, app=${appId}, retryTimeout: ${String(APPIUM_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS)}ms, retries: ${\n          String(APPIUM_CONNECTION_RETRY_COUNT)\n        })...`\n      );\n      const browser = await remote({\n        capabilities: {\n          'appium:appActivity': APP_ACTIVITY,\n          'appium:appPackage': appId,\n          'appium:autoGrantPermissions': true,\n          'appium:automationName': 'UiAutomator2',\n          'appium:newCommandTimeout': COMMAND_TIMEOUT_IN_MILLISECONDS,\n          'appium:noReset': true,\n          'appium:udid': actualDeviceId,\n          'appium:uiautomator2ServerInstallTimeout': SERVER_INSTALL_TIMEOUT_IN_MILLISECONDS,\n          'appium:uiautomator2ServerLaunchTimeout': SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS,\n          'platformName': 'Android'\n        },\n        connectionRetryCount: APPIUM_CONNECTION_RETRY_COUNT,\n        connectionRetryTimeout: APPIUM_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS,\n        hostname: url.hostname,\n        logLevel: 'warn',\n        path: url.pathname,\n        port,\n        transformRequest: stripForbiddenFetchHeaders\n      });\n\n      this.log('Appium session established.');\n      const appiumTransport = new AppiumTransport({\n        appId,\n        browser,\n        deviceId: actualDeviceId,\n        platform: 'android',\n        ...(options.vaultBasePath !== undefined && { vaultBasePath: options.vaultBasePath }),\n        ...(options.webviewTimeoutInMilliseconds !== undefined && { webviewTimeoutInMilliseconds: options.webviewTimeoutInMilliseconds })\n      });\n\n      const originalDispose = appiumTransport.dispose.bind(appiumTransport);\n      const transport: ObsidianTransport = appiumTransport;\n      transport.dispose = async (): Promise<void> => {\n        try {\n          await originalDispose();\n        } finally {\n          killAutoStartedProcesses();\n        }\n      };\n\n      transport.disposeSync = (): void => {\n        killAutoStartedProcesses();\n      };\n\n      return transport;\n\n      function killAutoStartedProcesses(): void {\n        if (appiumProcess) {\n          killProcessTree(appiumProcess);\n          // Cannot use this.log inside nested function \u2014 `this` is not captured.\n          log(`[transport-factory:${options.type}] Auto-started Appium server stopped.`);\n        }\n        if (emulatorProcess) {\n          killProcessTree(emulatorProcess);\n          log(`[transport-factory:${options.type}] Auto-started emulator stopped.`);\n        }\n      }\n    } catch (error: unknown) {\n      if (appiumProcess) {\n        killProcessTree(appiumProcess);\n        this.log('Killed auto-started Appium server after connection failure.');\n      }\n      if (emulatorProcess) {\n        killProcessTree(emulatorProcess);\n        this.log('Killed auto-started emulator after connection failure.');\n      }\n      throw error;\n    }\n  }\n\n  private async ensureDeviceConnected(avdName: string): Promise<EnsureDeviceConnectedResult> {\n    const deviceIdsBefore = await this.getConnectedDeviceIds();\n    this.log(`Checking existing devices for AVD \"${avdName}\"... (connected: [${deviceIdsBefore.join(', ')}])`);\n\n    const existingDeviceId = await this.findDeviceByAvdName(avdName, deviceIdsBefore);\n\n    if (existingDeviceId) {\n      this.log(`AVD \"${avdName}\" is already running on device ${existingDeviceId}, reusing.`);\n      return { actualDeviceId: existingDeviceId };\n    }\n\n    this.log(`AVD \"${avdName}\" not found on any existing device, starting a new emulator...`);\n    const emulatorProcess = this.startEmulator(avdName);\n    const actualDeviceId = await this.waitForNewDevice(deviceIdsBefore);\n    this.log(`Emulator \"${avdName}\" started, device ${actualDeviceId} is connected.`);\n    return { actualDeviceId, emulatorProcess };\n  }\n\n  private async findDeviceByAvdName(avdName: string, deviceIds: string[]): Promise<string | undefined> {\n    for (const deviceId of deviceIds) {\n      const runningAvd = await new Promise<string>((resolve) => {\n        execFile(\n          'adb',\n          ['-s', deviceId, 'emu', 'avd', 'name'],\n          { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n          (_error, stdout) => {\n            resolve(stdout.split('\\n')[0]?.trim() ?? '');\n          }\n        );\n      });\n\n      if (runningAvd === avdName) {\n        return deviceId;\n      }\n    }\n\n    return undefined;\n  }\n\n  private async getConnectedDeviceIds(): Promise<string[]> {\n    const output = await new Promise<string>((resolve, reject) => {\n      execFile('adb', ['devices'], { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS }, (error, stdout, stderr) => {\n        if (error) {\n          reject(new Error(`Failed to run 'adb devices': ${error.message}. Is ADB installed and in PATH?`));\n          return;\n        }\n        if (stderr) {\n          this.log(`ADB stderr: ${stderr.trim()}`);\n        }\n        resolve(stdout);\n      });\n    });\n\n    const lines = output.split('\\n').map((line) => line.trim()).filter((line) => line.length > 0);\n    return lines\n      .filter((line) => line.includes('\\tdevice'))\n      .map((line) => line.split('\\t')[0] ?? '');\n  }\n\n  private log(message: string): void {\n    log(`[transport-factory:${this.type}] ${message}`);\n  }\n\n  private resolveEmulatorBinary(): string {\n    const sdkRoot = process.env['ANDROID_HOME'] ?? process.env['ANDROID_SDK_ROOT'];\n    if (!sdkRoot) {\n      throw new Error(\n        'Cannot find Android emulator: neither ANDROID_HOME nor ANDROID_SDK_ROOT environment variable is set.'\n      );\n    }\n    return join(sdkRoot, 'emulator', 'emulator');\n  }\n\n  private async sendKeyEvent(deviceId: string, keyCode: number, description: string): Promise<void> {\n    await new Promise<void>((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'input', 'keyevent', String(keyCode)],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error) => {\n          if (error) {\n            this.log(\n              `Warning: failed to ${description} (keyevent ${String(keyCode)}): ${error instanceof Error ? error.message : 'unknown error'}`\n            );\n          }\n\n          resolve();\n        }\n      );\n    });\n  }\n\n  private async startAppiumAndEmulator(params: StartAppiumAndEmulatorParams): Promise<StartAppiumAndEmulatorResult> {\n    const { appiumUrl, avdName, port, shouldAutoStartAppium } = params;\n\n    let needsAppiumStart = false;\n\n    this.log(`Checking Appium server at ${appiumUrl.href}...`);\n    try {\n      await this.checkAppiumReachable(appiumUrl);\n      this.log('Appium server is reachable.');\n    } catch (error: unknown) {\n      if (shouldAutoStartAppium === false) {\n        throw error;\n      }\n      needsAppiumStart = true;\n    }\n\n    let appiumProcess: ChildProcess | undefined;\n\n    if (needsAppiumStart) {\n      this.log(`Appium not reachable, auto-starting on port ${String(port)}...`);\n      appiumProcess = this.startAppiumServer(port);\n    }\n\n    try {\n      const [, deviceResult] = await Promise.all([\n        needsAppiumStart\n          ? this.waitForAppiumReady(appiumUrl).then(() => {\n            this.log('Auto-started Appium server is ready.');\n          })\n          : Promise.resolve(),\n        this.ensureDeviceConnected(avdName)\n      ]);\n\n      return {\n        actualDeviceId: deviceResult.actualDeviceId,\n        appiumProcess,\n        emulatorProcess: deviceResult.emulatorProcess\n      };\n    } catch (error: unknown) {\n      if (appiumProcess) {\n        killProcessTree(appiumProcess);\n        this.log('Killed auto-started Appium server after startup failure.');\n      }\n      throw error;\n    }\n  }\n\n  private startAppiumServer(port: number): ChildProcess {\n    const child = spawn(`npx appium --log-timestamp --port ${String(port)} --allow-insecure=${CHROMEDRIVER_AUTODOWNLOAD_FEATURE}`, {\n      detached: true,\n      shell: true,\n      stdio: ['ignore', 'inherit', 'inherit']\n    });\n\n    child.unref();\n    return child;\n  }\n\n  private startEmulator(avdName: string): ChildProcess {\n    const emulatorBinary = this.resolveEmulatorBinary();\n    const args = buildEmulatorArgs(avdName);\n    this.log(`Running: ${emulatorBinary} ${args.join(' ')}`);\n    const child = spawn(emulatorBinary, args, {\n      detached: true,\n      stdio: ['ignore', 'ignore', 'ignore']\n    });\n\n    child.unref();\n    return child;\n  }\n\n  private async waitForAppiumReady(url: URL): Promise<void> {\n    this.log(\n      `Waiting for Appium at ${url.href} (timeout: ${String(APPIUM_START_TIMEOUT_IN_MILLISECONDS)}ms, poll: ${\n        String(APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS)\n      }ms)...`\n    );\n    const deadline = Date.now() + APPIUM_START_TIMEOUT_IN_MILLISECONDS;\n\n    while (Date.now() < deadline) {\n      try {\n        await this.checkAppiumReachable(url);\n        return;\n      } catch {\n        await new Promise((resolve) => {\n          setTimeout(resolve, APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS);\n        });\n      }\n    }\n\n    throw new Error(\n      `Auto-started Appium server did not become ready within ${String(APPIUM_START_TIMEOUT_IN_MILLISECONDS)}ms`\n    );\n  }\n\n  private async waitForBoot(deviceId: string, deadline: number): Promise<void> {\n    const remainingMs = Math.max(0, deadline - Date.now());\n    this.log(\n      `Waiting for device ${deviceId} to finish booting (remaining: ${String(remainingMs)}ms, poll: ${\n        String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)\n      }ms)...`\n    );\n\n    while (Date.now() < deadline) {\n      const isBooted = await new Promise<boolean>((resolve) => {\n        execFile(\n          'adb',\n          ['-s', deviceId, 'shell', 'getprop', 'sys.boot_completed'],\n          { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n          (_error, stdout) => {\n            resolve(stdout.trim() === '1');\n          }\n        );\n      });\n\n      if (isBooted) {\n        this.log(`Device ${deviceId} boot completed.`);\n        return;\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    throw new Error(\n      `Device \"${deviceId}\" connected but did not finish booting within ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms.`\n    );\n  }\n\n  private async waitForNewDevice(deviceIdsBefore: string[]): Promise<string> {\n    this.log(\n      `Waiting for a new device to appear in ADB (timeout: ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms, poll: ${\n        String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)\n      }ms)...`\n    );\n    const deadline = Date.now() + EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS;\n\n    while (Date.now() < deadline) {\n      const currentIds = await this.getConnectedDeviceIds();\n      const newIds = currentIds.filter((id) => !deviceIdsBefore.includes(id));\n\n      if (newIds.length > 0) {\n        const actualDeviceId = newIds[0] ?? '';\n        this.log(`Device ${actualDeviceId} appeared in ADB, waiting for boot to complete...`);\n        await this.waitForBoot(actualDeviceId, deadline);\n        await this.wakeScreen(actualDeviceId);\n        return actualDeviceId;\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    throw new Error(\n      `No new emulator device appeared within ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms.`\n    );\n  }\n\n  private async wakeScreen(deviceId: string): Promise<void> {\n    this.log(`Waking screen on device ${deviceId}...`);\n\n    await this.sendKeyEvent(deviceId, KEYCODE_WAKEUP, 'wake screen');\n    await this.sendKeyEvent(deviceId, KEYCODE_MENU, 'dismiss lock screen');\n\n    this.log(`Screen wake complete on device ${deviceId}.`);\n  }\n}\n\n/**\n * Creates a new transport instance from the given options.\n *\n * @param options - Transport configuration. Defaults to CLI transport.\n * @returns A new transport instance.\n */\nexport async function createTransportFromOptions(options?: ObsidianTransportOptions): Promise<ObsidianTransport> {\n  const type = options?.type ?? DEFAULT_TRANSPORT_TYPE;\n\n  if (!options || options.type === 'obsidian-cli') {\n    log(`[transport-factory:${type}] Creating DesktopCliTransport`);\n    return new DesktopCliTransport();\n  }\n\n  if (options.type === 'obsidian-cdp') {\n    log(`[transport-factory:${type}] Creating DesktopCdpTransport (host=${options.host ?? 'localhost'}, port=${String(options.port ?? CDP_DEFAULT_PORT)})`);\n    return new DesktopCdpTransport({\n      ...(options.host !== undefined && { cdpHost: options.host }),\n      ...(options.port !== undefined && { cdpPort: options.port }),\n      ...(options.commandTimeoutInMilliseconds !== undefined && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds })\n    });\n  }\n\n  const factory = new AppiumTransportFactory(type);\n  return factory.create(options);\n}\n\n/**\n * Returns a cached transport instance, creating one from the given options\n * if not already cached.\n *\n * The transport is cached per worker process so WebSocket/Appium sessions\n * are reused across calls within the same test worker.\n *\n * @param options - Transport configuration. Defaults to CLI transport.\n * @returns The cached or newly created transport.\n */\nexport async function getOrCreateTransport(options?: ObsidianTransportOptions): Promise<ObsidianTransport> {\n  if (cachedTransport) {\n    return cachedTransport;\n  }\n\n  const result = await createTransportFromOptions(options);\n  // eslint-disable-next-line require-atomic-updates -- Single-threaded worker; no concurrent writes.\n  cachedTransport = result;\n  return result;\n}\n\n/**\n * Kills a child process and its entire process tree.\n *\n * On Windows, `child.kill()` only sends SIGTERM to the direct process,\n * leaving spawned grandchildren (e.g. QEMU, UiAutomator) alive.\n * `taskkill /F /T /PID` forcefully terminates the entire tree.\n *\n * @param child - The child process to kill.\n */\nfunction killProcessTree(child: ChildProcess): void {\n  if (child.pid === undefined) {\n    return;\n  }\n\n  if (process.platform === 'win32') {\n    try {\n      execFileSync('taskkill', ['/F', '/T', '/PID', String(child.pid)], { stdio: 'ignore' });\n    } catch (error: unknown) {\n      log(\n        `[transport-factory] taskkill for PID ${String(child.pid)} failed (may have already exited): ${\n          error instanceof Error ? error.message : 'unknown error'\n        }`\n      );\n    }\n  } else {\n    child.kill('SIGKILL');\n  }\n}\n\n/**\n * Removes `Connection` and `Content-Length` from a WebDriver request's headers.\n *\n * The bundled `webdriver` package sets both headers explicitly. They are\n * forbidden request headers per the Fetch spec: Node up to 25 accepted them\n * silently, but Node 26 rejects them with `UND_ERR_INVALID_ARG`, breaking the\n * Appium `/session` request. The transport layer manages connection reuse and\n * the Fetch API computes `Content-Length` from the body, so dropping both is\n * safe on every Node version. See {@link https://github.com/webdriverio/webdriverio/issues/15265}.\n *\n * @param requestOptions - The request options about to be sent by WebDriverIO.\n * @returns The same request options with the forbidden headers removed.\n */\nfunction stripForbiddenFetchHeaders(requestOptions: RequestInit): RequestInit {\n  if (requestOptions.headers instanceof Headers) {\n    requestOptions.headers.delete('Connection');\n    requestOptions.headers.delete('Content-Length');\n  }\n\n  return requestOptions;\n}\n\n/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAUA,gCAIO;AACP,uBAAiB;AACjB,uBAAqB;AACrB,0BAAoB;AACpB,yBAGO;AAQP,2BAAkC;AAClC,iBAAoB;AACpB,8BAAgC;AAChC,mCAAoC;AACpC,mCAAoC;AAEpC,MAAM,cAAc;AACpB,MAAM,eAAe,GAAG,WAAW;AACnC,MAAM,2CAA2C;AACjD,MAAM,gCAAgC;AACtC,MAAM,kDAAkD;AACxD,MAAM,2CAA2C;AACjD,MAAM,6CAA6C;AACnD,MAAM,uCAAuC;AAC7C,MAAM,mBAAmB;AAKzB,MAAM,oCAAoC;AAC1C,MAAM,kCAAkC;AACxC,MAAM,yBAAyB;AAC/B,MAAM,8CAA8C;AACpD,MAAM,wCAAwC;AAC9C,MAAM,eAAe;AACrB,MAAM,iBAAiB;AACvB,MAAM,yCAAyC;AAC/C,MAAM,wCAAwC;AA4C9C,IAAI;AASJ,MAAM,uBAAuB;AAAA,EACV;AAAA,EAEV,YAAY,MAAc;AAC/B,SAAK,OAAO;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,MAAa,OAAO,SAA4E;AAC9F,QAAI,QAAQ,cAAc,UAAa,QAAQ,aAAa,QAAW;AACrE,aAAO,KAAK,wBAAwB,QAAQ,WAAW,QAAQ,UAAU,OAAO;AAAA,IAClF;AAEA,WAAO,KAAK,iBAAiB,OAAO;AAAA,EACtC;AAAA,EAEA,MAAc,wBACZ,WACA,UACA,SAC4B;AAC5B,UAAM,MAAM,IAAI,IAAI,QAAQ,SAAS;AACrC,UAAM,OAAO,OAAO,IAAI,IAAI;AAC5B,UAAM,QAAQ,QAAQ,SAAS;AAE/B,SAAK,IAAI,0CAA0C,SAAS,YAAY,QAAQ,GAAG;AAEnF,UAAM,UAAU,UAAM,2BAAO;AAAA,MAC3B,cAAc;AAAA,QACZ,cAAc;AAAA,MAChB;AAAA,MACA,UAAU,IAAI;AAAA,MACd,UAAU;AAAA,MACV,MAAM,IAAI;AAAA,MACV;AAAA,MACA;AAAA,MACA,kBAAkB;AAAA,IACpB,CAAC;AAED,SAAK,IAAI,+BAA+B;AAExC,WAAO,IAAI,wCAAgB;AAAA,MACzB;AAAA,MACA;AAAA,MACA;AAAA,MACA,gBAAgB;AAAA,MAChB,UAAU;AAAA,MACV,GAAI,QAAQ,kBAAkB,UAAa,EAAE,eAAe,QAAQ,cAAc;AAAA,MAClF,GAAI,QAAQ,iCAAiC,UAAa,EAAE,8BAA8B,QAAQ,6BAA6B;AAAA,IACjI,CAAC;AAAA,EACH;AAAA,EAEQ,qBAAqB,KAAyB;AACpD,WAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,YAAM,YAAY,IAAI,IAAI,WAAW,GAAG;AACxC,YAAM,MAAM,iBAAAA,QAAK,IAAI,WAAW,EAAE,SAAS,yCAAyC,GAAG,CAAC,QAAQ;AAC9F,YAAI,OAAO;AACX,gBAAQ;AAAA,MACV,CAAC;AACD,UAAI,GAAG,WAAW,MAAM;AACtB,YAAI,QAAQ;AACZ;AAAA,UACE,IAAI;AAAA,YACF,oBAAoB,IAAI,MAAM,2BAA2B,OAAO,wCAAwC,CAAC;AAAA,UAC3G;AAAA,QACF;AAAA,MACF,CAAC;AACD,UAAI,GAAG,SAAS,CAAC,QAAQ;AACvB;AAAA,UACE,IAAI;AAAA,YACF,iCAAiC,IAAI,MAAM,KAAK,IAAI,OAAO;AAAA,UAC7D;AAAA,QACF;AAAA,MACF,CAAC;AAAA,IACH,CAAC;AAAA,EACH;AAAA,EAEA,MAAc,iBAAiB,SAA4E;AACzG,SAAK,IAAI,iCAAiC,QAAQ,SAAS,SAAS,QAAQ,OAAO,GAAG;AAEtF,UAAM,MAAM,IAAI,IAAI,QAAQ,SAAS;AAErC,UAAM,OAAO,OAAO,IAAI,IAAI;AAC5B,QAAI,MAAM,IAAI,GAAG;AACf,YAAM,IAAI,MAAM,8BAA8B,IAAI,IAAI,EAAE;AAAA,IAC1D;AAEA,UAAM,QAAQ,QAAQ,SAAS;AAE/B,QAAI;AACJ,QAAI;AAEJ,QAAI;AAiEF,UAASC,4BAAT,WAA0C;AACxC,YAAI,eAAe;AACjB,0BAAgB,aAAa;AAE7B,8BAAI,sBAAsB,QAAQ,IAAI,uCAAuC;AAAA,QAC/E;AACA,YAAI,iBAAiB;AACnB,0BAAgB,eAAe;AAC/B,8BAAI,sBAAsB,QAAQ,IAAI,kCAAkC;AAAA,QAC1E;AAAA,MACF;AAVS,qCAAAA;AAhET,YAAM,SAAS,MAAM,KAAK,uBAAuB;AAAA,QAC/C,WAAW;AAAA,QACX,SAAS,QAAQ;AAAA,QACjB;AAAA,QACA,uBAAuB,QAAQ;AAAA,MACjC,CAAC;AAED,sBAAgB,OAAO;AACvB,wBAAkB,OAAO;AACzB,YAAM,iBAAiB,OAAO;AAE9B,WAAK;AAAA,QACH,gCAAgC,cAAc,SAAS,KAAK,mBAAmB,OAAO,+CAA+C,CAAC,gBACpI,OAAO,6BAA6B,CACtC;AAAA,MACF;AACA,YAAM,UAAU,UAAM,2BAAO;AAAA,QAC3B,cAAc;AAAA,UACZ,sBAAsB;AAAA,UACtB,qBAAqB;AAAA,UACrB,+BAA+B;AAAA,UAC/B,yBAAyB;AAAA,UACzB,4BAA4B;AAAA,UAC5B,kBAAkB;AAAA,UAClB,eAAe;AAAA,UACf,2CAA2C;AAAA,UAC3C,0CAA0C;AAAA,UAC1C,gBAAgB;AAAA,QAClB;AAAA,QACA,sBAAsB;AAAA,QACtB,wBAAwB;AAAA,QACxB,UAAU,IAAI;AAAA,QACd,UAAU;AAAA,QACV,MAAM,IAAI;AAAA,QACV;AAAA,QACA,kBAAkB;AAAA,MACpB,CAAC;AAED,WAAK,IAAI,6BAA6B;AACtC,YAAM,kBAAkB,IAAI,wCAAgB;AAAA,QAC1C;AAAA,QACA;AAAA,QACA,UAAU;AAAA,QACV,UAAU;AAAA,QACV,GAAI,QAAQ,kBAAkB,UAAa,EAAE,eAAe,QAAQ,cAAc;AAAA,QAClF,GAAI,QAAQ,iCAAiC,UAAa,EAAE,8BAA8B,QAAQ,6BAA6B;AAAA,MACjI,CAAC;AAED,YAAM,kBAAkB,gBAAgB,QAAQ,KAAK,eAAe;AACpE,YAAM,YAA+B;AACrC,gBAAU,UAAU,YAA2B;AAC7C,YAAI;AACF,gBAAM,gBAAgB;AAAA,QACxB,UAAE;AACA,UAAAA,0BAAyB;AAAA,QAC3B;AAAA,MACF;AAEA,gBAAU,cAAc,MAAY;AAClC,QAAAA,0BAAyB;AAAA,MAC3B;AAEA,aAAO;AAAA,IAaT,SAAS,OAAgB;AACvB,UAAI,eAAe;AACjB,wBAAgB,aAAa;AAC7B,aAAK,IAAI,6DAA6D;AAAA,MACxE;AACA,UAAI,iBAAiB;AACnB,wBAAgB,eAAe;AAC/B,aAAK,IAAI,wDAAwD;AAAA,MACnE;AACA,YAAM;AAAA,IACR;AAAA,EACF;AAAA,EAEA,MAAc,sBAAsB,SAAuD;AACzF,UAAM,kBAAkB,MAAM,KAAK,sBAAsB;AACzD,SAAK,IAAI,sCAAsC,OAAO,qBAAqB,gBAAgB,KAAK,IAAI,CAAC,IAAI;AAEzG,UAAM,mBAAmB,MAAM,KAAK,oBAAoB,SAAS,eAAe;AAEhF,QAAI,kBAAkB;AACpB,WAAK,IAAI,QAAQ,OAAO,kCAAkC,gBAAgB,YAAY;AACtF,aAAO,EAAE,gBAAgB,iBAAiB;AAAA,IAC5C;AAEA,SAAK,IAAI,QAAQ,OAAO,gEAAgE;AACxF,UAAM,kBAAkB,KAAK,cAAc,OAAO;AAClD,UAAM,iBAAiB,MAAM,KAAK,iBAAiB,eAAe;AAClE,SAAK,IAAI,aAAa,OAAO,qBAAqB,cAAc,gBAAgB;AAChF,WAAO,EAAE,gBAAgB,gBAAgB;AAAA,EAC3C;AAAA,EAEA,MAAc,oBAAoB,SAAiB,WAAkD;AACnG,eAAW,YAAY,WAAW;AAChC,YAAM,aAAa,MAAM,IAAI,QAAgB,CAAC,YAAY;AACxD;AAAA,UACE;AAAA,UACA,CAAC,MAAM,UAAU,OAAO,OAAO,MAAM;AAAA,UACrC,EAAE,SAAS,yCAAyC;AAAA,UACpD,CAAC,QAAQ,WAAW;AAClB,oBAAQ,OAAO,MAAM,IAAI,EAAE,CAAC,GAAG,KAAK,KAAK,EAAE;AAAA,UAC7C;AAAA,QACF;AAAA,MACF,CAAC;AAED,UAAI,eAAe,SAAS;AAC1B,eAAO;AAAA,MACT;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAAA,EAEA,MAAc,wBAA2C;AACvD,UAAM,SAAS,MAAM,IAAI,QAAgB,CAAC,SAAS,WAAW;AAC5D,8CAAS,OAAO,CAAC,SAAS,GAAG,EAAE,SAAS,yCAAyC,GAAG,CAAC,OAAO,QAAQ,WAAW;AAC7G,YAAI,OAAO;AACT,iBAAO,IAAI,MAAM,gCAAgC,MAAM,OAAO,iCAAiC,CAAC;AAChG;AAAA,QACF;AACA,YAAI,QAAQ;AACV,eAAK,IAAI,eAAe,OAAO,KAAK,CAAC,EAAE;AAAA,QACzC;AACA,gBAAQ,MAAM;AAAA,MAChB,CAAC;AAAA,IACH,CAAC;AAED,UAAM,QAAQ,OAAO,MAAM,IAAI,EAAE,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,EAAE,OAAO,CAAC,SAAS,KAAK,SAAS,CAAC;AAC5F,WAAO,MACJ,OAAO,CAAC,SAAS,KAAK,SAAS,SAAU,CAAC,EAC1C,IAAI,CAAC,SAAS,KAAK,MAAM,GAAI,EAAE,CAAC,KAAK,EAAE;AAAA,EAC5C;AAAA,EAEQ,IAAI,SAAuB;AACjC,wBAAI,sBAAsB,KAAK,IAAI,KAAK,OAAO,EAAE;AAAA,EACnD;AAAA,EAEQ,wBAAgC;AACtC,UAAM,UAAU,oBAAAC,QAAQ,IAAI,cAAc,KAAK,oBAAAA,QAAQ,IAAI,kBAAkB;AAC7E,QAAI,CAAC,SAAS;AACZ,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AACA,eAAO,uBAAK,SAAS,YAAY,UAAU;AAAA,EAC7C;AAAA,EAEA,MAAc,aAAa,UAAkB,SAAiB,aAAoC;AAChG,UAAM,IAAI,QAAc,CAAC,YAAY;AACnC;AAAA,QACE;AAAA,QACA,CAAC,MAAM,UAAU,SAAS,SAAS,YAAY,OAAO,OAAO,CAAC;AAAA,QAC9D,EAAE,SAAS,yCAAyC;AAAA,QACpD,CAAC,UAAU;AACT,cAAI,OAAO;AACT,iBAAK;AAAA,cACH,sBAAsB,WAAW,cAAc,OAAO,OAAO,CAAC,MAAM,iBAAiB,QAAQ,MAAM,UAAU,eAAe;AAAA,YAC9H;AAAA,UACF;AAEA,kBAAQ;AAAA,QACV;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EAEA,MAAc,uBAAuB,QAA6E;AAChH,UAAM,EAAE,WAAW,SAAS,MAAM,sBAAsB,IAAI;AAE5D,QAAI,mBAAmB;AAEvB,SAAK,IAAI,6BAA6B,UAAU,IAAI,KAAK;AACzD,QAAI;AACF,YAAM,KAAK,qBAAqB,SAAS;AACzC,WAAK,IAAI,6BAA6B;AAAA,IACxC,SAAS,OAAgB;AACvB,UAAI,0BAA0B,OAAO;AACnC,cAAM;AAAA,MACR;AACA,yBAAmB;AAAA,IACrB;AAEA,QAAI;AAEJ,QAAI,kBAAkB;AACpB,WAAK,IAAI,+CAA+C,OAAO,IAAI,CAAC,KAAK;AACzE,sBAAgB,KAAK,kBAAkB,IAAI;AAAA,IAC7C;AAEA,QAAI;AACF,YAAM,CAAC,EAAE,YAAY,IAAI,MAAM,QAAQ,IAAI;AAAA,QACzC,mBACI,KAAK,mBAAmB,SAAS,EAAE,KAAK,MAAM;AAC9C,eAAK,IAAI,sCAAsC;AAAA,QACjD,CAAC,IACC,QAAQ,QAAQ;AAAA,QACpB,KAAK,sBAAsB,OAAO;AAAA,MACpC,CAAC;AAED,aAAO;AAAA,QACL,gBAAgB,aAAa;AAAA,QAC7B;AAAA,QACA,iBAAiB,aAAa;AAAA,MAChC;AAAA,IACF,SAAS,OAAgB;AACvB,UAAI,eAAe;AACjB,wBAAgB,aAAa;AAC7B,aAAK,IAAI,0DAA0D;AAAA,MACrE;AACA,YAAM;AAAA,IACR;AAAA,EACF;AAAA,EAEQ,kBAAkB,MAA4B;AACpD,UAAM,YAAQ,iCAAM,qCAAqC,OAAO,IAAI,CAAC,qBAAqB,iCAAiC,IAAI;AAAA,MAC7H,UAAU;AAAA,MACV,OAAO;AAAA,MACP,OAAO,CAAC,UAAU,WAAW,SAAS;AAAA,IACxC,CAAC;AAED,UAAM,MAAM;AACZ,WAAO;AAAA,EACT;AAAA,EAEQ,cAAc,SAA+B;AACnD,UAAM,iBAAiB,KAAK,sBAAsB;AAClD,UAAM,WAAO,wCAAkB,OAAO;AACtC,SAAK,IAAI,YAAY,cAAc,IAAI,KAAK,KAAK,GAAG,CAAC,EAAE;AACvD,UAAM,YAAQ,iCAAM,gBAAgB,MAAM;AAAA,MACxC,UAAU;AAAA,MACV,OAAO,CAAC,UAAU,UAAU,QAAQ;AAAA,IACtC,CAAC;AAED,UAAM,MAAM;AACZ,WAAO;AAAA,EACT;AAAA,EAEA,MAAc,mBAAmB,KAAyB;AACxD,SAAK;AAAA,MACH,yBAAyB,IAAI,IAAI,cAAc,OAAO,oCAAoC,CAAC,aACzF,OAAO,0CAA0C,CACnD;AAAA,IACF;AACA,UAAM,WAAW,KAAK,IAAI,IAAI;AAE9B,WAAO,KAAK,IAAI,IAAI,UAAU;AAC5B,UAAI;AACF,cAAM,KAAK,qBAAqB,GAAG;AACnC;AAAA,MACF,QAAQ;AACN,cAAM,IAAI,QAAQ,CAAC,YAAY;AAC7B,qBAAW,SAAS,0CAA0C;AAAA,QAChE,CAAC;AAAA,MACH;AAAA,IACF;AAEA,UAAM,IAAI;AAAA,MACR,0DAA0D,OAAO,oCAAoC,CAAC;AAAA,IACxG;AAAA,EACF;AAAA,EAEA,MAAc,YAAY,UAAkB,UAAiC;AAC3E,UAAM,cAAc,KAAK,IAAI,GAAG,WAAW,KAAK,IAAI,CAAC;AACrD,SAAK;AAAA,MACH,sBAAsB,QAAQ,kCAAkC,OAAO,WAAW,CAAC,aACjF,OAAO,2CAA2C,CACpD;AAAA,IACF;AAEA,WAAO,KAAK,IAAI,IAAI,UAAU;AAC5B,YAAM,WAAW,MAAM,IAAI,QAAiB,CAAC,YAAY;AACvD;AAAA,UACE;AAAA,UACA,CAAC,MAAM,UAAU,SAAS,WAAW,oBAAoB;AAAA,UACzD,EAAE,SAAS,yCAAyC;AAAA,UACpD,CAAC,QAAQ,WAAW;AAClB,oBAAQ,OAAO,KAAK,MAAM,GAAG;AAAA,UAC/B;AAAA,QACF;AAAA,MACF,CAAC;AAED,UAAI,UAAU;AACZ,aAAK,IAAI,UAAU,QAAQ,kBAAkB;AAC7C;AAAA,MACF;AAEA,YAAM,IAAI,QAAQ,CAAC,YAAY;AAC7B,mBAAW,SAAS,2CAA2C;AAAA,MACjE,CAAC;AAAA,IACH;AAEA,UAAM,IAAI;AAAA,MACR,WAAW,QAAQ,iDAAiD,OAAO,qCAAqC,CAAC;AAAA,IACnH;AAAA,EACF;AAAA,EAEA,MAAc,iBAAiB,iBAA4C;AACzE,SAAK;AAAA,MACH,uDAAuD,OAAO,qCAAqC,CAAC,aAClG,OAAO,2CAA2C,CACpD;AAAA,IACF;AACA,UAAM,WAAW,KAAK,IAAI,IAAI;AAE9B,WAAO,KAAK,IAAI,IAAI,UAAU;AAC5B,YAAM,aAAa,MAAM,KAAK,sBAAsB;AACpD,YAAM,SAAS,WAAW,OAAO,CAAC,OAAO,CAAC,gBAAgB,SAAS,EAAE,CAAC;AAEtE,UAAI,OAAO,SAAS,GAAG;AACrB,cAAM,iBAAiB,OAAO,CAAC,KAAK;AACpC,aAAK,IAAI,UAAU,cAAc,mDAAmD;AACpF,cAAM,KAAK,YAAY,gBAAgB,QAAQ;AAC/C,cAAM,KAAK,WAAW,cAAc;AACpC,eAAO;AAAA,MACT;AAEA,YAAM,IAAI,QAAQ,CAAC,YAAY;AAC7B,mBAAW,SAAS,2CAA2C;AAAA,MACjE,CAAC;AAAA,IACH;AAEA,UAAM,IAAI;AAAA,MACR,0CAA0C,OAAO,qCAAqC,CAAC;AAAA,IACzF;AAAA,EACF;AAAA,EAEA,MAAc,WAAW,UAAiC;AACxD,SAAK,IAAI,2BAA2B,QAAQ,KAAK;AAEjD,UAAM,KAAK,aAAa,UAAU,gBAAgB,aAAa;AAC/D,UAAM,KAAK,aAAa,UAAU,cAAc,qBAAqB;AAErE,SAAK,IAAI,kCAAkC,QAAQ,GAAG;AAAA,EACxD;AACF;AAQA,eAAsB,2BAA2B,SAAgE;AAC/G,QAAM,OAAO,SAAS,QAAQ;AAE9B,MAAI,CAAC,WAAW,QAAQ,SAAS,gBAAgB;AAC/C,wBAAI,sBAAsB,IAAI,gCAAgC;AAC9D,WAAO,IAAI,iDAAoB;AAAA,EACjC;AAEA,MAAI,QAAQ,SAAS,gBAAgB;AACnC,wBAAI,sBAAsB,IAAI,wCAAwC,QAAQ,QAAQ,WAAW,UAAU,OAAO,QAAQ,QAAQ,gBAAgB,CAAC,GAAG;AACtJ,WAAO,IAAI,iDAAoB;AAAA,MAC7B,GAAI,QAAQ,SAAS,UAAa,EAAE,SAAS,QAAQ,KAAK;AAAA,MAC1D,GAAI,QAAQ,SAAS,UAAa,EAAE,SAAS,QAAQ,KAAK;AAAA,MAC1D,GAAI,QAAQ,iCAAiC,UAAa,EAAE,8BAA8B,QAAQ,6BAA6B;AAAA,IACjI,CAAC;AAAA,EACH;AAEA,QAAM,UAAU,IAAI,uBAAuB,IAAI;AAC/C,SAAO,QAAQ,OAAO,OAAO;AAC/B;AAYA,eAAsB,qBAAqB,SAAgE;AACzG,MAAI,iBAAiB;AACnB,WAAO;AAAA,EACT;AAEA,QAAM,SAAS,MAAM,2BAA2B,OAAO;AAEvD,oBAAkB;AAClB,SAAO;AACT;AAWA,SAAS,gBAAgB,OAA2B;AAClD,MAAI,MAAM,QAAQ,QAAW;AAC3B;AAAA,EACF;AAEA,MAAI,oBAAAA,QAAQ,aAAa,SAAS;AAChC,QAAI;AACF,kDAAa,YAAY,CAAC,MAAM,MAAM,QAAQ,OAAO,MAAM,GAAG,CAAC,GAAG,EAAE,OAAO,SAAS,CAAC;AAAA,IACvF,SAAS,OAAgB;AACvB;AAAA,QACE,wCAAwC,OAAO,MAAM,GAAG,CAAC,sCACvD,iBAAiB,QAAQ,MAAM,UAAU,eAC3C;AAAA,MACF;AAAA,IACF;AAAA,EACF,OAAO;AACL,UAAM,KAAK,SAAS;AAAA,EACtB;AACF;AAeA,SAAS,2BAA2B,gBAA0C;AAC5E,MAAI,eAAe,mBAAmB,SAAS;AAC7C,mBAAe,QAAQ,OAAO,YAAY;AAC1C,mBAAe,QAAQ,OAAO,gBAAgB;AAAA,EAChD;AAEA,SAAO;AACT;",
  "names": ["http", "killAutoStartedProcesses", "process"]
}


package/dist/lib/cjs/type-guards.cjs

@@ -19,6 +19,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var type_guards_exports = {};
 __export(type_guards_exports, {
   assertNonNullable: () => assertNonNullable,
+  castTo: () => castTo,
+  ensureGenericObject: () => ensureGenericObject,
   ensureNonNullable: () => ensureNonNullable
 });
 module.exports = __toCommonJS(type_guards_exports);
@@ -30,6 +32,12 @@ function assertNonNullable(value, errorOrMessage) {
   const error = typeof errorOrMessage === "string" ? new Error(errorOrMessage) : errorOrMessage;
   throw error;
 }
+function castTo(value) {
+  return value;
+}
+function ensureGenericObject(obj) {
+  return obj;
+}
 function ensureNonNullable(value, errorOrMessage) {
   assertNonNullable(value, errorOrMessage);
   return value;
@@ -37,6 +45,8 @@ function ensureNonNullable(value, errorOrMessage) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   assertNonNullable,
+  castTo,
+  ensureGenericObject,
   ensureNonNullable
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3R5cGUtZ3VhcmRzLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogQ29udGFpbnMgdXRpbGl0eSBmdW5jdGlvbnMgZm9yIHR5cGUgZ3VhcmRzLlxuICovXG5cbi8qKlxuICogQSBnZW5lcmljIG9iamVjdCB3aXRoIGBzdHJpbmdgIGtleXMgYW5kIGB1bmtub3duYCB2YWx1ZXMuXG4gKlxuICogVXNlZCBhcyBhIHdpZGVuaW5nIHRhcmdldCBmb3IgZHluYW1pYyBwcm9wZXJ0eSBhY2Nlc3Mgb24gbW9jayBvYmplY3RzLlxuICovXG5leHBvcnQgdHlwZSBHZW5lcmljT2JqZWN0ID0gUmVjb3JkPHN0cmluZywgdW5rbm93bj47XG5cbnR5cGUgTnVsbGFibGVDb25zdHJhaW50PFQ+ID0gbnVsbCBleHRlbmRzIFQgPyB1bmtub3duIDogdW5kZWZpbmVkIGV4dGVuZHMgVCA/IHVua25vd24gOiBuZXZlcjtcblxuLyoqXG4gKiBBc3NlcnRzIHRoYXQgYSB2YWx1ZSBpcyBub3QgYG51bGxgIG9yIGB1bmRlZmluZWRgLCBuYXJyb3dpbmcgaXRzIHR5cGUgaW4gcGxhY2UuXG4gKlxuICogT25seSBjYWxsYWJsZSB3aGVuIGBUYCBpbmNsdWRlcyBgbnVsbGAgb3IgYHVuZGVmaW5lZGAuIFBhc3NpbmcgYW4gYWxyZWFkeSBub24tbnVsbGFibGUgdHlwZSBpcyBhIGNvbXBpbGUgZXJyb3IuXG4gKlxuICogQHR5cGVQYXJhbSBUIC0gVGhlIHR5cGUgb2YgdGhlIHZhbHVlLlxuICogQHBhcmFtIHZhbHVlIC0gVGhlIHZhbHVlIHRvIGNoZWNrLlxuICogQHBhcmFtIGVycm9yT3JNZXNzYWdlIC0gT3B0aW9uYWwge0BsaW5rIEVycm9yfSBvciBlcnJvciBtZXNzYWdlIHN0cmluZy5cbiAqIEB0aHJvd3MgSWYgdGhlIHZhbHVlIGlzIGBudWxsYCBvciBgdW5kZWZpbmVkYC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGFzc2VydE5vbk51bGxhYmxlPFQgZXh0ZW5kcyBOdWxsYWJsZUNvbnN0cmFpbnQ8VD4+KHZhbHVlOiBULCBlcnJvck9yTWVzc2FnZT86IEVycm9yIHwgc3RyaW5nKTogYXNzZXJ0cyB2YWx1ZSBpcyBOb25OdWxsYWJsZTxUPiB7XG4gIGlmICh2YWx1ZSAhPT0gbnVsbCAmJiB2YWx1ZSAhPT0gdW5kZWZpbmVkKSB7XG4gICAgcmV0dXJuO1xuICB9XG5cbiAgZXJyb3JPck1lc3NhZ2UgPz89IHZhbHVlID09PSBudWxsID8gJ1ZhbHVlIGlzIG51bGwnIDogJ1ZhbHVlIGlzIHVuZGVmaW5lZCc7XG4gIGNvbnN0IGVycm9yID0gdHlwZW9mIGVycm9yT3JNZXNzYWdlID09PSAnc3RyaW5nJyA/IG5ldyBFcnJvcihlcnJvck9yTWVzc2FnZSkgOiBlcnJvck9yTWVzc2FnZTtcbiAgdGhyb3cgZXJyb3I7XG59XG5cbi8qKlxuICogQ2FzdHMgYSB2YWx1ZSB0byBhIHNwZWNpZmljIHR5cGUgd2l0aG91dCBhbnkgcnVudGltZSBjaGVjay5cbiAqXG4gKiBQcmVmZXIgdGhpcyBvdmVyIGlubGluZSBgYXNgIGFzc2VydGlvbnM6IGl0IGtlZXBzIHRoZSB1bnNhZmUgY2FzdCBpbiBvbmVcbiAqIGF1ZGl0YWJsZSBwbGFjZSBhbmQgcmVhZHMgYXMgYW4gZXhwbGljaXQsIGludGVudGlvbmFsIGVzY2FwZSBoYXRjaC5cbiAqXG4gKiBAdHlwZVBhcmFtIFQgLSBUaGUgdGFyZ2V0IHR5cGUgdG8gY2FzdCB0by5cbiAqIEBwYXJhbSB2YWx1ZSAtIFRoZSB2YWx1ZSB0byBjYXN0LlxuICogQHJldHVybnMgVGhlIHZhbHVlIHR5cGVkIGFzIGBUYC5cbiAqL1xuLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEB0eXBlc2NyaXB0LWVzbGludC9uby11bm5lY2Vzc2FyeS10eXBlLXBhcmFtZXRlcnMgLS0gVGhlIHR5cGUgcGFyYW1ldGVyIGlzIHRoZSBjYXN0IHRhcmdldDsgaXQgY2Fubm90IGJlIGluZmVycmVkIGZyb20gdGhlIGB1bmtub3duYCBhcmd1bWVudC5cbmV4cG9ydCBmdW5jdGlvbiBjYXN0VG88VD4odmFsdWU6IHVua25vd24pOiBUIHtcbiAgcmV0dXJuIHZhbHVlIGFzIFQ7XG59XG5cbi8qKlxuICogV2lkZW5zIGFuIG9iamVjdCB0byBhIHtAbGluayBHZW5lcmljT2JqZWN0fSBzbyBkeW5hbWljIHN0cmluZy1rZXllZCBwcm9wZXJ0eVxuICogYWNjZXNzIHR5cGUtY2hlY2tzLlxuICpcbiAqIEB0eXBlUGFyYW0gVCAtIFRoZSBvYmplY3QgdHlwZS5cbiAqIEBwYXJhbSBvYmogLSBUaGUgb2JqZWN0IHRvIHdpZGVuLlxuICogQHJldHVybnMgVGhlIHNhbWUgb2JqZWN0IHR5cGVkIGFzIGBHZW5lcmljT2JqZWN0ICYgVGAuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBlbnN1cmVHZW5lcmljT2JqZWN0PFQgZXh0ZW5kcyBvYmplY3Q+KG9iajogVCk6IEdlbmVyaWNPYmplY3QgJiBUIHtcbiAgcmV0dXJuIG9iaiBhcyBHZW5lcmljT2JqZWN0ICYgVDtcbn1cblxuLyoqXG4gKiBFbnN1cmVzIHRoYXQgYSB2YWx1ZSBpcyBub3QgYG51bGxgIG9yIGB1bmRlZmluZWRgIGFuZCByZXR1cm5zIGl0IHdpdGggbmFycm93ZWQgdHlwZS5cbiAqXG4gKiBPbmx5IGNhbGxhYmxlIHdoZW4gYFRgIGluY2x1ZGVzIGBudWxsYCBvciBgdW5kZWZpbmVkYC4gUGFzc2luZyBhbiBhbHJlYWR5IG5vbi1udWxsYWJsZSB0eXBlIGlzIGEgY29tcGlsZSBlcnJvci5cbiAqXG4gKiBAdHlwZVBhcmFtIFQgLSBUaGUgdHlwZSBvZiB0aGUgdmFsdWUuXG4gKiBAcGFyYW0gdmFsdWUgLSBUaGUgdmFsdWUgdG8gY2hlY2suXG4gKiBAcGFyYW0gZXJyb3JPck1lc3NhZ2UgLSBPcHRpb25hbCB7QGxpbmsgRXJyb3J9IG9yIGVycm9yIG1lc3NhZ2Ugc3RyaW5nLlxuICogQHJldHVybnMgVGhlIHZhbHVlIHdpdGggYG51bGxgIGFuZCBgdW5kZWZpbmVkYCBleGNsdWRlZCBmcm9tIGl0cyB0eXBlLlxuICogQHRocm93cyBJZiB0aGUgdmFsdWUgaXMgYG51bGxgIG9yIGB1bmRlZmluZWRgLlxuICovXG5leHBvcnQgZnVuY3Rpb24gZW5zdXJlTm9uTnVsbGFibGU8VCBleHRlbmRzIE51bGxhYmxlQ29uc3RyYWludDxUPj4odmFsdWU6IFQsIGVycm9yT3JNZXNzYWdlPzogRXJyb3IgfCBzdHJpbmcpOiBOb25OdWxsYWJsZTxUPiB7XG4gIGFzc2VydE5vbk51bGxhYmxlKHZhbHVlLCBlcnJvck9yTWVzc2FnZSk7XG4gIHJldHVybiB2YWx1ZTtcbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUF5Qk8sU0FBUyxrQkFBbUQsT0FBVSxnQkFBa0U7QUFDN0ksTUFBSSxVQUFVLFFBQVEsVUFBVSxRQUFXO0FBQ3pDO0FBQUEsRUFDRjtBQUVBLHFCQUFtQixVQUFVLE9BQU8sa0JBQWtCO0FBQ3RELFFBQU0sUUFBUSxPQUFPLG1CQUFtQixXQUFXLElBQUksTUFBTSxjQUFjLElBQUk7QUFDL0UsUUFBTTtBQUNSO0FBYU8sU0FBUyxPQUFVLE9BQW1CO0FBQzNDLFNBQU87QUFDVDtBQVVPLFNBQVMsb0JBQXNDLEtBQTJCO0FBQy9FLFNBQU87QUFDVDtBQWFPLFNBQVMsa0JBQW1ELE9BQVUsZ0JBQWlEO0FBQzVILG9CQUFrQixPQUFPLGNBQWM7QUFDdkMsU0FBTztBQUNUOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/cjs/type-guards.d.cts

@@ -3,6 +3,12 @@
  *
  * Contains utility functions for type guards.
  */
+/**
+ * A generic object with `string` keys and `unknown` values.
+ *
+ * Used as a widening target for dynamic property access on mock objects.
+ */
+export type GenericObject = Record<string, unknown>;
 type NullableConstraint<T> = null extends T ? unknown : undefined extends T ? unknown : never;
 /**
  * Asserts that a value is not `null` or `undefined`, narrowing its type in place.
@@ -15,6 +21,26 @@ type NullableConstraint<T> = null extends T ? unknown : undefined extends T ? un
  * @throws If the value is `null` or `undefined`.
  */
 export declare function assertNonNullable<T extends NullableConstraint<T>>(value: T, errorOrMessage?: Error | string): asserts value is NonNullable<T>;
+/**
+ * Casts a value to a specific type without any runtime check.
+ *
+ * Prefer this over inline `as` assertions: it keeps the unsafe cast in one
+ * auditable place and reads as an explicit, intentional escape hatch.
+ *
+ * @typeParam T - The target type to cast to.
+ * @param value - The value to cast.
+ * @returns The value typed as `T`.
+ */
+export declare function castTo<T>(value: unknown): T;
+/**
+ * Widens an object to a {@link GenericObject} so dynamic string-keyed property
+ * access type-checks.
+ *
+ * @typeParam T - The object type.
+ * @param obj - The object to widen.
+ * @returns The same object typed as `GenericObject & T`.
+ */
+export declare function ensureGenericObject<T extends object>(obj: T): GenericObject & T;
 /**
  * Ensures that a value is not `null` or `undefined` and returns it with narrowed type.
  *

package/dist/lib/esm/library.mjs

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

package/dist/lib/esm/strict-proxy.d.mts

@@ -0,0 +1,44 @@
+/**
+ * @file
+ *
+ * Strict proxy for mock objects.
+ *
+ * Wraps an object in a `Proxy` that throws a descriptive error when any
+ * unmocked property is accessed, instead of silently returning `undefined`.
+ *
+ * - Idempotent (double-wrapping is a no-op).
+ * - Passthrough for well-known props (`then`, `toJSON`, `Symbol.iterator`, etc.).
+ * - Class-name-aware error messages for class instances.
+ * - Recursive proxying of nested plain objects (for partial mocks only).
+ *
+ * Overloads:
+ * 1. `strictProxy(value, MockClass)` — infers `T` from `MockClass.prototype`,
+ *    overlays `__`-suffixed methods via the proxy.
+ * 2. `strictProxy(value: T)` — infers `T` from the argument.
+ * 3. `strictProxy<T>(partial)` — test mocking: typed via `PartialDeep<T>`.
+ * 4. `strictProxy<T>(value)` — explicit `T`, unchecked value (cross-type cast).
+ */
+import type { PartialDeep } from 'type-fest';
+type MockClassLike<T> = {
+    prototype: T;
+} & MockClassRef;
+interface MockClassRef {
+    name: string;
+    prototype: object;
+}
+/**
+ * Unwraps a strict-proxied object, returning the underlying target.
+ *
+ * Accessing unmocked properties on the returned object yields `undefined`
+ * instead of throwing. Non-proxied values are returned as-is.
+ *
+ * @typeParam T - The type of the object.
+ * @param obj - The object to unwrap.
+ * @returns The underlying target, or `obj` if it is not a strict proxy.
+ */
+export declare function bypassStrictProxy<T>(obj: T): T;
+export declare function strictProxy<T>(value: unknown, mockClass: MockClassLike<T>): T;
+export declare function strictProxy<T extends object>(value: T): T;
+export declare function strictProxy<T>(value: PartialDeep<T>): T;
+export declare function strictProxy<T>(value: unknown): T;
+export {};

package/dist/lib/esm/strict-proxy.mjs

@@ -0,0 +1,72 @@
+import { ensureGenericObject } from "./type-guards.mjs";
+const STRICT_PROXY_TARGET_SYMBOL = /* @__PURE__ */ Symbol.for("strictProxyTarget");
+const PASSTHROUGH_PROPS = /* @__PURE__ */ new Set([
+  Symbol.iterator,
+  Symbol.toPrimitive,
+  Symbol.toStringTag,
+  "then",
+  "toJSON"
+]);
+function bypassStrictProxy(obj) {
+  if (!isObjectLike(obj)) {
+    return obj;
+  }
+  if (!(STRICT_PROXY_TARGET_SYMBOL in obj)) {
+    return obj;
+  }
+  return obj[STRICT_PROXY_TARGET_SYMBOL];
+}
+function strictProxy(value, mockClass) {
+  return wrapProxy(value, mockClass);
+}
+function isObjectLike(value) {
+  return value !== null && typeof value === "object";
+}
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype;
+}
+function wrapProxy(value, mockClass) {
+  if (!isObjectLike(value)) {
+    return value;
+  }
+  if (STRICT_PROXY_TARGET_SYMBOL in value) {
+    return value;
+  }
+  Object.defineProperty(value, STRICT_PROXY_TARGET_SYMBOL, { value });
+  const isClass = !isPlainObject(value);
+  const className = mockClass?.name ?? (isClass ? value.constructor.name : "");
+  const mockProto = mockClass ? ensureGenericObject(mockClass.prototype) : null;
+  const proxiedChildren = isClass ? null : /* @__PURE__ */ new Map();
+  return new Proxy(value, {
+    get(target, prop, receiver) {
+      if (prop in target) {
+        if (proxiedChildren?.has(prop)) {
+          return proxiedChildren.get(prop);
+        }
+        const val = Reflect.get(target, prop, receiver);
+        if (proxiedChildren && isPlainObject(val)) {
+          const result = wrapProxy(val);
+          proxiedChildren.set(prop, result);
+          return result;
+        }
+        return val;
+      }
+      if (mockProto && typeof prop === "string" && prop.endsWith("__") && prop in mockProto) {
+        const val = mockProto[prop];
+        if (typeof val === "function") {
+          return val.bind(receiver);
+        }
+        return val;
+      }
+      if (typeof prop === "symbol" || PASSTHROUGH_PROPS.has(prop)) {
+        return Reflect.get(target, prop, receiver);
+      }
+      throw new Error(`Property "${prop}" is not mocked in ${className}. To override, assign a value first: mock.${prop} = ...`);
+    }
+  });
+}
+export {
+  bypassStrictProxy,
+  strictProxy
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/strict-proxy.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Strict proxy for mock objects.\n *\n * Wraps an object in a `Proxy` that throws a descriptive error when any\n * unmocked property is accessed, instead of silently returning `undefined`.\n *\n * - Idempotent (double-wrapping is a no-op).\n * - Passthrough for well-known props (`then`, `toJSON`, `Symbol.iterator`, etc.).\n * - Class-name-aware error messages for class instances.\n * - Recursive proxying of nested plain objects (for partial mocks only).\n *\n * Overloads:\n * 1. `strictProxy(value, MockClass)` \u2014 infers `T` from `MockClass.prototype`,\n *    overlays `__`-suffixed methods via the proxy.\n * 2. `strictProxy(value: T)` \u2014 infers `T` from the argument.\n * 3. `strictProxy<T>(partial)` \u2014 test mocking: typed via `PartialDeep<T>`.\n * 4. `strictProxy<T>(value)` \u2014 explicit `T`, unchecked value (cross-type cast).\n */\n\nimport type { PartialDeep } from 'type-fest';\n\nimport type { GenericObject } from './type-guards.mjs';\n\nimport { ensureGenericObject } from './type-guards.mjs';\n\nconst STRICT_PROXY_TARGET_SYMBOL = Symbol.for('strictProxyTarget');\n\nconst PASSTHROUGH_PROPS = new Set<string | symbol>([\n  Symbol.iterator,\n  Symbol.toPrimitive,\n  Symbol.toStringTag,\n  'then',\n  'toJSON'\n]);\n\ntype MockClassLike<T> = { prototype: T } & MockClassRef;\n\ninterface MockClassRef {\n  name: string;\n  prototype: object;\n}\n\n/**\n * Unwraps a strict-proxied object, returning the underlying target.\n *\n * Accessing unmocked properties on the returned object yields `undefined`\n * instead of throwing. Non-proxied values are returned as-is.\n *\n * @typeParam T - The type of the object.\n * @param obj - The object to unwrap.\n * @returns The underlying target, or `obj` if it is not a strict proxy.\n */\nexport function bypassStrictProxy<T>(obj: T): T {\n  if (!isObjectLike(obj)) {\n    return obj;\n  }\n  if (!(STRICT_PROXY_TARGET_SYMBOL in obj)) {\n    return obj;\n  }\n  return obj[STRICT_PROXY_TARGET_SYMBOL] as T;\n}\n\n// eslint-disable-next-line @typescript-eslint/unified-signatures -- This overload infers T from mockClass; the `unknown` overload below requires explicit T. They cannot be combined.\nexport function strictProxy<T>(value: unknown, mockClass: MockClassLike<T>): T;\nexport function strictProxy<T extends object>(value: T): T;\nexport function strictProxy<T>(value: PartialDeep<T>): T;\n// eslint-disable-next-line @typescript-eslint/unified-signatures, @typescript-eslint/no-unnecessary-type-parameters -- PartialDeep<T> above gives type safety for partial mocks; this overload accepts an explicit T with an unchecked value for cross-type casts.\nexport function strictProxy<T>(value: unknown): T;\n/**\n * Wraps a mock object in a strict {@link Proxy} that throws on unmocked access.\n *\n * @typeParam T - The type the proxy presents.\n * @param value - The object (or partial mock) to wrap.\n * @param mockClass - Optional mock class providing `__`-suffixed overlay methods.\n * @returns The wrapped value typed as `T`.\n */\nexport function strictProxy<T>(value: unknown, mockClass?: MockClassRef): T {\n  return wrapProxy<T>(value, mockClass);\n}\n\n/**\n * Checks whether a value is a non-`null` object.\n *\n * @param value - The value to check.\n * @returns `true` if the value is a non-`null` object.\n */\nfunction isObjectLike(value: unknown): value is object {\n  return value !== null && typeof value === 'object';\n}\n\n/**\n * Checks whether a value is a plain object (prototype is `Object.prototype`).\n *\n * @param value - The value to check.\n * @returns `true` if the value is a plain object.\n */\nfunction isPlainObject(value: unknown): value is GenericObject {\n  return value !== null && typeof value === 'object' && Object.getPrototypeOf(value) === Object.prototype;\n}\n\n/**\n * Implements the strict-proxy wrapping logic shared by all overloads.\n *\n * @typeParam T - The type the proxy presents.\n * @param value - The object to wrap.\n * @param mockClass - Optional mock class providing `__`-suffixed overlay methods.\n * @returns The wrapped value typed as `T`.\n */\n// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- T provides return-type inference at the call sites.\nfunction wrapProxy<T>(value: unknown, mockClass?: MockClassRef): T {\n  if (!isObjectLike(value)) {\n    return value as T;\n  }\n\n  if (STRICT_PROXY_TARGET_SYMBOL in value) {\n    return value as T;\n  }\n  Object.defineProperty(value, STRICT_PROXY_TARGET_SYMBOL, { value });\n\n  const isClass = !isPlainObject(value);\n  const className = mockClass?.name ?? (isClass ? value.constructor.name : '');\n  const mockProto = mockClass ? ensureGenericObject(mockClass.prototype) : null;\n  const proxiedChildren = isClass ? null : new Map<string | symbol>();\n\n  return new Proxy(value, {\n    get(target, prop, receiver): unknown {\n      // 1. Own properties and prototype chain of the original object.\n      if (prop in target) {\n        if (proxiedChildren?.has(prop)) {\n          return proxiedChildren.get(prop);\n        }\n\n        const val: unknown = Reflect.get(target, prop, receiver);\n        if (proxiedChildren && isPlainObject(val)) {\n          const result = wrapProxy<unknown>(val);\n          proxiedChildren.set(prop, result);\n          return result;\n        }\n        return val;\n      }\n\n      // 2. Mock prototype chain (for __ methods on the mock class).\n      if (mockProto && typeof prop === 'string' && prop.endsWith('__') && prop in mockProto) {\n        const val: unknown = mockProto[prop];\n        if (typeof val === 'function') {\n          return val.bind(receiver);\n        }\n        return val;\n      }\n\n      // 3. Passthrough props (symbols, then, toJSON, etc.).\n      if (typeof prop === 'symbol' || PASSTHROUGH_PROPS.has(prop)) {\n        return Reflect.get(target, prop, receiver);\n      }\n\n      throw new Error(`Property \"${prop}\" is not mocked in ${className}. To override, assign a value first: mock.${prop} = ...`);\n    }\n  }) as T;\n}\n"],
  "mappings": "AAyBA,SAAS,2BAA2B;AAEpC,MAAM,6BAA6B,uBAAO,IAAI,mBAAmB;AAEjE,MAAM,oBAAoB,oBAAI,IAAqB;AAAA,EACjD,OAAO;AAAA,EACP,OAAO;AAAA,EACP,OAAO;AAAA,EACP;AAAA,EACA;AACF,CAAC;AAmBM,SAAS,kBAAqB,KAAW;AAC9C,MAAI,CAAC,aAAa,GAAG,GAAG;AACtB,WAAO;AAAA,EACT;AACA,MAAI,EAAE,8BAA8B,MAAM;AACxC,WAAO;AAAA,EACT;AACA,SAAO,IAAI,0BAA0B;AACvC;AAgBO,SAAS,YAAe,OAAgB,WAA6B;AAC1E,SAAO,UAAa,OAAO,SAAS;AACtC;AAQA,SAAS,aAAa,OAAiC;AACrD,SAAO,UAAU,QAAQ,OAAO,UAAU;AAC5C;AAQA,SAAS,cAAc,OAAwC;AAC7D,SAAO,UAAU,QAAQ,OAAO,UAAU,YAAY,OAAO,eAAe,KAAK,MAAM,OAAO;AAChG;AAWA,SAAS,UAAa,OAAgB,WAA6B;AACjE,MAAI,CAAC,aAAa,KAAK,GAAG;AACxB,WAAO;AAAA,EACT;AAEA,MAAI,8BAA8B,OAAO;AACvC,WAAO;AAAA,EACT;AACA,SAAO,eAAe,OAAO,4BAA4B,EAAE,MAAM,CAAC;AAElE,QAAM,UAAU,CAAC,cAAc,KAAK;AACpC,QAAM,YAAY,WAAW,SAAS,UAAU,MAAM,YAAY,OAAO;AACzE,QAAM,YAAY,YAAY,oBAAoB,UAAU,SAAS,IAAI;AACzE,QAAM,kBAAkB,UAAU,OAAO,oBAAI,IAAqB;AAElE,SAAO,IAAI,MAAM,OAAO;AAAA,IACtB,IAAI,QAAQ,MAAM,UAAmB;AAEnC,UAAI,QAAQ,QAAQ;AAClB,YAAI,iBAAiB,IAAI,IAAI,GAAG;AAC9B,iBAAO,gBAAgB,IAAI,IAAI;AAAA,QACjC;AAEA,cAAM,MAAe,QAAQ,IAAI,QAAQ,MAAM,QAAQ;AACvD,YAAI,mBAAmB,cAAc,GAAG,GAAG;AACzC,gBAAM,SAAS,UAAmB,GAAG;AACrC,0BAAgB,IAAI,MAAM,MAAM;AAChC,iBAAO;AAAA,QACT;AACA,eAAO;AAAA,MACT;AAGA,UAAI,aAAa,OAAO,SAAS,YAAY,KAAK,SAAS,IAAI,KAAK,QAAQ,WAAW;AACrF,cAAM,MAAe,UAAU,IAAI;AACnC,YAAI,OAAO,QAAQ,YAAY;AAC7B,iBAAO,IAAI,KAAK,QAAQ;AAAA,QAC1B;AACA,eAAO;AAAA,MACT;AAGA,UAAI,OAAO,SAAS,YAAY,kBAAkB,IAAI,IAAI,GAAG;AAC3D,eAAO,QAAQ,IAAI,QAAQ,MAAM,QAAQ;AAAA,MAC3C;AAEA,YAAM,IAAI,MAAM,aAAa,IAAI,sBAAsB,SAAS,6CAA6C,IAAI,QAAQ;AAAA,IAC3H;AAAA,EACF,CAAC;AACH;",
  "names": []
}


package/dist/lib/esm/transport-factory.mjs

@@ -68,7 +68,8 @@ class AppiumTransportFactory {
       logLevel: "warn",
       path: url.pathname,
       port,
-      sessionId
+      sessionId,
+      transformRequest: stripForbiddenFetchHeaders
     });
     this.log("Reattached to Appium session.");
     return new AppiumTransport({
@@ -458,4 +459,4 @@ export {
   createTransportFromOptions,
   getOrCreateTransport
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/transport-factory.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Factory for creating transport instances from {@link ObsidianTransportOptions}.\n */\n\n/* v8 ignore start -- Integration-time factory covered by integration tests, not unit tests. */\n\nimport type { ChildProcess } from 'node:child_process';\n\nimport {\n  execFile,\n  execFileSync,\n  spawn\n} from 'node:child_process';\nimport http from 'node:http';\nimport { join } from 'node:path';\nimport process from 'node:process';\nimport {\n  attach,\n  remote\n} from 'webdriverio';\n\nimport type {\n  ObsidianAndroidAppiumTransportOptions,\n  ObsidianTransportOptions\n} from './transport-options.mjs';\nimport type { ObsidianTransport } from './transport.mjs';\n\nimport { buildEmulatorArgs } from './emulator-args.mjs';\nimport { log } from './log.mjs';\nimport { AppiumTransport } from './transport-appium.mjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nimport { DesktopCliTransport } from './transport-desktop-cli.mjs';\n\nconst APP_PACKAGE = 'md.obsidian';\nconst APP_ACTIVITY = `${APP_PACKAGE}.MainActivity`;\nconst ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS = 5000;\nconst APPIUM_CONNECTION_RETRY_COUNT = 3;\nconst APPIUM_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS = 180000;\nconst APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS = 5000;\nconst APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst APPIUM_START_TIMEOUT_IN_MILLISECONDS = 60000;\nconst CDP_DEFAULT_PORT = 8315;\n// Appium insecure feature letting the UiAutomator2 driver auto-download a\n// Chromedriver matching Obsidian's WebView Chrome version. Enabling it on the\n// Appium server (it has no effect as a capability) avoids the failure\n// \"No Chromedriver found that can automate Chrome ...\".\nconst CHROMEDRIVER_AUTODOWNLOAD_FEATURE = 'uiautomator2:chromedriver_autodownload';\nconst COMMAND_TIMEOUT_IN_MILLISECONDS = 300;\nconst DEFAULT_TRANSPORT_TYPE = 'obsidian-cli';\nconst EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS = 2000;\nconst EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS = 120000;\nconst KEYCODE_MENU = 82;\nconst KEYCODE_WAKEUP = 224;\nconst SERVER_INSTALL_TIMEOUT_IN_MILLISECONDS = 120000;\nconst SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS = 120000;\n\n/**\n * Result of {@link AppiumTransportFactory.ensureDeviceConnected}.\n */\ninterface EnsureDeviceConnectedResult {\n  /** The actual device ID that is connected (may differ from the requested one). */\n  actualDeviceId: string;\n\n  /** The emulator process, if one was auto-started. */\n  emulatorProcess?: ChildProcess | undefined;\n}\n\n/**\n * Parameters for {@link AppiumTransportFactory.startAppiumAndEmulator}.\n */\ninterface StartAppiumAndEmulatorParams {\n  /** The Appium server URL. */\n  appiumUrl: URL;\n\n  /** AVD name to start. */\n  avdName: string;\n\n  /** The Appium server port. */\n  port: number;\n\n  /** Whether Appium auto-start is allowed. */\n  shouldAutoStartAppium?: boolean | undefined;\n}\n\n/**\n * Result of {@link AppiumTransportFactory.startAppiumAndEmulator}.\n */\ninterface StartAppiumAndEmulatorResult {\n  /** The actual device ID that is connected (may differ from the requested one). */\n  actualDeviceId: string;\n\n  /** The Appium server process, if one was auto-started. */\n  appiumProcess?: ChildProcess | undefined;\n\n  /** The emulator process, if one was auto-started. */\n  emulatorProcess?: ChildProcess | undefined;\n}\n\nlet cachedTransport: ObsidianTransport | undefined;\n\n/**\n * Encapsulates all Appium transport creation logic, including Appium server\n * startup, emulator management, and WebDriverIO session establishment.\n *\n * Using a class avoids threading the transport `type` label through every\n * helper function \u2014 `this.log()` automatically prefixes it.\n */\nclass AppiumTransportFactory {\n  private readonly type: string;\n\n  public constructor(type: string) {\n    this.type = type;\n  }\n\n  /**\n   * Creates an Appium transport by establishing a WebDriverIO session.\n   *\n   * If `options.sessionId` is present, reattaches to the existing session\n   * instead of creating a new one. This avoids duplicate Appium/ADB connections\n   * when test workers reuse the global setup's session.\n   *\n   * @param options - Android Appium transport options.\n   * @returns A configured Appium transport.\n   */\n  public async create(options: ObsidianAndroidAppiumTransportOptions): Promise<ObsidianTransport> {\n    if (options.sessionId !== undefined && options.deviceId !== undefined) {\n      return this.attachToExistingSession(options.sessionId, options.deviceId, options);\n    }\n\n    return this.createNewSession(options);\n  }\n\n  private async attachToExistingSession(\n    sessionId: string,\n    deviceId: string,\n    options: ObsidianAndroidAppiumTransportOptions\n  ): Promise<ObsidianTransport> {\n    const url = new URL(options.appiumUrl);\n    const port = Number(url.port);\n    const appId = options.appId ?? APP_PACKAGE;\n\n    this.log(`Reattaching to existing Appium session ${sessionId} (device=${deviceId})`);\n\n    const browser = await attach({\n      capabilities: {\n        platformName: 'Android'\n      },\n      hostname: url.hostname,\n      logLevel: 'warn',\n      path: url.pathname,\n      port,\n      sessionId\n    });\n\n    this.log('Reattached to Appium session.');\n\n    return new AppiumTransport({\n      appId,\n      browser,\n      deviceId,\n      isSessionOwner: false,\n      platform: 'android',\n      ...(options.vaultBasePath !== undefined && { vaultBasePath: options.vaultBasePath }),\n      ...(options.webviewTimeoutInMilliseconds !== undefined && { webviewTimeoutInMilliseconds: options.webviewTimeoutInMilliseconds })\n    });\n  }\n\n  private checkAppiumReachable(url: URL): Promise<void> {\n    return new Promise((resolve, reject) => {\n      const statusUrl = new URL('/status', url);\n      const req = http.get(statusUrl, { timeout: APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS }, (res) => {\n        res.resume();\n        resolve();\n      });\n      req.on('timeout', () => {\n        req.destroy();\n        reject(\n          new Error(\n            `Appium server at ${url.origin} did not respond within ${String(APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS)}ms. Is the Appium server running?`\n          )\n        );\n      });\n      req.on('error', (err) => {\n        reject(\n          new Error(\n            `Cannot reach Appium server at ${url.origin}: ${err.message}. Is the Appium server running?`\n          )\n        );\n      });\n    });\n  }\n\n  private async createNewSession(options: ObsidianAndroidAppiumTransportOptions): Promise<ObsidianTransport> {\n    this.log(`Creating AppiumTransport (url=${options.appiumUrl}, avd=${options.avdName})`);\n\n    const url = new URL(options.appiumUrl);\n\n    const port = Number(url.port);\n    if (isNaN(port)) {\n      throw new Error(`Invalid port in appiumUrl: ${url.port}`);\n    }\n\n    const appId = options.appId ?? APP_PACKAGE;\n\n    let appiumProcess: ChildProcess | undefined;\n    let emulatorProcess: ChildProcess | undefined;\n\n    try {\n      const result = await this.startAppiumAndEmulator({\n        appiumUrl: url,\n        avdName: options.avdName,\n        port,\n        shouldAutoStartAppium: options.shouldAutoStartAppium\n      });\n\n      appiumProcess = result.appiumProcess;\n      emulatorProcess = result.emulatorProcess;\n      const actualDeviceId = result.actualDeviceId;\n\n      this.log(\n        `Connecting to Appium (device=${actualDeviceId}, app=${appId}, retryTimeout: ${String(APPIUM_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS)}ms, retries: ${\n          String(APPIUM_CONNECTION_RETRY_COUNT)\n        })...`\n      );\n      const browser = await remote({\n        capabilities: {\n          'appium:appActivity': APP_ACTIVITY,\n          'appium:appPackage': appId,\n          'appium:autoGrantPermissions': true,\n          'appium:automationName': 'UiAutomator2',\n          'appium:newCommandTimeout': COMMAND_TIMEOUT_IN_MILLISECONDS,\n          'appium:noReset': true,\n          'appium:udid': actualDeviceId,\n          'appium:uiautomator2ServerInstallTimeout': SERVER_INSTALL_TIMEOUT_IN_MILLISECONDS,\n          'appium:uiautomator2ServerLaunchTimeout': SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS,\n          'platformName': 'Android'\n        },\n        connectionRetryCount: APPIUM_CONNECTION_RETRY_COUNT,\n        connectionRetryTimeout: APPIUM_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS,\n        hostname: url.hostname,\n        logLevel: 'warn',\n        path: url.pathname,\n        port,\n        transformRequest: stripForbiddenFetchHeaders\n      });\n\n      this.log('Appium session established.');\n      const appiumTransport = new AppiumTransport({\n        appId,\n        browser,\n        deviceId: actualDeviceId,\n        platform: 'android',\n        ...(options.vaultBasePath !== undefined && { vaultBasePath: options.vaultBasePath }),\n        ...(options.webviewTimeoutInMilliseconds !== undefined && { webviewTimeoutInMilliseconds: options.webviewTimeoutInMilliseconds })\n      });\n\n      const originalDispose = appiumTransport.dispose.bind(appiumTransport);\n      const transport: ObsidianTransport = appiumTransport;\n      transport.dispose = async (): Promise<void> => {\n        try {\n          await originalDispose();\n        } finally {\n          killAutoStartedProcesses();\n        }\n      };\n\n      transport.disposeSync = (): void => {\n        killAutoStartedProcesses();\n      };\n\n      return transport;\n\n      function killAutoStartedProcesses(): void {\n        if (appiumProcess) {\n          killProcessTree(appiumProcess);\n          // Cannot use this.log inside nested function \u2014 `this` is not captured.\n          log(`[transport-factory:${options.type}] Auto-started Appium server stopped.`);\n        }\n        if (emulatorProcess) {\n          killProcessTree(emulatorProcess);\n          log(`[transport-factory:${options.type}] Auto-started emulator stopped.`);\n        }\n      }\n    } catch (error: unknown) {\n      if (appiumProcess) {\n        killProcessTree(appiumProcess);\n        this.log('Killed auto-started Appium server after connection failure.');\n      }\n      if (emulatorProcess) {\n        killProcessTree(emulatorProcess);\n        this.log('Killed auto-started emulator after connection failure.');\n      }\n      throw error;\n    }\n  }\n\n  private async ensureDeviceConnected(avdName: string): Promise<EnsureDeviceConnectedResult> {\n    const deviceIdsBefore = await this.getConnectedDeviceIds();\n    this.log(`Checking existing devices for AVD \"${avdName}\"... (connected: [${deviceIdsBefore.join(', ')}])`);\n\n    const existingDeviceId = await this.findDeviceByAvdName(avdName, deviceIdsBefore);\n\n    if (existingDeviceId) {\n      this.log(`AVD \"${avdName}\" is already running on device ${existingDeviceId}, reusing.`);\n      return { actualDeviceId: existingDeviceId };\n    }\n\n    this.log(`AVD \"${avdName}\" not found on any existing device, starting a new emulator...`);\n    const emulatorProcess = this.startEmulator(avdName);\n    const actualDeviceId = await this.waitForNewDevice(deviceIdsBefore);\n    this.log(`Emulator \"${avdName}\" started, device ${actualDeviceId} is connected.`);\n    return { actualDeviceId, emulatorProcess };\n  }\n\n  private async findDeviceByAvdName(avdName: string, deviceIds: string[]): Promise<string | undefined> {\n    for (const deviceId of deviceIds) {\n      const runningAvd = await new Promise<string>((resolve) => {\n        execFile(\n          'adb',\n          ['-s', deviceId, 'emu', 'avd', 'name'],\n          { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n          (_error, stdout) => {\n            resolve(stdout.split('\\n')[0]?.trim() ?? '');\n          }\n        );\n      });\n\n      if (runningAvd === avdName) {\n        return deviceId;\n      }\n    }\n\n    return undefined;\n  }\n\n  private async getConnectedDeviceIds(): Promise<string[]> {\n    const output = await new Promise<string>((resolve, reject) => {\n      execFile('adb', ['devices'], { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS }, (error, stdout, stderr) => {\n        if (error) {\n          reject(new Error(`Failed to run 'adb devices': ${error.message}. Is ADB installed and in PATH?`));\n          return;\n        }\n        if (stderr) {\n          this.log(`ADB stderr: ${stderr.trim()}`);\n        }\n        resolve(stdout);\n      });\n    });\n\n    const lines = output.split('\\n').map((line) => line.trim()).filter((line) => line.length > 0);\n    return lines\n      .filter((line) => line.includes('\\tdevice'))\n      .map((line) => line.split('\\t')[0] ?? '');\n  }\n\n  private log(message: string): void {\n    log(`[transport-factory:${this.type}] ${message}`);\n  }\n\n  private resolveEmulatorBinary(): string {\n    const sdkRoot = process.env['ANDROID_HOME'] ?? process.env['ANDROID_SDK_ROOT'];\n    if (!sdkRoot) {\n      throw new Error(\n        'Cannot find Android emulator: neither ANDROID_HOME nor ANDROID_SDK_ROOT environment variable is set.'\n      );\n    }\n    return join(sdkRoot, 'emulator', 'emulator');\n  }\n\n  private async sendKeyEvent(deviceId: string, keyCode: number, description: string): Promise<void> {\n    await new Promise<void>((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'input', 'keyevent', String(keyCode)],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error) => {\n          if (error) {\n            this.log(\n              `Warning: failed to ${description} (keyevent ${String(keyCode)}): ${error instanceof Error ? error.message : 'unknown error'}`\n            );\n          }\n\n          resolve();\n        }\n      );\n    });\n  }\n\n  private async startAppiumAndEmulator(params: StartAppiumAndEmulatorParams): Promise<StartAppiumAndEmulatorResult> {\n    const { appiumUrl, avdName, port, shouldAutoStartAppium } = params;\n\n    let needsAppiumStart = false;\n\n    this.log(`Checking Appium server at ${appiumUrl.href}...`);\n    try {\n      await this.checkAppiumReachable(appiumUrl);\n      this.log('Appium server is reachable.');\n    } catch (error: unknown) {\n      if (shouldAutoStartAppium === false) {\n        throw error;\n      }\n      needsAppiumStart = true;\n    }\n\n    let appiumProcess: ChildProcess | undefined;\n\n    if (needsAppiumStart) {\n      this.log(`Appium not reachable, auto-starting on port ${String(port)}...`);\n      appiumProcess = this.startAppiumServer(port);\n    }\n\n    try {\n      const [, deviceResult] = await Promise.all([\n        needsAppiumStart\n          ? this.waitForAppiumReady(appiumUrl).then(() => {\n            this.log('Auto-started Appium server is ready.');\n          })\n          : Promise.resolve(),\n        this.ensureDeviceConnected(avdName)\n      ]);\n\n      return {\n        actualDeviceId: deviceResult.actualDeviceId,\n        appiumProcess,\n        emulatorProcess: deviceResult.emulatorProcess\n      };\n    } catch (error: unknown) {\n      if (appiumProcess) {\n        killProcessTree(appiumProcess);\n        this.log('Killed auto-started Appium server after startup failure.');\n      }\n      throw error;\n    }\n  }\n\n  private startAppiumServer(port: number): ChildProcess {\n    const child = spawn(`npx appium --log-timestamp --port ${String(port)} --allow-insecure=${CHROMEDRIVER_AUTODOWNLOAD_FEATURE}`, {\n      detached: true,\n      shell: true,\n      stdio: ['ignore', 'inherit', 'inherit']\n    });\n\n    child.unref();\n    return child;\n  }\n\n  private startEmulator(avdName: string): ChildProcess {\n    const emulatorBinary = this.resolveEmulatorBinary();\n    const args = buildEmulatorArgs(avdName);\n    this.log(`Running: ${emulatorBinary} ${args.join(' ')}`);\n    const child = spawn(emulatorBinary, args, {\n      detached: true,\n      stdio: ['ignore', 'ignore', 'ignore']\n    });\n\n    child.unref();\n    return child;\n  }\n\n  private async waitForAppiumReady(url: URL): Promise<void> {\n    this.log(\n      `Waiting for Appium at ${url.href} (timeout: ${String(APPIUM_START_TIMEOUT_IN_MILLISECONDS)}ms, poll: ${\n        String(APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS)\n      }ms)...`\n    );\n    const deadline = Date.now() + APPIUM_START_TIMEOUT_IN_MILLISECONDS;\n\n    while (Date.now() < deadline) {\n      try {\n        await this.checkAppiumReachable(url);\n        return;\n      } catch {\n        await new Promise((resolve) => {\n          setTimeout(resolve, APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS);\n        });\n      }\n    }\n\n    throw new Error(\n      `Auto-started Appium server did not become ready within ${String(APPIUM_START_TIMEOUT_IN_MILLISECONDS)}ms`\n    );\n  }\n\n  private async waitForBoot(deviceId: string, deadline: number): Promise<void> {\n    const remainingMs = Math.max(0, deadline - Date.now());\n    this.log(\n      `Waiting for device ${deviceId} to finish booting (remaining: ${String(remainingMs)}ms, poll: ${\n        String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)\n      }ms)...`\n    );\n\n    while (Date.now() < deadline) {\n      const isBooted = await new Promise<boolean>((resolve) => {\n        execFile(\n          'adb',\n          ['-s', deviceId, 'shell', 'getprop', 'sys.boot_completed'],\n          { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n          (_error, stdout) => {\n            resolve(stdout.trim() === '1');\n          }\n        );\n      });\n\n      if (isBooted) {\n        this.log(`Device ${deviceId} boot completed.`);\n        return;\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    throw new Error(\n      `Device \"${deviceId}\" connected but did not finish booting within ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms.`\n    );\n  }\n\n  private async waitForNewDevice(deviceIdsBefore: string[]): Promise<string> {\n    this.log(\n      `Waiting for a new device to appear in ADB (timeout: ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms, poll: ${\n        String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)\n      }ms)...`\n    );\n    const deadline = Date.now() + EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS;\n\n    while (Date.now() < deadline) {\n      const currentIds = await this.getConnectedDeviceIds();\n      const newIds = currentIds.filter((id) => !deviceIdsBefore.includes(id));\n\n      if (newIds.length > 0) {\n        const actualDeviceId = newIds[0] ?? '';\n        this.log(`Device ${actualDeviceId} appeared in ADB, waiting for boot to complete...`);\n        await this.waitForBoot(actualDeviceId, deadline);\n        await this.wakeScreen(actualDeviceId);\n        return actualDeviceId;\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    throw new Error(\n      `No new emulator device appeared within ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms.`\n    );\n  }\n\n  private async wakeScreen(deviceId: string): Promise<void> {\n    this.log(`Waking screen on device ${deviceId}...`);\n\n    await this.sendKeyEvent(deviceId, KEYCODE_WAKEUP, 'wake screen');\n    await this.sendKeyEvent(deviceId, KEYCODE_MENU, 'dismiss lock screen');\n\n    this.log(`Screen wake complete on device ${deviceId}.`);\n  }\n}\n\n/**\n * Creates a new transport instance from the given options.\n *\n * @param options - Transport configuration. Defaults to CLI transport.\n * @returns A new transport instance.\n */\nexport async function createTransportFromOptions(options?: ObsidianTransportOptions): Promise<ObsidianTransport> {\n  const type = options?.type ?? DEFAULT_TRANSPORT_TYPE;\n\n  if (!options || options.type === 'obsidian-cli') {\n    log(`[transport-factory:${type}] Creating DesktopCliTransport`);\n    return new DesktopCliTransport();\n  }\n\n  if (options.type === 'obsidian-cdp') {\n    log(`[transport-factory:${type}] Creating DesktopCdpTransport (host=${options.host ?? 'localhost'}, port=${String(options.port ?? CDP_DEFAULT_PORT)})`);\n    return new DesktopCdpTransport({\n      ...(options.host !== undefined && { cdpHost: options.host }),\n      ...(options.port !== undefined && { cdpPort: options.port }),\n      ...(options.commandTimeoutInMilliseconds !== undefined && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds })\n    });\n  }\n\n  const factory = new AppiumTransportFactory(type);\n  return factory.create(options);\n}\n\n/**\n * Returns a cached transport instance, creating one from the given options\n * if not already cached.\n *\n * The transport is cached per worker process so WebSocket/Appium sessions\n * are reused across calls within the same test worker.\n *\n * @param options - Transport configuration. Defaults to CLI transport.\n * @returns The cached or newly created transport.\n */\nexport async function getOrCreateTransport(options?: ObsidianTransportOptions): Promise<ObsidianTransport> {\n  if (cachedTransport) {\n    return cachedTransport;\n  }\n\n  const result = await createTransportFromOptions(options);\n  // eslint-disable-next-line require-atomic-updates -- Single-threaded worker; no concurrent writes.\n  cachedTransport = result;\n  return result;\n}\n\n/**\n * Kills a child process and its entire process tree.\n *\n * On Windows, `child.kill()` only sends SIGTERM to the direct process,\n * leaving spawned grandchildren (e.g. QEMU, UiAutomator) alive.\n * `taskkill /F /T /PID` forcefully terminates the entire tree.\n *\n * @param child - The child process to kill.\n */\nfunction killProcessTree(child: ChildProcess): void {\n  if (child.pid === undefined) {\n    return;\n  }\n\n  if (process.platform === 'win32') {\n    try {\n      execFileSync('taskkill', ['/F', '/T', '/PID', String(child.pid)], { stdio: 'ignore' });\n    } catch (error: unknown) {\n      log(\n        `[transport-factory] taskkill for PID ${String(child.pid)} failed (may have already exited): ${\n          error instanceof Error ? error.message : 'unknown error'\n        }`\n      );\n    }\n  } else {\n    child.kill('SIGKILL');\n  }\n}\n\n/**\n * Removes `Connection` and `Content-Length` from a WebDriver request's headers.\n *\n * The bundled `webdriver` package sets both headers explicitly. They are\n * forbidden request headers per the Fetch spec: Node up to 25 accepted them\n * silently, but Node 26 rejects them with `UND_ERR_INVALID_ARG`, breaking the\n * Appium `/session` request. The transport layer manages connection reuse and\n * the Fetch API computes `Content-Length` from the body, so dropping both is\n * safe on every Node version. See {@link https://github.com/webdriverio/webdriverio/issues/15265}.\n *\n * @param requestOptions - The request options about to be sent by WebDriverIO.\n * @returns The same request options with the forbidden headers removed.\n */\nfunction stripForbiddenFetchHeaders(requestOptions: RequestInit): RequestInit {\n  if (requestOptions.headers instanceof Headers) {\n    requestOptions.headers.delete('Connection');\n    requestOptions.headers.delete('Content-Length');\n  }\n\n  return requestOptions;\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["killAutoStartedProcesses"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/transport-factory.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Factory for creating transport instances from {@link ObsidianTransportOptions}.\n */\n\n/* v8 ignore start -- Integration-time factory covered by integration tests, not unit tests. */\n\nimport type { ChildProcess } from 'node:child_process';\n\nimport {\n  execFile,\n  execFileSync,\n  spawn\n} from 'node:child_process';\nimport http from 'node:http';\nimport { join } from 'node:path';\nimport process from 'node:process';\nimport {\n  attach,\n  remote\n} from 'webdriverio';\n\nimport type {\n  ObsidianAndroidAppiumTransportOptions,\n  ObsidianTransportOptions\n} from './transport-options.mjs';\nimport type { ObsidianTransport } from './transport.mjs';\n\nimport { buildEmulatorArgs } from './emulator-args.mjs';\nimport { log } from './log.mjs';\nimport { AppiumTransport } from './transport-appium.mjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nimport { DesktopCliTransport } from './transport-desktop-cli.mjs';\n\nconst APP_PACKAGE = 'md.obsidian';\nconst APP_ACTIVITY = `${APP_PACKAGE}.MainActivity`;\nconst ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS = 5000;\nconst APPIUM_CONNECTION_RETRY_COUNT = 3;\nconst APPIUM_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS = 180000;\nconst APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS = 5000;\nconst APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst APPIUM_START_TIMEOUT_IN_MILLISECONDS = 60000;\nconst CDP_DEFAULT_PORT = 8315;\n// Appium insecure feature letting the UiAutomator2 driver auto-download a\n// Chromedriver matching Obsidian's WebView Chrome version. Enabling it on the\n// Appium server (it has no effect as a capability) avoids the failure\n// \"No Chromedriver found that can automate Chrome ...\".\nconst CHROMEDRIVER_AUTODOWNLOAD_FEATURE = 'uiautomator2:chromedriver_autodownload';\nconst COMMAND_TIMEOUT_IN_MILLISECONDS = 300;\nconst DEFAULT_TRANSPORT_TYPE = 'obsidian-cli';\nconst EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS = 2000;\nconst EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS = 120000;\nconst KEYCODE_MENU = 82;\nconst KEYCODE_WAKEUP = 224;\nconst SERVER_INSTALL_TIMEOUT_IN_MILLISECONDS = 120000;\nconst SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS = 120000;\n\n/**\n * Result of {@link AppiumTransportFactory.ensureDeviceConnected}.\n */\ninterface EnsureDeviceConnectedResult {\n  /** The actual device ID that is connected (may differ from the requested one). */\n  actualDeviceId: string;\n\n  /** The emulator process, if one was auto-started. */\n  emulatorProcess?: ChildProcess | undefined;\n}\n\n/**\n * Parameters for {@link AppiumTransportFactory.startAppiumAndEmulator}.\n */\ninterface StartAppiumAndEmulatorParams {\n  /** The Appium server URL. */\n  appiumUrl: URL;\n\n  /** AVD name to start. */\n  avdName: string;\n\n  /** The Appium server port. */\n  port: number;\n\n  /** Whether Appium auto-start is allowed. */\n  shouldAutoStartAppium?: boolean | undefined;\n}\n\n/**\n * Result of {@link AppiumTransportFactory.startAppiumAndEmulator}.\n */\ninterface StartAppiumAndEmulatorResult {\n  /** The actual device ID that is connected (may differ from the requested one). */\n  actualDeviceId: string;\n\n  /** The Appium server process, if one was auto-started. */\n  appiumProcess?: ChildProcess | undefined;\n\n  /** The emulator process, if one was auto-started. */\n  emulatorProcess?: ChildProcess | undefined;\n}\n\nlet cachedTransport: ObsidianTransport | undefined;\n\n/**\n * Encapsulates all Appium transport creation logic, including Appium server\n * startup, emulator management, and WebDriverIO session establishment.\n *\n * Using a class avoids threading the transport `type` label through every\n * helper function \u2014 `this.log()` automatically prefixes it.\n */\nclass AppiumTransportFactory {\n  private readonly type: string;\n\n  public constructor(type: string) {\n    this.type = type;\n  }\n\n  /**\n   * Creates an Appium transport by establishing a WebDriverIO session.\n   *\n   * If `options.sessionId` is present, reattaches to the existing session\n   * instead of creating a new one. This avoids duplicate Appium/ADB connections\n   * when test workers reuse the global setup's session.\n   *\n   * @param options - Android Appium transport options.\n   * @returns A configured Appium transport.\n   */\n  public async create(options: ObsidianAndroidAppiumTransportOptions): Promise<ObsidianTransport> {\n    if (options.sessionId !== undefined && options.deviceId !== undefined) {\n      return this.attachToExistingSession(options.sessionId, options.deviceId, options);\n    }\n\n    return this.createNewSession(options);\n  }\n\n  private async attachToExistingSession(\n    sessionId: string,\n    deviceId: string,\n    options: ObsidianAndroidAppiumTransportOptions\n  ): Promise<ObsidianTransport> {\n    const url = new URL(options.appiumUrl);\n    const port = Number(url.port);\n    const appId = options.appId ?? APP_PACKAGE;\n\n    this.log(`Reattaching to existing Appium session ${sessionId} (device=${deviceId})`);\n\n    const browser = await attach({\n      capabilities: {\n        platformName: 'Android'\n      },\n      hostname: url.hostname,\n      logLevel: 'warn',\n      path: url.pathname,\n      port,\n      sessionId,\n      transformRequest: stripForbiddenFetchHeaders\n    });\n\n    this.log('Reattached to Appium session.');\n\n    return new AppiumTransport({\n      appId,\n      browser,\n      deviceId,\n      isSessionOwner: false,\n      platform: 'android',\n      ...(options.vaultBasePath !== undefined && { vaultBasePath: options.vaultBasePath }),\n      ...(options.webviewTimeoutInMilliseconds !== undefined && { webviewTimeoutInMilliseconds: options.webviewTimeoutInMilliseconds })\n    });\n  }\n\n  private checkAppiumReachable(url: URL): Promise<void> {\n    return new Promise((resolve, reject) => {\n      const statusUrl = new URL('/status', url);\n      const req = http.get(statusUrl, { timeout: APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS }, (res) => {\n        res.resume();\n        resolve();\n      });\n      req.on('timeout', () => {\n        req.destroy();\n        reject(\n          new Error(\n            `Appium server at ${url.origin} did not respond within ${String(APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS)}ms. Is the Appium server running?`\n          )\n        );\n      });\n      req.on('error', (err) => {\n        reject(\n          new Error(\n            `Cannot reach Appium server at ${url.origin}: ${err.message}. Is the Appium server running?`\n          )\n        );\n      });\n    });\n  }\n\n  private async createNewSession(options: ObsidianAndroidAppiumTransportOptions): Promise<ObsidianTransport> {\n    this.log(`Creating AppiumTransport (url=${options.appiumUrl}, avd=${options.avdName})`);\n\n    const url = new URL(options.appiumUrl);\n\n    const port = Number(url.port);\n    if (isNaN(port)) {\n      throw new Error(`Invalid port in appiumUrl: ${url.port}`);\n    }\n\n    const appId = options.appId ?? APP_PACKAGE;\n\n    let appiumProcess: ChildProcess | undefined;\n    let emulatorProcess: ChildProcess | undefined;\n\n    try {\n      const result = await this.startAppiumAndEmulator({\n        appiumUrl: url,\n        avdName: options.avdName,\n        port,\n        shouldAutoStartAppium: options.shouldAutoStartAppium\n      });\n\n      appiumProcess = result.appiumProcess;\n      emulatorProcess = result.emulatorProcess;\n      const actualDeviceId = result.actualDeviceId;\n\n      this.log(\n        `Connecting to Appium (device=${actualDeviceId}, app=${appId}, retryTimeout: ${String(APPIUM_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS)}ms, retries: ${\n          String(APPIUM_CONNECTION_RETRY_COUNT)\n        })...`\n      );\n      const browser = await remote({\n        capabilities: {\n          'appium:appActivity': APP_ACTIVITY,\n          'appium:appPackage': appId,\n          'appium:autoGrantPermissions': true,\n          'appium:automationName': 'UiAutomator2',\n          'appium:newCommandTimeout': COMMAND_TIMEOUT_IN_MILLISECONDS,\n          'appium:noReset': true,\n          'appium:udid': actualDeviceId,\n          'appium:uiautomator2ServerInstallTimeout': SERVER_INSTALL_TIMEOUT_IN_MILLISECONDS,\n          'appium:uiautomator2ServerLaunchTimeout': SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS,\n          'platformName': 'Android'\n        },\n        connectionRetryCount: APPIUM_CONNECTION_RETRY_COUNT,\n        connectionRetryTimeout: APPIUM_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS,\n        hostname: url.hostname,\n        logLevel: 'warn',\n        path: url.pathname,\n        port,\n        transformRequest: stripForbiddenFetchHeaders\n      });\n\n      this.log('Appium session established.');\n      const appiumTransport = new AppiumTransport({\n        appId,\n        browser,\n        deviceId: actualDeviceId,\n        platform: 'android',\n        ...(options.vaultBasePath !== undefined && { vaultBasePath: options.vaultBasePath }),\n        ...(options.webviewTimeoutInMilliseconds !== undefined && { webviewTimeoutInMilliseconds: options.webviewTimeoutInMilliseconds })\n      });\n\n      const originalDispose = appiumTransport.dispose.bind(appiumTransport);\n      const transport: ObsidianTransport = appiumTransport;\n      transport.dispose = async (): Promise<void> => {\n        try {\n          await originalDispose();\n        } finally {\n          killAutoStartedProcesses();\n        }\n      };\n\n      transport.disposeSync = (): void => {\n        killAutoStartedProcesses();\n      };\n\n      return transport;\n\n      function killAutoStartedProcesses(): void {\n        if (appiumProcess) {\n          killProcessTree(appiumProcess);\n          // Cannot use this.log inside nested function \u2014 `this` is not captured.\n          log(`[transport-factory:${options.type}] Auto-started Appium server stopped.`);\n        }\n        if (emulatorProcess) {\n          killProcessTree(emulatorProcess);\n          log(`[transport-factory:${options.type}] Auto-started emulator stopped.`);\n        }\n      }\n    } catch (error: unknown) {\n      if (appiumProcess) {\n        killProcessTree(appiumProcess);\n        this.log('Killed auto-started Appium server after connection failure.');\n      }\n      if (emulatorProcess) {\n        killProcessTree(emulatorProcess);\n        this.log('Killed auto-started emulator after connection failure.');\n      }\n      throw error;\n    }\n  }\n\n  private async ensureDeviceConnected(avdName: string): Promise<EnsureDeviceConnectedResult> {\n    const deviceIdsBefore = await this.getConnectedDeviceIds();\n    this.log(`Checking existing devices for AVD \"${avdName}\"... (connected: [${deviceIdsBefore.join(', ')}])`);\n\n    const existingDeviceId = await this.findDeviceByAvdName(avdName, deviceIdsBefore);\n\n    if (existingDeviceId) {\n      this.log(`AVD \"${avdName}\" is already running on device ${existingDeviceId}, reusing.`);\n      return { actualDeviceId: existingDeviceId };\n    }\n\n    this.log(`AVD \"${avdName}\" not found on any existing device, starting a new emulator...`);\n    const emulatorProcess = this.startEmulator(avdName);\n    const actualDeviceId = await this.waitForNewDevice(deviceIdsBefore);\n    this.log(`Emulator \"${avdName}\" started, device ${actualDeviceId} is connected.`);\n    return { actualDeviceId, emulatorProcess };\n  }\n\n  private async findDeviceByAvdName(avdName: string, deviceIds: string[]): Promise<string | undefined> {\n    for (const deviceId of deviceIds) {\n      const runningAvd = await new Promise<string>((resolve) => {\n        execFile(\n          'adb',\n          ['-s', deviceId, 'emu', 'avd', 'name'],\n          { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n          (_error, stdout) => {\n            resolve(stdout.split('\\n')[0]?.trim() ?? '');\n          }\n        );\n      });\n\n      if (runningAvd === avdName) {\n        return deviceId;\n      }\n    }\n\n    return undefined;\n  }\n\n  private async getConnectedDeviceIds(): Promise<string[]> {\n    const output = await new Promise<string>((resolve, reject) => {\n      execFile('adb', ['devices'], { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS }, (error, stdout, stderr) => {\n        if (error) {\n          reject(new Error(`Failed to run 'adb devices': ${error.message}. Is ADB installed and in PATH?`));\n          return;\n        }\n        if (stderr) {\n          this.log(`ADB stderr: ${stderr.trim()}`);\n        }\n        resolve(stdout);\n      });\n    });\n\n    const lines = output.split('\\n').map((line) => line.trim()).filter((line) => line.length > 0);\n    return lines\n      .filter((line) => line.includes('\\tdevice'))\n      .map((line) => line.split('\\t')[0] ?? '');\n  }\n\n  private log(message: string): void {\n    log(`[transport-factory:${this.type}] ${message}`);\n  }\n\n  private resolveEmulatorBinary(): string {\n    const sdkRoot = process.env['ANDROID_HOME'] ?? process.env['ANDROID_SDK_ROOT'];\n    if (!sdkRoot) {\n      throw new Error(\n        'Cannot find Android emulator: neither ANDROID_HOME nor ANDROID_SDK_ROOT environment variable is set.'\n      );\n    }\n    return join(sdkRoot, 'emulator', 'emulator');\n  }\n\n  private async sendKeyEvent(deviceId: string, keyCode: number, description: string): Promise<void> {\n    await new Promise<void>((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'input', 'keyevent', String(keyCode)],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error) => {\n          if (error) {\n            this.log(\n              `Warning: failed to ${description} (keyevent ${String(keyCode)}): ${error instanceof Error ? error.message : 'unknown error'}`\n            );\n          }\n\n          resolve();\n        }\n      );\n    });\n  }\n\n  private async startAppiumAndEmulator(params: StartAppiumAndEmulatorParams): Promise<StartAppiumAndEmulatorResult> {\n    const { appiumUrl, avdName, port, shouldAutoStartAppium } = params;\n\n    let needsAppiumStart = false;\n\n    this.log(`Checking Appium server at ${appiumUrl.href}...`);\n    try {\n      await this.checkAppiumReachable(appiumUrl);\n      this.log('Appium server is reachable.');\n    } catch (error: unknown) {\n      if (shouldAutoStartAppium === false) {\n        throw error;\n      }\n      needsAppiumStart = true;\n    }\n\n    let appiumProcess: ChildProcess | undefined;\n\n    if (needsAppiumStart) {\n      this.log(`Appium not reachable, auto-starting on port ${String(port)}...`);\n      appiumProcess = this.startAppiumServer(port);\n    }\n\n    try {\n      const [, deviceResult] = await Promise.all([\n        needsAppiumStart\n          ? this.waitForAppiumReady(appiumUrl).then(() => {\n            this.log('Auto-started Appium server is ready.');\n          })\n          : Promise.resolve(),\n        this.ensureDeviceConnected(avdName)\n      ]);\n\n      return {\n        actualDeviceId: deviceResult.actualDeviceId,\n        appiumProcess,\n        emulatorProcess: deviceResult.emulatorProcess\n      };\n    } catch (error: unknown) {\n      if (appiumProcess) {\n        killProcessTree(appiumProcess);\n        this.log('Killed auto-started Appium server after startup failure.');\n      }\n      throw error;\n    }\n  }\n\n  private startAppiumServer(port: number): ChildProcess {\n    const child = spawn(`npx appium --log-timestamp --port ${String(port)} --allow-insecure=${CHROMEDRIVER_AUTODOWNLOAD_FEATURE}`, {\n      detached: true,\n      shell: true,\n      stdio: ['ignore', 'inherit', 'inherit']\n    });\n\n    child.unref();\n    return child;\n  }\n\n  private startEmulator(avdName: string): ChildProcess {\n    const emulatorBinary = this.resolveEmulatorBinary();\n    const args = buildEmulatorArgs(avdName);\n    this.log(`Running: ${emulatorBinary} ${args.join(' ')}`);\n    const child = spawn(emulatorBinary, args, {\n      detached: true,\n      stdio: ['ignore', 'ignore', 'ignore']\n    });\n\n    child.unref();\n    return child;\n  }\n\n  private async waitForAppiumReady(url: URL): Promise<void> {\n    this.log(\n      `Waiting for Appium at ${url.href} (timeout: ${String(APPIUM_START_TIMEOUT_IN_MILLISECONDS)}ms, poll: ${\n        String(APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS)\n      }ms)...`\n    );\n    const deadline = Date.now() + APPIUM_START_TIMEOUT_IN_MILLISECONDS;\n\n    while (Date.now() < deadline) {\n      try {\n        await this.checkAppiumReachable(url);\n        return;\n      } catch {\n        await new Promise((resolve) => {\n          setTimeout(resolve, APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS);\n        });\n      }\n    }\n\n    throw new Error(\n      `Auto-started Appium server did not become ready within ${String(APPIUM_START_TIMEOUT_IN_MILLISECONDS)}ms`\n    );\n  }\n\n  private async waitForBoot(deviceId: string, deadline: number): Promise<void> {\n    const remainingMs = Math.max(0, deadline - Date.now());\n    this.log(\n      `Waiting for device ${deviceId} to finish booting (remaining: ${String(remainingMs)}ms, poll: ${\n        String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)\n      }ms)...`\n    );\n\n    while (Date.now() < deadline) {\n      const isBooted = await new Promise<boolean>((resolve) => {\n        execFile(\n          'adb',\n          ['-s', deviceId, 'shell', 'getprop', 'sys.boot_completed'],\n          { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n          (_error, stdout) => {\n            resolve(stdout.trim() === '1');\n          }\n        );\n      });\n\n      if (isBooted) {\n        this.log(`Device ${deviceId} boot completed.`);\n        return;\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    throw new Error(\n      `Device \"${deviceId}\" connected but did not finish booting within ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms.`\n    );\n  }\n\n  private async waitForNewDevice(deviceIdsBefore: string[]): Promise<string> {\n    this.log(\n      `Waiting for a new device to appear in ADB (timeout: ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms, poll: ${\n        String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)\n      }ms)...`\n    );\n    const deadline = Date.now() + EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS;\n\n    while (Date.now() < deadline) {\n      const currentIds = await this.getConnectedDeviceIds();\n      const newIds = currentIds.filter((id) => !deviceIdsBefore.includes(id));\n\n      if (newIds.length > 0) {\n        const actualDeviceId = newIds[0] ?? '';\n        this.log(`Device ${actualDeviceId} appeared in ADB, waiting for boot to complete...`);\n        await this.waitForBoot(actualDeviceId, deadline);\n        await this.wakeScreen(actualDeviceId);\n        return actualDeviceId;\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    throw new Error(\n      `No new emulator device appeared within ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms.`\n    );\n  }\n\n  private async wakeScreen(deviceId: string): Promise<void> {\n    this.log(`Waking screen on device ${deviceId}...`);\n\n    await this.sendKeyEvent(deviceId, KEYCODE_WAKEUP, 'wake screen');\n    await this.sendKeyEvent(deviceId, KEYCODE_MENU, 'dismiss lock screen');\n\n    this.log(`Screen wake complete on device ${deviceId}.`);\n  }\n}\n\n/**\n * Creates a new transport instance from the given options.\n *\n * @param options - Transport configuration. Defaults to CLI transport.\n * @returns A new transport instance.\n */\nexport async function createTransportFromOptions(options?: ObsidianTransportOptions): Promise<ObsidianTransport> {\n  const type = options?.type ?? DEFAULT_TRANSPORT_TYPE;\n\n  if (!options || options.type === 'obsidian-cli') {\n    log(`[transport-factory:${type}] Creating DesktopCliTransport`);\n    return new DesktopCliTransport();\n  }\n\n  if (options.type === 'obsidian-cdp') {\n    log(`[transport-factory:${type}] Creating DesktopCdpTransport (host=${options.host ?? 'localhost'}, port=${String(options.port ?? CDP_DEFAULT_PORT)})`);\n    return new DesktopCdpTransport({\n      ...(options.host !== undefined && { cdpHost: options.host }),\n      ...(options.port !== undefined && { cdpPort: options.port }),\n      ...(options.commandTimeoutInMilliseconds !== undefined && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds })\n    });\n  }\n\n  const factory = new AppiumTransportFactory(type);\n  return factory.create(options);\n}\n\n/**\n * Returns a cached transport instance, creating one from the given options\n * if not already cached.\n *\n * The transport is cached per worker process so WebSocket/Appium sessions\n * are reused across calls within the same test worker.\n *\n * @param options - Transport configuration. Defaults to CLI transport.\n * @returns The cached or newly created transport.\n */\nexport async function getOrCreateTransport(options?: ObsidianTransportOptions): Promise<ObsidianTransport> {\n  if (cachedTransport) {\n    return cachedTransport;\n  }\n\n  const result = await createTransportFromOptions(options);\n  // eslint-disable-next-line require-atomic-updates -- Single-threaded worker; no concurrent writes.\n  cachedTransport = result;\n  return result;\n}\n\n/**\n * Kills a child process and its entire process tree.\n *\n * On Windows, `child.kill()` only sends SIGTERM to the direct process,\n * leaving spawned grandchildren (e.g. QEMU, UiAutomator) alive.\n * `taskkill /F /T /PID` forcefully terminates the entire tree.\n *\n * @param child - The child process to kill.\n */\nfunction killProcessTree(child: ChildProcess): void {\n  if (child.pid === undefined) {\n    return;\n  }\n\n  if (process.platform === 'win32') {\n    try {\n      execFileSync('taskkill', ['/F', '/T', '/PID', String(child.pid)], { stdio: 'ignore' });\n    } catch (error: unknown) {\n      log(\n        `[transport-factory] taskkill for PID ${String(child.pid)} failed (may have already exited): ${\n          error instanceof Error ? error.message : 'unknown error'\n        }`\n      );\n    }\n  } else {\n    child.kill('SIGKILL');\n  }\n}\n\n/**\n * Removes `Connection` and `Content-Length` from a WebDriver request's headers.\n *\n * The bundled `webdriver` package sets both headers explicitly. They are\n * forbidden request headers per the Fetch spec: Node up to 25 accepted them\n * silently, but Node 26 rejects them with `UND_ERR_INVALID_ARG`, breaking the\n * Appium `/session` request. The transport layer manages connection reuse and\n * the Fetch API computes `Content-Length` from the body, so dropping both is\n * safe on every Node version. See {@link https://github.com/webdriverio/webdriverio/issues/15265}.\n *\n * @param requestOptions - The request options about to be sent by WebDriverIO.\n * @returns The same request options with the forbidden headers removed.\n */\nfunction stripForbiddenFetchHeaders(requestOptions: RequestInit): RequestInit {\n  if (requestOptions.headers instanceof Headers) {\n    requestOptions.headers.delete('Connection');\n    requestOptions.headers.delete('Content-Length');\n  }\n\n  return requestOptions;\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["killAutoStartedProcesses"]
}


package/dist/lib/esm/type-guards.d.mts

@@ -3,6 +3,12 @@
  *
  * Contains utility functions for type guards.
  */
+/**
+ * A generic object with `string` keys and `unknown` values.
+ *
+ * Used as a widening target for dynamic property access on mock objects.
+ */
+export type GenericObject = Record<string, unknown>;
 type NullableConstraint<T> = null extends T ? unknown : undefined extends T ? unknown : never;
 /**
  * Asserts that a value is not `null` or `undefined`, narrowing its type in place.
@@ -15,6 +21,26 @@ type NullableConstraint<T> = null extends T ? unknown : undefined extends T ? un
  * @throws If the value is `null` or `undefined`.
  */
 export declare function assertNonNullable<T extends NullableConstraint<T>>(value: T, errorOrMessage?: Error | string): asserts value is NonNullable<T>;
+/**
+ * Casts a value to a specific type without any runtime check.
+ *
+ * Prefer this over inline `as` assertions: it keeps the unsafe cast in one
+ * auditable place and reads as an explicit, intentional escape hatch.
+ *
+ * @typeParam T - The target type to cast to.
+ * @param value - The value to cast.
+ * @returns The value typed as `T`.
+ */
+export declare function castTo<T>(value: unknown): T;
+/**
+ * Widens an object to a {@link GenericObject} so dynamic string-keyed property
+ * access type-checks.
+ *
+ * @typeParam T - The object type.
+ * @param obj - The object to widen.
+ * @returns The same object typed as `GenericObject & T`.
+ */
+export declare function ensureGenericObject<T extends object>(obj: T): GenericObject & T;
 /**
  * Ensures that a value is not `null` or `undefined` and returns it with narrowed type.
  *

package/dist/lib/esm/type-guards.mjs

@@ -6,12 +6,20 @@ function assertNonNullable(value, errorOrMessage) {
   const error = typeof errorOrMessage === "string" ? new Error(errorOrMessage) : errorOrMessage;
   throw error;
 }
+function castTo(value) {
+  return value;
+}
+function ensureGenericObject(obj) {
+  return obj;
+}
 function ensureNonNullable(value, errorOrMessage) {
   assertNonNullable(value, errorOrMessage);
   return value;
 }
 export {
   assertNonNullable,
+  castTo,
+  ensureGenericObject,
   ensureNonNullable
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-integration-testing",
-  "version": "4.2.2",
+  "version": "4.2.3",
   "description": "Simplifies integration testing of Obsidian plugins.",
   "keywords": [
     "obsidian",