appium-mac2-driver 4.5.1 → 4.6.1

package/node_modules/@appium/base-driver/node_modules/asyncbox/build/esm/lib/wait-for-condition.js

@@ -0,0 +1,48 @@
+import { sleep } from './sleep.js';
+/**
+ * Takes a condition (a function returning a boolean or boolean promise), and
+ * waits until the condition is true.
+ *
+ * Throws a `/Condition unmet/` error if the condition has not been satisfied
+ * within the allocated time, unless an error is provided in the options, as the
+ * `error` property, which is either thrown itself, or used as the message.
+ *
+ * The condition result is returned if it is not falsy. If the condition throws an
+ * error then this exception will be immediately passed through.
+ *
+ * The default options are: `{ waitMs: 5000, intervalMs: 500 }`
+ * @param condFn - The condition function to evaluate
+ * @param options - Options for controlling the wait behavior
+ */
+export async function waitForCondition(condFn, options = {}) {
+    const opts = {
+        ...options,
+        waitMs: typeof options.waitMs === 'number' ? options.waitMs : 5000,
+        intervalMs: typeof options.intervalMs === 'number' ? options.intervalMs : 500,
+    };
+    const debug = opts.logger ? opts.logger.debug.bind(opts.logger) : () => undefined;
+    const error = opts.error;
+    const begunAt = performance.now();
+    const endAt = begunAt + opts.waitMs;
+    const spin = async function spin() {
+        const result = await condFn();
+        if (result) {
+            return result;
+        }
+        const now = performance.now();
+        const waited = Math.round(now - begunAt);
+        const remainingTime = endAt - now;
+        if (now < endAt) {
+            debug(`Waited for ${waited} ms so far`);
+            await sleep(Math.min(opts.intervalMs, remainingTime));
+            return await spin();
+        }
+        // if there is an error option, it is either a string message or an error itself
+        if (error) {
+            throw typeof error === 'string' ? new Error(error) : error;
+        }
+        throw new Error(`Condition unmet after ${waited} ms. Timing out.`);
+    };
+    return await spin();
+}
+//# sourceMappingURL=wait-for-condition.js.map

package/node_modules/@appium/base-driver/node_modules/asyncbox/build/esm/lib/wait-for-condition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait-for-condition.js","sourceRoot":"","sources":["../../../lib/wait-for-condition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,EAAC,MAAM,YAAY,CAAC;AAGjC;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,MAA4B,EAC5B,UAAmC,EAAE;IAErC,MAAM,IAAI,GAAmE;QAC3E,GAAG,OAAO;QACV,MAAM,EAAE,OAAO,OAAO,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI;QAClE,UAAU,EAAE,OAAO,OAAO,CAAC,UAAU,KAAK,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG;KAC9E,CAAC;IACF,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC;IAClF,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;IACzB,MAAM,OAAO,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;IAClC,MAAM,KAAK,GAAG,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC;IACpC,MAAM,IAAI,GAAG,KAAK,UAAU,IAAI;QAC9B,MAAM,MAAM,GAAG,MAAM,MAAM,EAAE,CAAC;QAC9B,IAAI,MAAM,EAAE,CAAC;YACX,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,MAAM,GAAG,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;QAC9B,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,OAAO,CAAC,CAAC;QACzC,MAAM,aAAa,GAAG,KAAK,GAAG,GAAG,CAAC;QAClC,IAAI,GAAG,GAAG,KAAK,EAAE,CAAC;YAChB,KAAK,CAAC,cAAc,MAAM,YAAY,CAAC,CAAC;YACxC,MAAM,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,EAAE,aAAa,CAAC,CAAC,CAAC;YACtD,OAAO,MAAM,IAAI,EAAE,CAAC;QACtB,CAAC;QACD,gFAAgF;QAChF,IAAI,KAAK,EAAE,CAAC;YACV,MAAM,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QAC7D,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,yBAAyB,MAAM,kBAAkB,CAAC,CAAC;IACrE,CAAC,CAAC;IACF,OAAO,MAAM,IAAI,EAAE,CAAC;AACtB,CAAC"}

package/node_modules/@appium/base-driver/node_modules/asyncbox/build/esm/lib/with-timeout.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Resolves with `promise` or rejects if it does not settle before `timeoutMs`.
+ *
+ * If the deadline passes first: with no third argument (or a falsy non-error value), rejects
+ * with {@link TimeoutError} whose message includes `timeoutMs`; with a non-empty string,
+ * rejects with {@link TimeoutError} using that message; with an `Error` instance, rejects
+ * with that same instance.
+ *
+ * @param promise - Promise to race against the timeout.
+ * @param timeoutMs - Maximum time in milliseconds before rejecting if `promise` has not settled.
+ * @param messageOrError - Optional override for the timeout rejection: custom {@link TimeoutError}
+ * message when the string is non-empty, or an existing `Error` to reject with verbatim.
+ * Omitted, `undefined`, or other falsy non-error values use the default timeout message (includes `timeoutMs`).
+ */
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, messageOrError?: string | Error): Promise<T>;
+//# sourceMappingURL=with-timeout.d.ts.map

package/node_modules/@appium/base-driver/node_modules/asyncbox/build/esm/lib/with-timeout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-timeout.d.ts","sourceRoot":"","sources":["../../../lib/with-timeout.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,wBAAsB,WAAW,CAAC,CAAC,EACjC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,SAAS,EAAE,MAAM,EACjB,cAAc,CAAC,EAAE,MAAM,GAAG,KAAK,GAC9B,OAAO,CAAC,CAAC,CAAC,CAsBZ"}

package/node_modules/@appium/base-driver/node_modules/asyncbox/build/esm/lib/with-timeout.js

@@ -0,0 +1,42 @@
+import { TimeoutError } from './errors.js';
+/**
+ * Resolves with `promise` or rejects if it does not settle before `timeoutMs`.
+ *
+ * If the deadline passes first: with no third argument (or a falsy non-error value), rejects
+ * with {@link TimeoutError} whose message includes `timeoutMs`; with a non-empty string,
+ * rejects with {@link TimeoutError} using that message; with an `Error` instance, rejects
+ * with that same instance.
+ *
+ * @param promise - Promise to race against the timeout.
+ * @param timeoutMs - Maximum time in milliseconds before rejecting if `promise` has not settled.
+ * @param messageOrError - Optional override for the timeout rejection: custom {@link TimeoutError}
+ * message when the string is non-empty, or an existing `Error` to reject with verbatim.
+ * Omitted, `undefined`, or other falsy non-error values use the default timeout message (includes `timeoutMs`).
+ */
+export async function withTimeout(promise, timeoutMs, messageOrError) {
+    let timer = null;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => {
+                    if (typeof messageOrError === 'string' && messageOrError) {
+                        reject(new TimeoutError(messageOrError));
+                    }
+                    else if (!messageOrError) {
+                        reject(new TimeoutError(`Operation timed out after ${timeoutMs}ms`));
+                    }
+                    else {
+                        reject(messageOrError);
+                    }
+                }, timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer) {
+            clearTimeout(timer);
+        }
+    }
+}
+//# sourceMappingURL=with-timeout.js.map

package/node_modules/@appium/base-driver/node_modules/asyncbox/build/esm/lib/with-timeout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-timeout.js","sourceRoot":"","sources":["../../../lib/with-timeout.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAEzC;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,OAAmB,EACnB,SAAiB,EACjB,cAA+B;IAE/B,IAAI,KAAK,GAA0B,IAAI,CAAC;IACxC,IAAI,CAAC;QACH,OAAO,MAAM,OAAO,CAAC,IAAI,CAAC;YACxB,OAAO;YACP,IAAI,OAAO,CAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE;gBAClC,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE;oBACtB,IAAI,OAAO,cAAc,KAAK,QAAQ,IAAI,cAAc,EAAE,CAAC;wBACzD,MAAM,CAAC,IAAI,YAAY,CAAC,cAAc,CAAC,CAAC,CAAC;oBAC3C,CAAC;yBAAM,IAAI,CAAC,cAAc,EAAE,CAAC;wBAC3B,MAAM,CAAC,IAAI,YAAY,CAAC,6BAA6B,SAAS,IAAI,CAAC,CAAC,CAAC;oBACvE,CAAC;yBAAM,CAAC;wBACN,MAAM,CAAC,cAAc,CAAC,CAAC;oBACzB,CAAC;gBACH,CAAC,EAAE,SAAS,CAAC,CAAC;YAChB,CAAC,CAAC;SACH,CAAC,CAAC;IACL,CAAC;YAAS,CAAC;QACT,IAAI,KAAK,EAAE,CAAC;YACV,YAAY,CAAC,KAAK,CAAC,CAAC;QACtB,CAAC;IACH,CAAC;AACH,CAAC"}

package/node_modules/@appium/base-driver/node_modules/asyncbox/build/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/node_modules/@appium/base-driver/node_modules/asyncbox/lib/asyncfilter.ts

@@ -0,0 +1,38 @@
+import {getLimitFunction} from './limit-function.js';
+import type {MapFilterOptions} from './types.js';
+
+/**
+ * Similar to `Array.prototype.filter`; runs in parallel, serial, or with custom concurrency pool
+ * @param coll - The collection to filter
+ * @param filter - The function to test each element
+ * @param options - Options for controlling parallelism (default: true - fully parallel)
+ */
+export async function asyncfilter<T>(
+  coll: T[],
+  filter: (value: T) => boolean | Promise<boolean>,
+  options: MapFilterOptions = true,
+): Promise<T[]> {
+  if (options === null) {
+    throw new Error('Options cannot be null');
+  }
+  // limitFunction requires the filter to always return a promise
+  const filterAsync = async (value: T): Promise<boolean> => filter(value);
+  if (options === false) {
+    return coll.reduce<Promise<T[]>>(async (accP, item) => {
+      const acc = await accP;
+      if (await filterAsync(item)) {
+        acc.push(item);
+      }
+      return acc;
+    }, Promise.resolve([]));
+  }
+  const adjustedFilter =
+    options === true ? filterAsync : (await getLimitFunction())(filterAsync, {concurrency: options.concurrency});
+  const bools = await Promise.all(coll.map(adjustedFilter));
+  return coll.reduce<T[]>((acc, item, i) => {
+    if (bools[i]) {
+      acc.push(item);
+    }
+    return acc;
+  }, []);
+}

package/node_modules/@appium/base-driver/node_modules/asyncbox/lib/asyncmap.ts

@@ -0,0 +1,29 @@
+import {getLimitFunction} from './limit-function.js';
+import type {MapFilterOptions} from './types.js';
+
+/**
+ * Similar to `Array.prototype.map`; runs in parallel, serial, or with custom concurrency pool
+ * @param coll - The collection to map over
+ * @param mapper - The function to apply to each element
+ * @param options - Options for controlling parallelism (default: true - fully parallel)
+ */
+export async function asyncmap<T, R>(
+  coll: T[],
+  mapper: (value: T) => R | Promise<R>,
+  options: MapFilterOptions = true,
+): Promise<R[]> {
+  if (options === null) {
+    throw new Error('Options cannot be null');
+  }
+  // limitFunction requires the mapper to always return a promise
+  const mapperAsync = async (value: T): Promise<R> => mapper(value);
+  if (options === false) {
+    return coll.reduce<Promise<R[]>>(
+      async (acc, item) => [...(await acc), await mapperAsync(item)],
+      Promise.resolve([]),
+    );
+  }
+  const adjustedMapper =
+    options === true ? mapperAsync : (await getLimitFunction())(mapperAsync, {concurrency: options.concurrency});
+  return Promise.all(coll.map(adjustedMapper));
+}

package/node_modules/@appium/base-driver/node_modules/asyncbox/lib/errors.ts

@@ -0,0 +1,15 @@
+/** Error thrown by {@link withTimeout} when the deadline is exceeded. */
+export class TimeoutError extends Error {
+  constructor(message?: string) {
+    super(message ?? 'Operation timed out');
+    this.name = 'TimeoutError';
+  }
+}
+
+/** Thrown when a promise is cancelled via `cancel`. */
+export class PromiseCancellationError extends Error {
+  constructor(message: string = 'Promise cancelled') {
+    super(message);
+    this.name = 'PromiseCancellationError';
+  }
+}

package/node_modules/@appium/base-driver/node_modules/asyncbox/lib/index.ts

@@ -0,0 +1,21 @@
+export {TimeoutError, PromiseCancellationError} from './errors.js';
+export {sleep} from './sleep.js';
+export {withTimeout} from './with-timeout.js';
+export {longSleep} from './long-sleep.js';
+export {retry, retryInterval} from './retry.js';
+export {asyncmap} from './asyncmap.js';
+export {asyncfilter} from './asyncfilter.js';
+export {waitForCondition} from './wait-for-condition.js';
+export {AsyncLock} from './lock.js';
+
+export type {AsyncLockOptions, AcquireOptions} from './lock.js';
+export type {
+  CancellablePromise,
+  Progress,
+  ProgressCallback,
+  LongSleepOptions,
+  MapFilterOptions,
+  SleepArg,
+  SleepOptions,
+  WaitForConditionOptions,
+} from './types.js';

package/node_modules/@appium/base-driver/node_modules/asyncbox/lib/limit-function.ts

@@ -0,0 +1,18 @@
+import type {limitFunction} from 'p-limit';
+
+type PLimitModule = {limitFunction: typeof limitFunction};
+
+// p-limit is ESM-only. tsc downlevels a plain `import()` in CommonJS output into a
+// require()-in-a-microtask, which still hits Node's require(esm) interop and can race with a
+// concurrent dynamic import() of the same module elsewhere in the process
+// (ERR_REQUIRE_ESM_RACE_CONDITION). Route through `new Function` so tsc can't see or rewrite the
+// import() call, keeping it a genuine native dynamic import in both the ESM and CJS builds.
+const dynamicImport = new Function('specifier', 'return import(specifier)') as (
+  specifier: string,
+) => Promise<PLimitModule>;
+
+let limitFunctionPromise: Promise<PLimitModule> | undefined;
+export async function getLimitFunction() {
+  limitFunctionPromise ??= dynamicImport('p-limit');
+  return (await limitFunctionPromise).limitFunction;
+}

package/node_modules/@appium/base-driver/node_modules/asyncbox/lib/lock.ts

@@ -0,0 +1,360 @@
+import {AsyncResource} from 'node:async_hooks';
+
+const DEFAULT_MAX_PENDING = 1000;
+// setTimeout fires after 1 ms for anything above this
+const MAX_TIMER_MS = 2 ** 31 - 1;
+
+/** Options shared by the {@link AsyncLock} constructor and {@link AsyncLock.acquire}. */
+export interface AsyncLockOptions {
+  /**
+   * Max ms a task may wait in the queue before failing. `0` means never.
+   * @default 0
+   */
+  timeout?: number;
+  /**
+   * Max ms between calling `acquire` and the task finishing (queue wait included). `0` means never.
+   * @default 0
+   */
+  maxOccupationTime?: number;
+  /**
+   * Max ms the task may run once it holds the lock; the lock is then released. `0` means never.
+   * @default 0
+   */
+  maxExecutionTime?: number;
+  /**
+   * Max number of tasks waiting per key; further ones are rejected right away. `0` rejects every
+   * task that would have to wait.
+   * @default 1000
+   */
+  maxPending?: number;
+}
+
+/** Per-call options of {@link AsyncLock.acquire}; override the constructor ones. */
+export interface AcquireOptions extends AsyncLockOptions {
+  /**
+   * Put the task at the front of the queue instead of the back.
+   * @default false
+   */
+  skipQueue?: boolean;
+}
+
+type Task<T> = () => T | PromiseLike<T>;
+type Outcome<T> = {value: T} | {error: unknown};
+type Queues = Map<string, Array<() => void>>;
+type ResolvedOptions = Required<AsyncLockOptions> & {skipQueue?: boolean};
+type ClaimOptions = Pick<ResolvedOptions, 'timeout' | 'maxPending' | 'skipQueue'>;
+
+/**
+ * Promise-based mutex keyed by string. Tasks with the same key run one at a time, in FIFO order.
+ *
+ * Each task runs in the async context (`AsyncLocalStorage`) of the code that called
+ * {@link AsyncLock.acquire}, not in the context of the task that held the lock before it.
+ */
+export class AsyncLock {
+  private readonly queues: Queues = new Map();
+  private readonly defaults: Required<AsyncLockOptions>;
+
+  constructor(opts: AsyncLockOptions = {}) {
+    validateOptions(opts);
+    this.defaults = {
+      timeout: 0,
+      maxOccupationTime: 0,
+      maxExecutionTime: 0,
+      maxPending: DEFAULT_MAX_PENDING,
+      ...stripUndefined(opts),
+    };
+  }
+
+  /**
+   * Run `fn` once the lock for `key` is free and release the lock when it settles.
+   *
+   * Multiple keys are held together. They are acquired one by one in sorted order, whatever order
+   * they are given in, so that overlapping calls cannot deadlock; duplicates are ignored. Keys that
+   * are already held stay held while a later one is awaited. `timeout` and `maxOccupationTime` are
+   * budgets for the whole call, while `maxExecutionTime` counts from the moment all the keys are
+   * held and releases all of them.
+   *
+   * @param key - Resource key, or a non-empty array of keys
+   * @param fn - Task to run while holding the lock; may be sync or async
+   * @param opts - Per-call options
+   * @returns The result of `fn`
+   * @throws {TypeError} Synchronously, if an argument is invalid
+   */
+  acquire<T>(key: string | readonly string[], fn: Task<T>, opts: AcquireOptions = {}): Promise<T> {
+    if (typeof fn !== 'function') {
+      throw new TypeError('You must pass a function to execute');
+    }
+    if (
+      typeof key !== 'string' &&
+      !(Array.isArray(key) && key.length > 0 && [...key].every((k) => typeof k === 'string'))
+    ) {
+      throw new TypeError('The key must be a string or a non-empty array of strings');
+    }
+    validateOptions(opts);
+    // A canonical order keeps overlapping multi-key calls, e.g. ['a', 'b'] and ['b', 'a'], from deadlocking
+    const keys = typeof key === 'string' ? [key] : [...new Set(key)].sort();
+    const acquisition = new Acquisition(this.queues, keys, fn, {...this.defaults, ...stripUndefined(opts)});
+    acquisition.enqueue();
+    return acquisition.promise;
+  }
+
+  /**
+   * Number of tasks waiting for `key`, not counting the running one.
+   *
+   * @param key - Resource key
+   */
+  getQueueLength(key: string): number {
+    return this.queues.get(key)?.length ?? 0;
+  }
+
+  /**
+   * Whether `key` has a running or pending task. Without a key, whether any key does.
+   *
+   * @param key - Resource key
+   */
+  isBusy(key?: string): boolean {
+    return key === undefined ? this.queues.size > 0 : this.queues.has(key);
+  }
+}
+
+/** The place of one acquisition in the queue of one key; once granted, it holds the key. */
+class KeyClaim {
+  private holding = false;
+  private dropped = false;
+  private queueTimer?: NodeJS.Timeout;
+
+  constructor(
+    private readonly queues: Queues,
+    private readonly key: string,
+    private readonly opts: ClaimOptions,
+    private readonly onGranted: () => void,
+    private readonly onDenied: (error: Error) => void,
+  ) {}
+
+  /**
+   * Take the key right away if it is free, otherwise wait in its queue.
+   *
+   * @returns Whether the key is held. If not, `onGranted` is called once it is, unless the claim
+   * is denied.
+   */
+  join(): boolean {
+    const {timeout, maxPending, skipQueue} = this.opts;
+    const queue = this.queues.get(this.key);
+    if (!queue) {
+      this.queues.set(this.key, []);
+      this.holding = true;
+      return true;
+    }
+    if (queue.length >= maxPending) {
+      this.onDenied(new Error(`Too many pending tasks in queue ${this.key}`));
+    } else {
+      if (skipQueue) {
+        queue.unshift(this.grant);
+      } else {
+        queue.push(this.grant);
+      }
+      if (timeout) {
+        this.queueTimer = setTimeout(
+          () => this.onDenied(new Error(`async-lock timed out in queue ${this.key}`)),
+          timeout,
+        );
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Leave the queue, or release the key if it is held. Idempotent.
+   *
+   * @returns The handover of the key to its next waiter. The caller must run it only after it
+   * has released all of its keys, so that no waiter starts while a batch is partially released.
+   */
+  drop(): (() => void) | undefined {
+    if (this.dropped) {
+      return undefined;
+    }
+    this.dropped = true;
+    clearTimeout(this.queueTimer);
+    if (this.holding) {
+      return this.releaseKey();
+    }
+    const queue = this.queues.get(this.key);
+    const idx = queue?.indexOf(this.grant) ?? -1;
+    if (idx >= 0) {
+      queue?.splice(idx, 1);
+    }
+    return undefined;
+  }
+
+  private releaseKey(): (() => void) | undefined {
+    const next = this.queues.get(this.key)?.shift();
+    if (!next) {
+      this.queues.delete(this.key);
+    }
+    return next;
+  }
+
+  // An arrow function, because this exact reference sits in the queue and is removed by drop()
+  private readonly grant = (): void => {
+    clearTimeout(this.queueTimer);
+    this.holding = true;
+    if (this.dropped) {
+      // Dropped while the key was being handed over to it: pass the key on instead of using it
+      this.releaseKey()?.();
+      return;
+    }
+    this.onGranted();
+  };
+}
+
+/**
+ * One `acquire` call: its promise, its timers and its claims on all of its keys. The keys are
+ * claimed one by one, the task runs once all of them are held and they are released together.
+ */
+class Acquisition<T> {
+  readonly promise: Promise<T>;
+  private resolve!: (value: T) => void;
+  private reject!: (error: unknown) => void;
+  private readonly task: Task<T>;
+  private readonly claims: KeyClaim[] = [];
+  private running = false;
+  private settled = false;
+  private queueDeadline = 0;
+  private occupationTimer?: NodeJS.Timeout;
+  private executionTimer?: NodeJS.Timeout;
+
+  constructor(
+    private readonly queues: Queues,
+    private readonly keys: string[],
+    task: Task<T>,
+    private readonly opts: ResolvedOptions,
+  ) {
+    // Queued tasks are started from the previous task's promise chain; bind to keep our context
+    this.task = AsyncResource.bind(task);
+    this.promise = new Promise<T>((resolve, reject) => {
+      this.resolve = resolve;
+      this.reject = reject;
+    });
+  }
+
+  /** Start the task right away if all the keys are free, otherwise wait for them. */
+  enqueue(): void {
+    const {timeout, maxOccupationTime} = this.opts;
+    if (timeout) {
+      this.queueDeadline = performance.now() + timeout;
+    }
+    if (maxOccupationTime) {
+      this.occupationTimer = setTimeout(() => this.expire(), maxOccupationTime);
+    }
+    this.claimKeys(0);
+  }
+
+  // Free keys are claimed in a loop, not recursively, so that a large batch cannot overflow the stack
+  private claimKeys(from: number): void {
+    const {maxPending, skipQueue} = this.opts;
+    try {
+      for (let index = from; index < this.keys.length; index++) {
+        // The queue timeout is a budget for waiting for all the keys, not for each one
+        const timeout = this.queueDeadline ? Math.max(this.queueDeadline - performance.now(), 1) : 0;
+        const claim = new KeyClaim(
+          this.queues,
+          this.keys[index],
+          {timeout, maxPending, skipQueue},
+          () => this.claimKeys(index + 1),
+          (error) => this.abort(error),
+        );
+        this.claims.push(claim);
+        if (!claim.join()) {
+          return;
+        }
+      }
+      this.execute();
+    } catch (error) {
+      this.abort(error);
+    }
+  }
+
+  private execute(): void {
+    const {maxExecutionTime} = this.opts;
+    this.running = true;
+    if (maxExecutionTime) {
+      this.executionTimer = setTimeout(
+        () => this.abort(new Error(`Maximum execution time is exceeded ${this.keys.join(', ')}`)),
+        maxExecutionTime,
+      );
+    }
+    new Promise<T>((resolve) => resolve(this.task())).then(
+      (value) => this.finish({value}),
+      (error) => this.finish({error}),
+    );
+  }
+
+  private finish(outcome: Outcome<T>): void {
+    this.settle(outcome);
+    this.release();
+  }
+
+  // Reject and release all the keys; a running task is left to finish on its own
+  private abort(error: unknown): void {
+    this.settle({error});
+    this.release();
+  }
+
+  // A running task keeps its keys until it finishes, an unstarted one gives them up
+  private expire(): void {
+    const keys = this.keys.join(', ');
+    if (this.running) {
+      this.settle({error: new Error(`Maximum occupation time is exceeded while executing ${keys}`)});
+    } else {
+      this.abort(new Error(`Maximum occupation time is exceeded in queue ${keys}`));
+    }
+  }
+
+  private settle(outcome: Outcome<T>): void {
+    if (this.settled) {
+      return;
+    }
+    this.settled = true;
+    clearTimeout(this.occupationTimer);
+    if ('error' in outcome) {
+      this.reject(outcome.error);
+    } else {
+      this.resolve(outcome.value);
+    }
+  }
+
+  // Idempotent, so a task that outlives its execution timeout cannot release the keys twice
+  private release(): void {
+    clearTimeout(this.executionTimer);
+    const handovers = this.claims
+      .splice(0)
+      .reverse()
+      .map((claim) => claim.drop());
+    for (const handover of handovers) {
+      handover?.();
+    }
+  }
+}
+
+function validateOptions(opts: AcquireOptions): void {
+  if (opts === null || typeof opts !== 'object') {
+    throw new TypeError('The options must be an object');
+  }
+  for (const name of ['timeout', 'maxOccupationTime', 'maxExecutionTime'] as const) {
+    const value = opts[name];
+    if (value !== undefined && !(Number.isFinite(value) && value >= 0 && value <= MAX_TIMER_MS)) {
+      throw new TypeError(`${name} must be a number of milliseconds between 0 and ${MAX_TIMER_MS}`);
+    }
+  }
+  if (opts.skipQueue !== undefined && typeof opts.skipQueue !== 'boolean') {
+    throw new TypeError('skipQueue must be a boolean');
+  }
+  const {maxPending} = opts;
+  if (maxPending !== undefined && maxPending !== Infinity && !(Number.isInteger(maxPending) && maxPending >= 0)) {
+    throw new TypeError('maxPending must be a non-negative integer or Infinity');
+  }
+}
+
+function stripUndefined<T extends object>(obj: T): Partial<T> {
+  return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined)) as Partial<T>;
+}

package/node_modules/@appium/base-driver/node_modules/asyncbox/lib/long-sleep.ts

@@ -0,0 +1,38 @@
+import {sleep} from './sleep.js';
+import type {LongSleepOptions} from './types.js';
+
+const LONG_SLEEP_THRESHOLD = 5000; // anything over 5000ms will turn into a spin
+
+/**
+ * Sometimes `Promise.delay` or `setTimeout` are inaccurate for large wait
+ * times. To safely wait for these long times (e.g. in the 5+ minute range), you
+ * can use `longSleep`.
+ *
+ * You can also pass a `progressCb` option which is a callback function that
+ * receives an object with the properties `elapsedMs`, `timeLeft`, and
+ * `progress`. This will be called on every wait interval so you can do your
+ * wait logging or whatever.
+ * @param ms - The number of milliseconds to wait
+ * @param options - Options for controlling the long sleep behavior
+ */
+export async function longSleep(
+  ms: number,
+  {thresholdMs = LONG_SLEEP_THRESHOLD, intervalMs = 1000, progressCb = null}: LongSleepOptions = {},
+): Promise<void> {
+  if (ms < thresholdMs) {
+    return await sleep(ms);
+  }
+  const endAt = performance.now() + ms;
+  let timeLeft: number;
+  let elapsedMs = 0;
+  do {
+    const pre = performance.now();
+    await sleep(intervalMs);
+    const post = performance.now();
+    timeLeft = endAt - post;
+    elapsedMs = elapsedMs + (post - pre);
+    if (typeof progressCb === 'function') {
+      progressCb({elapsedMs: Math.round(elapsedMs), timeLeft: Math.round(timeLeft), progress: elapsedMs / ms});
+    }
+  } while (timeLeft > 0);
+}