appium-mac2-driver 4.5.0 → 4.6.0

package/node_modules/appium-chromedriver/lib/utils.ts

@@ -0,0 +1,196 @@
+import {readFileSync} from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+import {BaseDriver} from '@appium/base-driver';
+import {system, fs, node, util} from '@appium/support';
+import axios from 'axios';
+import type {AxiosRequestConfig} from 'axios';
+
+import {OS, CPU} from './constants.js';
+import type {ChromedriverAdb, ChromedriverVersionMapping, OSInfo} from './types.js';
+
+const VERSION_COLLATOR = new Intl.Collator('en', {numeric: true});
+
+const CD_EXECUTABLE_PREFIX = 'chromedriver';
+const MODULE_NAME = 'appium-chromedriver';
+
+/**
+ * Calculates the path to the current module's root folder
+ * @returns The full path to module root
+ * @throws {Error} If the current module root folder cannot be determined
+ */
+const getModuleRoot = util.memoize(function getModuleRoot(): string {
+  const root = node.getModuleRootSync(MODULE_NAME, fileURLToPath(import.meta.url));
+  if (!root) {
+    throw new Error(`Cannot find the root folder of the ${MODULE_NAME} Node.js module`);
+  }
+  return root;
+});
+
+// Chromedriver version: minimum Chrome version
+export const CHROMEDRIVER_CHROME_MAPPING: ChromedriverVersionMapping = JSON.parse(
+  readFileSync(path.join(getModuleRoot(), 'config', 'mapping.json'), 'utf8'),
+);
+export const CD_BASE_DIR = path.join(getModuleRoot(), 'chromedriver');
+
+/**
+ * Compares dotted version strings numerically (e.g. `114.0.5735.90`, `2.46`).
+ * A leading `v` is ignored and missing trailing segments count as `0`.
+ * @returns Negative if `a < b`, positive if `a > b`, zero if equal.
+ */
+export function compareVersions(a: string, b: string): number {
+  const aParts = a.replace(/^v/i, '').split('.');
+  const bParts = b.replace(/^v/i, '').split('.');
+  const len = Math.max(aParts.length, bParts.length);
+  const pad = (parts: string[]) => parts.concat(Array<string>(len - parts.length).fill('0')).join('.');
+  return VERSION_COLLATOR.compare(pad(aParts), pad(bParts));
+}
+
+/**
+ * Gets the most recent Chromedriver version from the mapping.
+ * @param mapping - The Chromedriver version mapping (defaults to the static mapping).
+ * @returns The most recent version string.
+ * @throws {Error} If the mapping is empty.
+ */
+export function getMostRecentChromedriver(mapping: ChromedriverVersionMapping = CHROMEDRIVER_CHROME_MAPPING): string {
+  if (util.isEmpty(mapping)) {
+    throw new Error('Unable to get most recent Chromedriver version from empty mapping');
+  }
+  const sorted = Object.keys(mapping).sort(compareVersions);
+  return sorted.at(-1) as string;
+}
+
+export const CD_VER: string =
+  process.env.npm_config_chromedriver_version || process.env.CHROMEDRIVER_VERSION || getMostRecentChromedriver();
+
+/**
+ * Gets the Chrome version for a given bundle ID using ADB.
+ * @param adb - The ADB-like instance to use.
+ * @param bundleId - The bundle ID of the Chrome/WebView app.
+ * @returns The version name string, or undefined if not found.
+ */
+export async function getChromeVersion(
+  adb: Pick<ChromedriverAdb, 'getPackageInfo'>,
+  bundleId: string,
+): Promise<string | undefined> {
+  const {versionName} = await adb.getPackageInfo(bundleId);
+  return versionName;
+}
+
+/**
+ * Gets the directory path for Chromedriver executables for a given OS.
+ * @param osName - The OS name (defaults to the current OS).
+ * @returns The full path to the Chromedriver directory.
+ */
+export function getChromedriverDir(osName: string = getOsName()): string {
+  return path.resolve(CD_BASE_DIR, osName);
+}
+
+/**
+ * Gets the path to the Chromedriver binary for a given OS.
+ * @param osName - The OS name (defaults to the current OS).
+ * @returns The full path to the Chromedriver binary.
+ */
+export async function getChromedriverBinaryPath(osName: string = getOsName()): Promise<string> {
+  const rootDir = getChromedriverDir(osName);
+  const pathSuffix = osName === OS.WINDOWS ? '.exe' : '';
+  const paths = await fs.glob(`${CD_EXECUTABLE_PREFIX}*${pathSuffix}`, {
+    cwd: rootDir,
+    absolute: true,
+    nocase: true,
+    nodir: true,
+  });
+  return paths[0] ?? path.resolve(rootDir, `${CD_EXECUTABLE_PREFIX}${pathSuffix}`);
+}
+
+/**
+ * Retrieves data from a URL using axios.
+ * @param url - The URL to fetch from.
+ * @param headers - Optional HTTP headers.
+ * @param opts - Optional configuration (timeout, responseType).
+ * @returns The response data.
+ */
+export async function retrieveData(
+  url: string,
+  headers?: AxiosRequestConfig['headers'],
+  opts: Pick<AxiosRequestConfig, 'timeout' | 'responseType'> = {},
+): Promise<any> {
+  const {timeout = 5000, responseType = 'text'} = opts;
+  return (
+    await axios({
+      url,
+      headers,
+      timeout,
+      responseType,
+    })
+  ).data;
+}
+
+/**
+ * Gets the OS name for the current system.
+ * @returns The OS name ('win', 'mac', or 'linux').
+ */
+export const getOsName = util.memoize(function getOsName(): (typeof OS)[keyof typeof OS] {
+  if (system.isWindows()) {
+    return OS.WINDOWS;
+  }
+  if (system.isMac()) {
+    return OS.MAC;
+  }
+  return OS.LINUX;
+});
+
+/**
+ * Gets the CPU type for the current system.
+ * @returns The CPU type ('intel' or 'arm').
+ */
+export const getCpuType = util.memoize(function getCpuType(): (typeof CPU)[keyof typeof CPU] {
+  return os.cpus()[0]?.model.toLowerCase().includes('apple') ? CPU.ARM : CPU.INTEL;
+});
+
+/**
+ * Gets OS information including name, architecture, and CPU type.
+ * @returns A promise that resolves to OS information.
+ */
+export const getOsInfo = util.memoize(async function getOsInfo(): Promise<OSInfo> {
+  return {
+    name: getOsName(),
+    arch: String(await system.arch()),
+    cpu: getCpuType(),
+  };
+});
+
+// @ts-expect-error to avoid error
+// TS2345: Argument of type '{}' is not assignable to parameter of type 'DriverOpts<Readonly<Record<string, Constraint>>>'
+// Type '{}' is missing the following properties from type 'ServerArgs': address, allowCors, allowInsecure, basePath, and 26 more.
+const getBaseDriverInstance = util.memoize(() => new BaseDriver({}, false));
+
+/**
+ * Generates log prefix string.
+ * @param obj - Log owner instance.
+ * @param sessionId - Optional session identifier.
+ * @returns The generated log prefix string.
+ */
+export function generateLogPrefix(obj: any, sessionId: string | null = null): string {
+  return getBaseDriverInstance().helpers.generateDriverLogPrefix(obj, sessionId ? sessionId : undefined);
+}
+
+/**
+ * Converts the given object to an integer number if possible.
+ * @param value - The value to be converted.
+ * @returns The integer value or null if conversion is not possible.
+ */
+export function convertToInt(value: any): number | null {
+  switch (typeof value) {
+    case 'number':
+      return Number.isNaN(value) ? null : value;
+    case 'string': {
+      const parsedAsInt = parseInt(value, 10);
+      return Number.isNaN(parsedAsInt) ? null : parsedAsInt;
+    }
+    default:
+      return null;
+  }
+}

package/node_modules/appium-chromedriver/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "appium-chromedriver",
+  "version": "9.2.2",
+  "description": "Node.js wrapper around chromedriver.",
+  "keywords": [
+    "android",
+    "appium",
+    "chrome"
+  ],
+  "homepage": "https://appium.io",
+  "bugs": {
+    "url": "https://github.com/appium/appium-android/issues"
+  },
+  "license": "Apache-2.0",
+  "author": "Appium Contributors",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/appium/appium-android.git",
+    "directory": "packages/chromedriver"
+  },
+  "directories": {
+    "lib": "lib"
+  },
+  "files": [
+    "config",
+    "lib",
+    "build/lib",
+    "CHANGELOG.md"
+  ],
+  "type": "module",
+  "main": "./build/lib/index.js",
+  "types": "./build/lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/lib/index.d.ts",
+      "import": "./build/lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "tsc -b --clean",
+    "dev": "npm run build -- --watch",
+    "prepare": "npm run build",
+    "test": "node --enable-source-maps --experimental-test-module-mocks --test --test-force-exit --test-timeout=60000 \"./build/test/unit/**/*.spec.js\"",
+    "test:e2e": "node --enable-source-maps --test --test-force-exit --test-concurrency=1 --test-timeout=600000 \"./build/test/functional/**/*.spec.js\""
+  },
+  "dependencies": {
+    "@appium/base-driver": "^10.8.0",
+    "@appium/support": "^7.2.6",
+    "@xmldom/xmldom": "^0.x",
+    "asyncbox": "^6.5.0",
+    "axios": "^1.21.0",
+    "semver": "^7.0.0",
+    "teen_process": "^4.2.0",
+    "xpath": "^0.x"
+  },
+  "devDependencies": {
+    "@appium/tsconfig": "^1.2.0",
+    "@types/express": "^5.0.6",
+    "@types/node": "^26.6.5",
+    "@types/semver": "^7.0.0",
+    "@types/sinon": "^22.0.2",
+    "sinon": "^22.0.0"
+  },
+  "engines": {
+    "node": "^20.19.0 || ^22.12.0 || >=24.0.0",
+    "npm": ">=10"
+  },
+  "gitHead": "dfe10bc251ed9ad1d821ea1b71e7f1682e07662b"
+}

package/node_modules/appium-xcode/CHANGELOG.md

@@ -3,6 +3,13 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [7.2.4](https://github.com/appium/appium-ios/compare/appium-xcode@7.2.3...appium-xcode@7.2.4) (2026-10-23)
+
+### Miscellaneous Chores
+
+* use AsyncLock from asyncbox instead of async-lock ([#107](https://github.com/appium/appium-ios/issues/107)) ([c6f7784](https://github.com/appium/appium-ios/commit/c6f7784ce933cc5910103b756645e159453964a2))
+
+
 ## [7.2.3](https://github.com/appium/appium-ios/compare/appium-xcode@7.2.2...appium-xcode@7.2.3) (2026-10-02)
 
 ### Miscellaneous Chores

package/node_modules/appium-xcode/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appium-xcode",
-  "version": "7.2.3",
+  "version": "7.2.4",
   "description": "Interact with Xcode",
   "keywords": [
     "appium",
@@ -43,19 +43,19 @@
   },
   "dependencies": {
     "@appium/support": "^7.2.8",
-    "asyncbox": "^6.4.3",
+    "asyncbox": "^6.5.0",
     "semver": "^7.8.5",
     "teen_process": "^4.2.1"
   },
   "devDependencies": {
     "@appium/tsconfig": "^1.2.1",
     "@appium/types": "^1.7.1",
-    "@types/node": "^26.6.3",
+    "@types/node": "^26.6.5",
     "@types/semver": "^7.8.0"
   },
   "engines": {
     "node": "^20.19.0 || ^22.12.0 || >=24.0.0",
     "npm": ">=10"
   },
-  "gitHead": "da9df509454bca268192150e4d3302d7f000a5c9"
+  "gitHead": "81fb72dc3b3f23f23c804f1969f0c1eb19c8a7a2"
 }

package/node_modules/asyncbox/README.md

@@ -208,6 +208,49 @@ try {
 }
 ```
 
+### AsyncLock
+
+A promise-based mutex keyed by string, derived from the unmaintained
+[async-lock](https://github.com/rogierschouten/async-lock) (MIT). Tasks with the
+same key run one at a time in FIFO order; different keys run concurrently.
+
+Differences from `async-lock`: promises only (no callbacks, custom `Promise`
+or domain support), and each task runs in the `AsyncLocalStorage` context of
+its own `acquire` caller instead of the previous lock holder's one, so no
+`AsyncResource.bind` is needed. A task that outlives `maxExecutionTime` can no
+longer release the lock a second time, and queued tasks that time out are
+removed from the queue.
+
+```js
+import {AsyncLock} from 'asyncbox';
+
+const lock = new AsyncLock({maxPending: 10});
+
+const result = await lock.acquire('key', async () => {
+  // runs exclusively for 'key'
+  return 42;
+});
+
+// several keys are held together; they are acquired in sorted order, so overlapping calls cannot deadlock
+await lock.acquire(['key1', 'key2'], () => {});
+
+// per-call options: timeout, maxOccupationTime, maxExecutionTime, maxPending, skipQueue
+await lock.acquire('key', () => {}, {timeout: 5000, skipQueue: true});
+
+lock.getQueueLength('key'); // tasks waiting for the key (the running one is not counted)
+lock.isBusy('key'); // running or pending tasks for the key
+lock.isBusy(); // any key
+```
+
+Options can be passed to the constructor and overridden per `acquire` call.
+Times are in ms, up to 2147483647, and `0` means no limit.
+
+- `timeout` (default `0`) - max wait in the queue (for all the keys of a multi-key call together) before the task is rejected and dropped
+- `maxOccupationTime` (default `0`) - max time from `acquire` to completion, queue wait included; one budget is shared by all keys of a multi-key call
+- `maxExecutionTime` (default `0`) - max time the task may run while holding the lock; the lock is released when exceeded (for a multi-key call, it counts from when all keys are held and releases all of them)
+- `maxPending` (default `1000`) - max tasks waiting per key; further ones are rejected right away, so `0` rejects every task that would have to wait
+- `skipQueue` (default `false`, per call only) - put the task at the front of the queue
+
 ### Run the tests
 
 ```

package/node_modules/asyncbox/build/cjs/lib/asyncfilter.d.ts

@@ -0,0 +1,9 @@
+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 declare function asyncfilter<T>(coll: T[], filter: (value: T) => boolean | Promise<boolean>, options?: MapFilterOptions): Promise<T[]>;
+//# sourceMappingURL=asyncfilter.d.ts.map

package/node_modules/asyncbox/build/cjs/lib/asyncfilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asyncfilter.d.ts","sourceRoot":"","sources":["../../../lib/asyncfilter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,YAAY,CAAC;AAEjD;;;;;GAKG;AACH,wBAAsB,WAAW,CAAC,CAAC,EACjC,IAAI,EAAE,CAAC,EAAE,EACT,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,EAChD,OAAO,GAAE,gBAAuB,GAC/B,OAAO,CAAC,CAAC,EAAE,CAAC,CAwBd"}

package/node_modules/asyncbox/build/cjs/lib/asyncfilter.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asyncfilter = asyncfilter;
+const limit_function_js_1 = require("./limit-function.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)
+ */
+async function asyncfilter(coll, filter, options = true) {
+    if (options === null) {
+        throw new Error('Options cannot be null');
+    }
+    // limitFunction requires the filter to always return a promise
+    const filterAsync = async (value) => filter(value);
+    if (options === false) {
+        return coll.reduce(async (accP, item) => {
+            const acc = await accP;
+            if (await filterAsync(item)) {
+                acc.push(item);
+            }
+            return acc;
+        }, Promise.resolve([]));
+    }
+    const adjustedFilter = options === true ? filterAsync : (await (0, limit_function_js_1.getLimitFunction)())(filterAsync, { concurrency: options.concurrency });
+    const bools = await Promise.all(coll.map(adjustedFilter));
+    return coll.reduce((acc, item, i) => {
+        if (bools[i]) {
+            acc.push(item);
+        }
+        return acc;
+    }, []);
+}
+//# sourceMappingURL=asyncfilter.js.map

package/node_modules/asyncbox/build/cjs/lib/asyncfilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"asyncfilter.js","sourceRoot":"","sources":["../../../lib/asyncfilter.ts"],"names":[],"mappings":";;AASA,kCA4BC;AArCD,2DAAqD;AAGrD;;;;;GAKG;AACI,KAAK,UAAU,WAAW,CAC/B,IAAS,EACT,MAAgD,EAChD,UAA4B,IAAI;IAEhC,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;QACrB,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC;IAC5C,CAAC;IACD,+DAA+D;IAC/D,MAAM,WAAW,GAAG,KAAK,EAAE,KAAQ,EAAoB,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACxE,IAAI,OAAO,KAAK,KAAK,EAAE,CAAC;QACtB,OAAO,IAAI,CAAC,MAAM,CAAe,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE;YACpD,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC;YACvB,IAAI,MAAM,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC5B,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACjB,CAAC;YACD,OAAO,GAAG,CAAC;QACb,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC;IAC1B,CAAC;IACD,MAAM,cAAc,GAClB,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,MAAM,IAAA,oCAAgB,GAAE,CAAC,CAAC,WAAW,EAAE,EAAC,WAAW,EAAE,OAAO,CAAC,WAAW,EAAC,CAAC,CAAC;IAC/G,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC;IAC1D,OAAO,IAAI,CAAC,MAAM,CAAM,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE;QACvC,IAAI,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;YACb,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACjB,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC,EAAE,EAAE,CAAC,CAAC;AACT,CAAC"}

package/node_modules/asyncbox/build/cjs/lib/asyncmap.d.ts

@@ -0,0 +1,9 @@
+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 declare function asyncmap<T, R>(coll: T[], mapper: (value: T) => R | Promise<R>, options?: MapFilterOptions): Promise<R[]>;
+//# sourceMappingURL=asyncmap.d.ts.map

package/node_modules/asyncbox/build/cjs/lib/asyncmap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asyncmap.d.ts","sourceRoot":"","sources":["../../../lib/asyncmap.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,YAAY,CAAC;AAEjD;;;;;GAKG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAAE,CAAC,EACjC,IAAI,EAAE,CAAC,EAAE,EACT,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EACpC,OAAO,GAAE,gBAAuB,GAC/B,OAAO,CAAC,CAAC,EAAE,CAAC,CAed"}

package/node_modules/asyncbox/build/cjs/lib/asyncmap.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asyncmap = asyncmap;
+const limit_function_js_1 = require("./limit-function.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)
+ */
+async function asyncmap(coll, mapper, options = true) {
+    if (options === null) {
+        throw new Error('Options cannot be null');
+    }
+    // limitFunction requires the mapper to always return a promise
+    const mapperAsync = async (value) => mapper(value);
+    if (options === false) {
+        return coll.reduce(async (acc, item) => [...(await acc), await mapperAsync(item)], Promise.resolve([]));
+    }
+    const adjustedMapper = options === true ? mapperAsync : (await (0, limit_function_js_1.getLimitFunction)())(mapperAsync, { concurrency: options.concurrency });
+    return Promise.all(coll.map(adjustedMapper));
+}
+//# sourceMappingURL=asyncmap.js.map

package/node_modules/asyncbox/build/cjs/lib/asyncmap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"asyncmap.js","sourceRoot":"","sources":["../../../lib/asyncmap.ts"],"names":[],"mappings":";;AASA,4BAmBC;AA5BD,2DAAqD;AAGrD;;;;;GAKG;AACI,KAAK,UAAU,QAAQ,CAC5B,IAAS,EACT,MAAoC,EACpC,UAA4B,IAAI;IAEhC,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;QACrB,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC;IAC5C,CAAC;IACD,+DAA+D;IAC/D,MAAM,WAAW,GAAG,KAAK,EAAE,KAAQ,EAAc,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAClE,IAAI,OAAO,KAAK,KAAK,EAAE,CAAC;QACtB,OAAO,IAAI,CAAC,MAAM,CAChB,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE,MAAM,WAAW,CAAC,IAAI,CAAC,CAAC,EAC9D,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CACpB,CAAC;IACJ,CAAC;IACD,MAAM,cAAc,GAClB,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,MAAM,IAAA,oCAAgB,GAAE,CAAC,CAAC,WAAW,EAAE,EAAC,WAAW,EAAE,OAAO,CAAC,WAAW,EAAC,CAAC,CAAC;IAC/G,OAAO,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC;AAC/C,CAAC"}

package/node_modules/asyncbox/build/cjs/lib/errors.d.ts

@@ -0,0 +1,9 @@
+/** Error thrown by {@link withTimeout} when the deadline is exceeded. */
+export declare class TimeoutError extends Error {
+    constructor(message?: string);
+}
+/** Thrown when a promise is cancelled via `cancel`. */
+export declare class PromiseCancellationError extends Error {
+    constructor(message?: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/node_modules/asyncbox/build/cjs/lib/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../lib/errors.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,qBAAa,YAAa,SAAQ,KAAK;gBACzB,OAAO,CAAC,EAAE,MAAM;CAI7B;AAED,uDAAuD;AACvD,qBAAa,wBAAyB,SAAQ,KAAK;gBACrC,OAAO,GAAE,MAA4B;CAIlD"}

package/node_modules/asyncbox/build/cjs/lib/errors.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromiseCancellationError = exports.TimeoutError = void 0;
+/** Error thrown by {@link withTimeout} when the deadline is exceeded. */
+class TimeoutError extends Error {
+    constructor(message) {
+        super(message ?? 'Operation timed out');
+        this.name = 'TimeoutError';
+    }
+}
+exports.TimeoutError = TimeoutError;
+/** Thrown when a promise is cancelled via `cancel`. */
+class PromiseCancellationError extends Error {
+    constructor(message = 'Promise cancelled') {
+        super(message);
+        this.name = 'PromiseCancellationError';
+    }
+}
+exports.PromiseCancellationError = PromiseCancellationError;
+//# sourceMappingURL=errors.js.map

package/node_modules/asyncbox/build/cjs/lib/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../lib/errors.ts"],"names":[],"mappings":";;;AAAA,yEAAyE;AACzE,MAAa,YAAa,SAAQ,KAAK;IACrC,YAAY,OAAgB;QAC1B,KAAK,CAAC,OAAO,IAAI,qBAAqB,CAAC,CAAC;QACxC,IAAI,CAAC,IAAI,GAAG,cAAc,CAAC;IAC7B,CAAC;CACF;AALD,oCAKC;AAED,uDAAuD;AACvD,MAAa,wBAAyB,SAAQ,KAAK;IACjD,YAAY,UAAkB,mBAAmB;QAC/C,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,0BAA0B,CAAC;IACzC,CAAC;CACF;AALD,4DAKC"}

package/node_modules/asyncbox/build/cjs/lib/index.d.ts

@@ -0,0 +1,12 @@
+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';
+//# sourceMappingURL=index.d.ts.map

package/node_modules/asyncbox/build/cjs/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAE,wBAAwB,EAAC,MAAM,aAAa,CAAC;AACnE,OAAO,EAAC,KAAK,EAAC,MAAM,YAAY,CAAC;AACjC,OAAO,EAAC,WAAW,EAAC,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EAAC,KAAK,EAAE,aAAa,EAAC,MAAM,YAAY,CAAC;AAChD,OAAO,EAAC,QAAQ,EAAC,MAAM,eAAe,CAAC;AACvC,OAAO,EAAC,WAAW,EAAC,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAC,gBAAgB,EAAC,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAC,SAAS,EAAC,MAAM,WAAW,CAAC;AAEpC,YAAY,EAAC,gBAAgB,EAAE,cAAc,EAAC,MAAM,WAAW,CAAC;AAChE,YAAY,EACV,kBAAkB,EAClB,QAAQ,EACR,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,EAChB,QAAQ,EACR,YAAY,EACZ,uBAAuB,GACxB,MAAM,YAAY,CAAC"}

package/node_modules/asyncbox/build/cjs/lib/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncLock = exports.waitForCondition = exports.asyncfilter = exports.asyncmap = exports.retryInterval = exports.retry = exports.longSleep = exports.withTimeout = exports.sleep = exports.PromiseCancellationError = exports.TimeoutError = void 0;
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "TimeoutError", { enumerable: true, get: function () { return errors_js_1.TimeoutError; } });
+Object.defineProperty(exports, "PromiseCancellationError", { enumerable: true, get: function () { return errors_js_1.PromiseCancellationError; } });
+var sleep_js_1 = require("./sleep.js");
+Object.defineProperty(exports, "sleep", { enumerable: true, get: function () { return sleep_js_1.sleep; } });
+var with_timeout_js_1 = require("./with-timeout.js");
+Object.defineProperty(exports, "withTimeout", { enumerable: true, get: function () { return with_timeout_js_1.withTimeout; } });
+var long_sleep_js_1 = require("./long-sleep.js");
+Object.defineProperty(exports, "longSleep", { enumerable: true, get: function () { return long_sleep_js_1.longSleep; } });
+var retry_js_1 = require("./retry.js");
+Object.defineProperty(exports, "retry", { enumerable: true, get: function () { return retry_js_1.retry; } });
+Object.defineProperty(exports, "retryInterval", { enumerable: true, get: function () { return retry_js_1.retryInterval; } });
+var asyncmap_js_1 = require("./asyncmap.js");
+Object.defineProperty(exports, "asyncmap", { enumerable: true, get: function () { return asyncmap_js_1.asyncmap; } });
+var asyncfilter_js_1 = require("./asyncfilter.js");
+Object.defineProperty(exports, "asyncfilter", { enumerable: true, get: function () { return asyncfilter_js_1.asyncfilter; } });
+var wait_for_condition_js_1 = require("./wait-for-condition.js");
+Object.defineProperty(exports, "waitForCondition", { enumerable: true, get: function () { return wait_for_condition_js_1.waitForCondition; } });
+var lock_js_1 = require("./lock.js");
+Object.defineProperty(exports, "AsyncLock", { enumerable: true, get: function () { return lock_js_1.AsyncLock; } });
+//# sourceMappingURL=index.js.map

package/node_modules/asyncbox/build/cjs/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../lib/index.ts"],"names":[],"mappings":";;;AAAA,yCAAmE;AAA3D,yGAAA,YAAY,OAAA;AAAE,qHAAA,wBAAwB,OAAA;AAC9C,uCAAiC;AAAzB,iGAAA,KAAK,OAAA;AACb,qDAA8C;AAAtC,8GAAA,WAAW,OAAA;AACnB,iDAA0C;AAAlC,0GAAA,SAAS,OAAA;AACjB,uCAAgD;AAAxC,iGAAA,KAAK,OAAA;AAAE,yGAAA,aAAa,OAAA;AAC5B,6CAAuC;AAA/B,uGAAA,QAAQ,OAAA;AAChB,mDAA6C;AAArC,6GAAA,WAAW,OAAA;AACnB,iEAAyD;AAAjD,yHAAA,gBAAgB,OAAA;AACxB,qCAAoC;AAA5B,oGAAA,SAAS,OAAA"}

package/node_modules/asyncbox/build/cjs/lib/limit-function.d.ts

@@ -0,0 +1,3 @@
+import type { limitFunction } from 'p-limit';
+export declare function getLimitFunction(): Promise<typeof limitFunction>;
+//# sourceMappingURL=limit-function.d.ts.map

package/node_modules/asyncbox/build/cjs/lib/limit-function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"limit-function.d.ts","sourceRoot":"","sources":["../../../lib/limit-function.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,SAAS,CAAC;AAc3C,wBAAsB,gBAAgB,kCAGrC"}

package/node_modules/asyncbox/build/cjs/lib/limit-function.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLimitFunction = getLimitFunction;
+// 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)');
+let limitFunctionPromise;
+async function getLimitFunction() {
+    limitFunctionPromise ??= dynamicImport('p-limit');
+    return (await limitFunctionPromise).limitFunction;
+}
+//# sourceMappingURL=limit-function.js.map

package/node_modules/asyncbox/build/cjs/lib/limit-function.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"limit-function.js","sourceRoot":"","sources":["../../../lib/limit-function.ts"],"names":[],"mappings":";;AAcA,4CAGC;AAbD,mFAAmF;AACnF,6FAA6F;AAC7F,0EAA0E;AAC1E,iGAAiG;AACjG,4FAA4F;AAC5F,MAAM,aAAa,GAAG,IAAI,QAAQ,CAAC,WAAW,EAAE,0BAA0B,CAEhD,CAAC;AAE3B,IAAI,oBAAuD,CAAC;AACrD,KAAK,UAAU,gBAAgB;IACpC,oBAAoB,KAAK,aAAa,CAAC,SAAS,CAAC,CAAC;IAClD,OAAO,CAAC,MAAM,oBAAoB,CAAC,CAAC,aAAa,CAAC;AACpD,CAAC"}

package/node_modules/asyncbox/build/cjs/lib/lock.d.ts

@@ -0,0 +1,74 @@
+/** 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>;
+/**
+ * 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 declare class AsyncLock {
+    private readonly queues;
+    private readonly defaults;
+    constructor(opts?: AsyncLockOptions);
+    /**
+     * 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>;
+    /**
+     * Number of tasks waiting for `key`, not counting the running one.
+     *
+     * @param key - Resource key
+     */
+    getQueueLength(key: string): number;
+    /**
+     * Whether `key` has a running or pending task. Without a key, whether any key does.
+     *
+     * @param key - Resource key
+     */
+    isBusy(key?: string): boolean;
+}
+export {};
+//# sourceMappingURL=lock.d.ts.map