commandkit 1.0.0-dev.20250622124751 → 1.0.0-dev.20250622135945

package/async-queue.cjs

@@ -0,0 +1,9 @@
+const {
+  AsyncQueue,
+  createAsyncQueue,
+} = require('./dist/utils/useful-stuff/async-queue.js');
+
+module.exports = {
+  AsyncQueue,
+  createAsyncQueue,
+};

package/async-queue.d.ts

@@ -0,0 +1 @@
+export * from './dist/utils/useful-stuff/async-queue.js';

package/dist/cli/information.js

@@ -1,5 +1,5 @@
 const require_chunk = require('../chunk-nOFOJqeH.js');
-const require_version = require('../version-CRg5idya.js');
+const require_version = require('../version-DfdnkNI2.js');
 const node_fs = require_chunk.__toESM(require("node:fs"));
 const node_path = require_chunk.__toESM(require("node:path"));
 const node_child_process = require_chunk.__toESM(require("node:child_process"));

package/dist/index.js

@@ -36,7 +36,7 @@ require('./store-CyzliDXj.js');
 const require_helpers = require('./helpers-DfV6HlgI.js');
 require('./app-gCenKq8k.js');
 require('./ILogger-BMIMljYD.js');
-const require_version = require('./version-CRg5idya.js');
+const require_version = require('./version-DfdnkNI2.js');
 const require_feature_flags = require('./feature-flags-CFoqosTw.js');
 const require_init = require('./init-muFynnQh.js');
 

package/dist/utils/useful-stuff/async-queue.d.ts

@@ -0,0 +1,84 @@
+//#region src/utils/useful-stuff/async-queue.d.ts
+/**
+ * Async queue implementation for processing tasks sequentially or with limited concurrency.
+ * Useful for rate-limiting, batching, or controlling resource usage.
+ */
+interface AsyncQueueOptions {
+  /** Maximum number of concurrent tasks. Default: 1 (sequential) */
+  concurrency?: number;
+  /** Optional callback invoked when all tasks are completed */
+  onDrain?: () => void | Promise<void>;
+  /** Optional AbortSignal for cancelling the queue */
+  signal?: AbortSignal;
+}
+type AsyncQueueTask<T> = () => Promise<T>;
+declare class AsyncQueue {
+  private readonly concurrency;
+  private readonly onDrain?;
+  private readonly signal?;
+  private running;
+  private paused;
+  private aborted;
+  private queue;
+  constructor(options?: AsyncQueueOptions);
+  /**
+   * Adds a task to the queue.
+   * @param task - The async function to execute.
+   * @param signal - Optional AbortSignal for cancelling this specific task.
+   * @returns Promise resolving to the result of the task.
+   */
+  add<T>(task: AsyncQueueTask<T>, signal?: AbortSignal): Promise<T>;
+  /**
+   * Pauses the queue. No new tasks will be started until resumed.
+   */
+  pause(): void;
+  /**
+   * Resumes the queue and processes pending tasks.
+   */
+  resume(): void;
+  /**
+   * Aborts the queue, rejecting all pending tasks.
+   */
+  abort(): void;
+  /**
+   * Clears all pending tasks from the queue.
+   */
+  clear(): void;
+  /**
+   * Returns the number of running tasks.
+   */
+  getRunning(): number;
+  /**
+   * Returns the number of pending tasks in the queue.
+   */
+  getPending(): number;
+  /**
+   * Returns true if the queue is currently paused.
+   */
+  isPaused(): boolean;
+  /**
+   * Returns true if the queue has been aborted.
+   */
+  isAborted(): boolean;
+  private next;
+}
+/**
+ * Creates a new async queue instance with the specified configuration.
+ * @param options - Configuration options for the async queue.
+ * @returns New AsyncQueue instance.
+ *
+ * @example
+ * ```typescript
+ * const controller = new AbortController();
+ * const queue = createAsyncQueue({
+ *   concurrency: 2,
+ *   signal: controller.signal
+ * });
+ * queue.add(async () => await doSomething());
+ * controller.abort(); // Aborts the queue
+ * ```
+ */
+declare function createAsyncQueue(options?: AsyncQueueOptions): AsyncQueue;
+//#endregion
+export { AsyncQueue, AsyncQueueOptions, AsyncQueueTask, createAsyncQueue };
+//# sourceMappingURL=async-queue.d.ts.map

package/dist/utils/useful-stuff/async-queue.js

@@ -0,0 +1,136 @@
+
+//#region src/utils/useful-stuff/async-queue.ts
+var AsyncQueue = class {
+	concurrency;
+	onDrain;
+	signal;
+	running = 0;
+	paused = false;
+	aborted = false;
+	queue = [];
+	constructor(options = {}) {
+		this.concurrency = options.concurrency ?? 1;
+		this.onDrain = options.onDrain;
+		this.signal = options.signal;
+		if (this.signal) this.signal.addEventListener("abort", () => {
+			this.abort();
+		});
+	}
+	/**
+	* Adds a task to the queue.
+	* @param task - The async function to execute.
+	* @param signal - Optional AbortSignal for cancelling this specific task.
+	* @returns Promise resolving to the result of the task.
+	*/
+	add(task, signal) {
+		if (this.aborted) return Promise.reject(new Error("Queue has been aborted"));
+		return new Promise((resolve, reject) => {
+			const run = async () => {
+				if (this.paused || this.aborted) {
+					if (this.aborted) reject(new Error("Queue has been aborted"));
+					else this.queue.push(run);
+					return;
+				}
+				if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+					reject(new Error("Task was aborted"));
+					return;
+				}
+				this.running++;
+				try {
+					const result = await task();
+					resolve(result);
+				} catch (err) {
+					reject(err);
+				} finally {
+					this.running--;
+					this.next();
+				}
+			};
+			if (this.running < this.concurrency && !this.paused && !this.aborted) run();
+			else this.queue.push(run);
+		});
+	}
+	/**
+	* Pauses the queue. No new tasks will be started until resumed.
+	*/
+	pause() {
+		this.paused = true;
+	}
+	/**
+	* Resumes the queue and processes pending tasks.
+	*/
+	resume() {
+		if (!this.paused) return;
+		this.paused = false;
+		this.next();
+	}
+	/**
+	* Aborts the queue, rejecting all pending tasks.
+	*/
+	abort() {
+		this.aborted = true;
+		this.clear();
+	}
+	/**
+	* Clears all pending tasks from the queue.
+	*/
+	clear() {
+		this.queue = [];
+	}
+	/**
+	* Returns the number of running tasks.
+	*/
+	getRunning() {
+		return this.running;
+	}
+	/**
+	* Returns the number of pending tasks in the queue.
+	*/
+	getPending() {
+		return this.queue.length;
+	}
+	/**
+	* Returns true if the queue is currently paused.
+	*/
+	isPaused() {
+		return this.paused;
+	}
+	/**
+	* Returns true if the queue has been aborted.
+	*/
+	isAborted() {
+		return this.aborted;
+	}
+	next() {
+		if (this.paused || this.aborted) return;
+		while (this.running < this.concurrency && this.queue.length > 0) {
+			const fn = this.queue.shift();
+			if (fn) fn();
+		}
+		if (this.running === 0 && this.queue.length === 0 && this.onDrain) this.onDrain();
+	}
+};
+/**
+* Creates a new async queue instance with the specified configuration.
+* @param options - Configuration options for the async queue.
+* @returns New AsyncQueue instance.
+*
+* @example
+* ```typescript
+* const controller = new AbortController();
+* const queue = createAsyncQueue({
+*   concurrency: 2,
+*   signal: controller.signal
+* });
+* queue.add(async () => await doSomething());
+* controller.abort(); // Aborts the queue
+* ```
+*/
+function createAsyncQueue(options) {
+	return new AsyncQueue(options);
+}
+
+//#endregion
+exports.AsyncQueue = AsyncQueue;
+exports.createAsyncQueue = createAsyncQueue;
+//# sourceMappingURL=async-queue.js.map

package/dist/utils/useful-stuff/async-queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-queue.js","names":[],"sources":["../../../src/utils/useful-stuff/async-queue.ts"],"sourcesContent":["/**\n * Async queue implementation for processing tasks sequentially or with limited concurrency.\n * Useful for rate-limiting, batching, or controlling resource usage.\n */\n\nexport interface AsyncQueueOptions {\n  /** Maximum number of concurrent tasks. Default: 1 (sequential) */\n  concurrency?: number;\n  /** Optional callback invoked when all tasks are completed */\n  onDrain?: () => void | Promise<void>;\n  /** Optional AbortSignal for cancelling the queue */\n  signal?: AbortSignal;\n}\n\nexport type AsyncQueueTask<T> = () => Promise<T>;\n\nexport class AsyncQueue {\n  private readonly concurrency: number;\n  private readonly onDrain?: () => void | Promise<void>;\n  private readonly signal?: AbortSignal;\n  private running = 0;\n  private paused = false;\n  private aborted = false;\n  private queue: Array<() => void> = [];\n\n  constructor(options: AsyncQueueOptions = {}) {\n    this.concurrency = options.concurrency ?? 1;\n    this.onDrain = options.onDrain;\n    this.signal = options.signal;\n\n    if (this.signal) {\n      this.signal.addEventListener('abort', () => {\n        this.abort();\n      });\n    }\n  }\n\n  /**\n   * Adds a task to the queue.\n   * @param task - The async function to execute.\n   * @param signal - Optional AbortSignal for cancelling this specific task.\n   * @returns Promise resolving to the result of the task.\n   */\n  public add<T>(task: AsyncQueueTask<T>, signal?: AbortSignal): Promise<T> {\n    if (this.aborted) {\n      return Promise.reject(new Error('Queue has been aborted'));\n    }\n\n    return new Promise<T>((resolve, reject) => {\n      const run = async () => {\n        if (this.paused || this.aborted) {\n          if (this.aborted) {\n            reject(new Error('Queue has been aborted'));\n          } else {\n            this.queue.push(run);\n          }\n          return;\n        }\n\n        // Check if task-specific signal is aborted\n        if (signal?.aborted) {\n          reject(new Error('Task was aborted'));\n          return;\n        }\n\n        this.running++;\n        try {\n          const result = await task();\n          resolve(result);\n        } catch (err) {\n          reject(err);\n        } finally {\n          this.running--;\n          this.next();\n        }\n      };\n\n      if (this.running < this.concurrency && !this.paused && !this.aborted) {\n        run();\n      } else {\n        this.queue.push(run);\n      }\n    });\n  }\n\n  /**\n   * Pauses the queue. No new tasks will be started until resumed.\n   */\n  public pause() {\n    this.paused = true;\n  }\n\n  /**\n   * Resumes the queue and processes pending tasks.\n   */\n  public resume() {\n    if (!this.paused) return;\n    this.paused = false;\n    this.next();\n  }\n\n  /**\n   * Aborts the queue, rejecting all pending tasks.\n   */\n  public abort() {\n    this.aborted = true;\n    this.clear();\n  }\n\n  /**\n   * Clears all pending tasks from the queue.\n   */\n  public clear() {\n    this.queue = [];\n  }\n\n  /**\n   * Returns the number of running tasks.\n   */\n  public getRunning(): number {\n    return this.running;\n  }\n\n  /**\n   * Returns the number of pending tasks in the queue.\n   */\n  public getPending(): number {\n    return this.queue.length;\n  }\n\n  /**\n   * Returns true if the queue is currently paused.\n   */\n  public isPaused(): boolean {\n    return this.paused;\n  }\n\n  /**\n   * Returns true if the queue has been aborted.\n   */\n  public isAborted(): boolean {\n    return this.aborted;\n  }\n\n  private next() {\n    if (this.paused || this.aborted) return;\n    while (this.running < this.concurrency && this.queue.length > 0) {\n      const fn = this.queue.shift();\n      if (fn) fn();\n    }\n    if (this.running === 0 && this.queue.length === 0 && this.onDrain) {\n      this.onDrain();\n    }\n  }\n}\n\n/**\n * Creates a new async queue instance with the specified configuration.\n * @param options - Configuration options for the async queue.\n * @returns New AsyncQueue instance.\n *\n * @example\n * ```typescript\n * const controller = new AbortController();\n * const queue = createAsyncQueue({\n *   concurrency: 2,\n *   signal: controller.signal\n * });\n * queue.add(async () => await doSomething());\n * controller.abort(); // Aborts the queue\n * ```\n */\nexport function createAsyncQueue(options?: AsyncQueueOptions): AsyncQueue {\n  return new AsyncQueue(options);\n}\n"],"mappings":";;AAgBA,IAAa,aAAb,MAAwB;CACtB,AAAiB;CACjB,AAAiB;CACjB,AAAiB;CACjB,AAAQ,UAAU;CAClB,AAAQ,SAAS;CACjB,AAAQ,UAAU;CAClB,AAAQ,QAA2B,CAAE;CAErC,YAAY,UAA6B,CAAE,GAAE;AAC3C,OAAK,cAAc,QAAQ,eAAe;AAC1C,OAAK,UAAU,QAAQ;AACvB,OAAK,SAAS,QAAQ;AAEtB,MAAI,KAAK,OACP,MAAK,OAAO,iBAAiB,SAAS,MAAM;AAC1C,QAAK,OAAO;EACb,EAAC;CAEN;;;;;;;CAQA,AAAO,IAAO,MAAyB,QAAkC;AACvE,MAAI,KAAK,QACP,QAAO,QAAQ,OAAO,IAAI,MAAM,0BAA0B;AAG5D,SAAO,IAAI,QAAW,CAAC,SAAS,WAAW;GACzC,MAAM,MAAM,YAAY;AACtB,QAAI,KAAK,UAAU,KAAK,SAAS;AAC/B,SAAI,KAAK,QACP,QAAO,IAAI,MAAM,0BAA0B;SAE3C,MAAK,MAAM,KAAK,IAAI;AAEtB;IACF;AAGA,wDAAI,OAAQ,SAAS;AACnB,YAAO,IAAI,MAAM,oBAAoB;AACrC;IACF;AAEA,SAAK;AACL,QAAI;KACF,MAAM,SAAS,MAAM,MAAM;AAC3B,aAAQ,OAAO;IAChB,SAAQ,KAAK;AACZ,YAAO,IAAI;IACZ,UAAS;AACR,UAAK;AACL,UAAK,MAAM;IACb;GACD;AAED,OAAI,KAAK,UAAU,KAAK,gBAAgB,KAAK,WAAW,KAAK,QAC3D,MAAK;OAEL,MAAK,MAAM,KAAK,IAAI;EAEvB;CACH;;;;CAKA,AAAO,QAAQ;AACb,OAAK,SAAS;CAChB;;;;CAKA,AAAO,SAAS;AACd,OAAK,KAAK,OAAQ;AAClB,OAAK,SAAS;AACd,OAAK,MAAM;CACb;;;;CAKA,AAAO,QAAQ;AACb,OAAK,UAAU;AACf,OAAK,OAAO;CACd;;;;CAKA,AAAO,QAAQ;AACb,OAAK,QAAQ,CAAE;CACjB;;;;CAKA,AAAO,aAAqB;AAC1B,SAAO,KAAK;CACd;;;;CAKA,AAAO,aAAqB;AAC1B,SAAO,KAAK,MAAM;CACpB;;;;CAKA,AAAO,WAAoB;AACzB,SAAO,KAAK;CACd;;;;CAKA,AAAO,YAAqB;AAC1B,SAAO,KAAK;CACd;CAEA,AAAQ,OAAO;AACb,MAAI,KAAK,UAAU,KAAK,QAAS;AACjC,SAAO,KAAK,UAAU,KAAK,eAAe,KAAK,MAAM,SAAS,GAAG;GAC/D,MAAM,KAAK,KAAK,MAAM,OAAO;AAC7B,OAAI,GAAI,KAAI;EACd;AACA,MAAI,KAAK,YAAY,KAAK,KAAK,MAAM,WAAW,KAAK,KAAK,QACxD,MAAK,SAAS;CAElB;AACF;;;;;;;;;;;;;;;;;AAkBA,SAAgB,iBAAiB,SAAyC;AACxE,QAAO,IAAI,WAAW;AACxB"}

package/dist/utils/useful-stuff/mutex.d.ts

@@ -0,0 +1,188 @@
+//#region src/utils/useful-stuff/mutex.d.ts
+/**
+ * Async mutex implementation for coordinating access to shared resources.
+ * Provides mutual exclusion to ensure only one task can access a resource at a time.
+ */
+/**
+ * Interface for mutex storage implementations.
+ * Provides methods to store, retrieve, and delete mutex lock data.
+ */
+interface MutexStorage {
+  /**
+   * Attempts to acquire a lock for a given key
+   * @param key - The unique identifier for the mutex lock
+   * @param timeout - Optional timeout in milliseconds for the lock
+   * @param signal - Optional AbortSignal for cancelling the acquisition
+   * @returns Promise resolving to true if lock was acquired, false if timeout or already locked
+   */
+  acquire(key: string, timeout?: number, signal?: AbortSignal): Promise<boolean>;
+  /**
+   * Releases the lock for a given key
+   * @param key - The unique identifier for the mutex lock
+   * @returns Promise that resolves when the lock is released
+   */
+  release(key: string): Promise<void>;
+  /**
+   * Checks if a lock is currently held for a given key
+   * @param key - The unique identifier for the mutex lock
+   * @returns Promise resolving to true if the lock is held, false otherwise
+   */
+  isLocked(key: string): Promise<boolean>;
+}
+/**
+ * Configuration options for mutex
+ */
+interface MutexOptions {
+  /** Default timeout in milliseconds for lock acquisition. Default: 30000 */
+  timeout?: number;
+  /** Storage implementation for persisting mutex data. Default: {@link MemoryMutexStorage} */
+  storage?: MutexStorage;
+}
+/**
+ * In-memory storage implementation for mutex locks.
+ * Suitable for single-instance applications.
+ */
+declare class MemoryMutexStorage implements MutexStorage {
+  private readonly locks;
+  /**
+   * Attempts to acquire a lock for a given key
+   * @param key - The unique identifier for the mutex lock
+   * @param timeout - Optional timeout in milliseconds for the lock
+   * @param signal - Optional AbortSignal for cancelling the acquisition
+   * @returns Promise resolving to true if lock was acquired, false if timeout or already locked
+   */
+  acquire(key: string, timeout?: number, signal?: AbortSignal): Promise<boolean>;
+  /**
+   * Releases the lock for a given key
+   * @param key - The unique identifier for the mutex lock
+   * @returns Promise that resolves when the lock is released
+   */
+  release(key: string): Promise<void>;
+  /**
+   * Checks if a lock is currently held for a given key
+   * @param key - The unique identifier for the mutex lock
+   * @returns Promise resolving to true if the lock is held, false otherwise
+   */
+  isLocked(key: string): Promise<boolean>;
+  private generateHolderId;
+  private delay;
+}
+/**
+ * Async mutex implementation that provides mutual exclusion for shared resources.
+ * Ensures only one task can access a protected resource at a time.
+ */
+declare class Mutex {
+  private storage;
+  private readonly defaultTimeout;
+  /**
+   * Creates a new mutex instance
+   * @param options - Configuration options for the mutex
+   */
+  constructor(options?: MutexOptions);
+  /**
+   * Sets the storage implementation for the mutex
+   * @param storage - The storage implementation to use
+   */
+  setStorage(storage: MutexStorage): void;
+  /**
+   * Gets the storage implementation for the mutex
+   * @returns The storage implementation
+   */
+  getStorage(): MutexStorage;
+  /**
+   * Acquires a lock for the given key
+   * @param key - The unique identifier for the mutex lock
+   * @param timeout - Optional timeout in milliseconds for lock acquisition
+   * @param signal - Optional AbortSignal for cancelling the acquisition
+   * @returns Promise resolving to true if lock was acquired, false if timeout
+   */
+  acquire(key: string, timeout?: number, signal?: AbortSignal): Promise<boolean>;
+  /**
+   * Releases the lock for the given key
+   * @param key - The unique identifier for the mutex lock
+   * @returns Promise that resolves when the lock is released
+   */
+  release(key: string): Promise<void>;
+  /**
+   * Checks if a lock is currently held for the given key
+   * @param key - The unique identifier for the mutex lock
+   * @returns Promise resolving to true if the lock is held, false otherwise
+   */
+  isLocked(key: string): Promise<boolean>;
+  /**
+   * Executes a function with exclusive access to the resource
+   * @param key - The unique identifier for the mutex lock
+   * @param fn - The function to execute with exclusive access
+   * @param timeout - Optional timeout in milliseconds for lock acquisition
+   * @param signal - Optional AbortSignal for cancelling the lock acquisition
+   * @returns Promise resolving to the result of the function execution
+   * @throws Error if lock acquisition fails or function execution fails
+   */
+  withLock<T>(key: string, fn: () => Promise<T> | T, timeout?: number, signal?: AbortSignal): Promise<T>;
+  /**
+   * Gets the current configuration of the mutex
+   * @returns Object containing the current timeout value
+   */
+  getConfig(): Omit<MutexOptions, 'storage'>;
+}
+/**
+ * Default mutex instance for global use
+ */
+declare const defaultMutex: Mutex;
+/**
+ * Convenience function to execute a function with exclusive access using the default mutex.
+ *
+ * @param key - The unique identifier for the mutex lock
+ * @param fn - The function to execute with exclusive access
+ * @param timeout - Optional timeout in milliseconds for lock acquisition
+ * @param signal - Optional AbortSignal for cancelling the lock acquisition
+ * @returns Promise resolving to the result of the function execution
+ *
+ * @example
+ * ```typescript
+ * const controller = new AbortController();
+ * const result = await withMutex('shared-resource', async () => {
+ *   // This code runs with exclusive access
+ *   return await updateSharedResource();
+ * }, 30000, controller.signal);
+ * controller.abort(); // Cancels the lock acquisition
+ * ```
+ */
+declare function withMutex<T>(key: string, fn: () => Promise<T> | T, timeout?: number, signal?: AbortSignal): Promise<T>;
+/**
+ * Creates a new mutex instance with the specified configuration
+ * @param options - Configuration options for the mutex
+ * @returns New Mutex instance
+ *
+ * @example
+ * ```typescript
+ * const mutex = createMutex({
+ *   timeout: 60000,
+ *   storage: new RedisMutexStorage()
+ * });
+ * ```
+ */
+declare function createMutex(options: MutexOptions): Mutex;
+/**
+ * Acquires a lock using the default mutex
+ * @param key - The unique identifier for the mutex lock
+ * @param timeout - Optional timeout in milliseconds for lock acquisition
+ * @param signal - Optional AbortSignal for cancelling the acquisition
+ * @returns Promise resolving to true if lock was acquired, false if timeout
+ */
+declare function acquireLock(key: string, timeout?: number, signal?: AbortSignal): Promise<boolean>;
+/**
+ * Releases a lock using the default mutex
+ * @param key - The unique identifier for the mutex lock
+ * @returns Promise that resolves when the lock is released
+ */
+declare function releaseLock(key: string): Promise<void>;
+/**
+ * Checks if a lock is held using the default mutex
+ * @param key - The unique identifier for the mutex lock
+ * @returns Promise resolving to true if the lock is held, false otherwise
+ */
+declare function isLocked(key: string): Promise<boolean>;
+//#endregion
+export { MemoryMutexStorage, Mutex, MutexOptions, MutexStorage, acquireLock, createMutex, defaultMutex, isLocked, releaseLock, withMutex };
+//# sourceMappingURL=mutex.d.ts.map

package/dist/utils/useful-stuff/mutex.js

@@ -0,0 +1,214 @@
+
+//#region src/utils/useful-stuff/mutex.ts
+/**
+* In-memory storage implementation for mutex locks.
+* Suitable for single-instance applications.
+*/
+var MemoryMutexStorage = class {
+	locks = /* @__PURE__ */ new Map();
+	/**
+	* Attempts to acquire a lock for a given key
+	* @param key - The unique identifier for the mutex lock
+	* @param timeout - Optional timeout in milliseconds for the lock
+	* @param signal - Optional AbortSignal for cancelling the acquisition
+	* @returns Promise resolving to true if lock was acquired, false if timeout or already locked
+	*/
+	async acquire(key, timeout = 3e4, signal) {
+		const holder = this.generateHolderId();
+		const startTime = Date.now();
+		while (Date.now() - startTime < timeout) {
+			if (signal === null || signal === void 0 ? void 0 : signal.aborted) throw new Error("Lock acquisition was aborted");
+			if (!this.locks.has(key)) {
+				this.locks.set(key, {
+					holder,
+					acquiredAt: Date.now()
+				});
+				return true;
+			}
+			await this.delay(10);
+		}
+		return false;
+	}
+	/**
+	* Releases the lock for a given key
+	* @param key - The unique identifier for the mutex lock
+	* @returns Promise that resolves when the lock is released
+	*/
+	async release(key) {
+		this.locks.delete(key);
+	}
+	/**
+	* Checks if a lock is currently held for a given key
+	* @param key - The unique identifier for the mutex lock
+	* @returns Promise resolving to true if the lock is held, false otherwise
+	*/
+	async isLocked(key) {
+		return this.locks.has(key);
+	}
+	generateHolderId() {
+		return `holder_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+	}
+	delay(ms) {
+		return new Promise((resolve) => setTimeout(resolve, ms));
+	}
+};
+/**
+* Async mutex implementation that provides mutual exclusion for shared resources.
+* Ensures only one task can access a protected resource at a time.
+*/
+var Mutex = class {
+	storage;
+	defaultTimeout;
+	/**
+	* Creates a new mutex instance
+	* @param options - Configuration options for the mutex
+	*/
+	constructor(options = {}) {
+		this.storage = options.storage || new MemoryMutexStorage();
+		this.defaultTimeout = options.timeout || 3e4;
+	}
+	/**
+	* Sets the storage implementation for the mutex
+	* @param storage - The storage implementation to use
+	*/
+	setStorage(storage) {
+		this.storage = storage;
+	}
+	/**
+	* Gets the storage implementation for the mutex
+	* @returns The storage implementation
+	*/
+	getStorage() {
+		return this.storage;
+	}
+	/**
+	* Acquires a lock for the given key
+	* @param key - The unique identifier for the mutex lock
+	* @param timeout - Optional timeout in milliseconds for lock acquisition
+	* @param signal - Optional AbortSignal for cancelling the acquisition
+	* @returns Promise resolving to true if lock was acquired, false if timeout
+	*/
+	async acquire(key, timeout, signal) {
+		return this.storage.acquire(key, timeout || this.defaultTimeout, signal);
+	}
+	/**
+	* Releases the lock for the given key
+	* @param key - The unique identifier for the mutex lock
+	* @returns Promise that resolves when the lock is released
+	*/
+	async release(key) {
+		return this.storage.release(key);
+	}
+	/**
+	* Checks if a lock is currently held for the given key
+	* @param key - The unique identifier for the mutex lock
+	* @returns Promise resolving to true if the lock is held, false otherwise
+	*/
+	async isLocked(key) {
+		return this.storage.isLocked(key);
+	}
+	/**
+	* Executes a function with exclusive access to the resource
+	* @param key - The unique identifier for the mutex lock
+	* @param fn - The function to execute with exclusive access
+	* @param timeout - Optional timeout in milliseconds for lock acquisition
+	* @param signal - Optional AbortSignal for cancelling the lock acquisition
+	* @returns Promise resolving to the result of the function execution
+	* @throws Error if lock acquisition fails or function execution fails
+	*/
+	async withLock(key, fn, timeout, signal) {
+		const acquired = await this.acquire(key, timeout, signal);
+		if (!acquired) throw new Error(`Failed to acquire lock for key: ${key}`);
+		try {
+			return await fn();
+		} finally {
+			await this.release(key);
+		}
+	}
+	/**
+	* Gets the current configuration of the mutex
+	* @returns Object containing the current timeout value
+	*/
+	getConfig() {
+		return { timeout: this.defaultTimeout };
+	}
+};
+/**
+* Default mutex instance for global use
+*/
+const defaultMutex = new Mutex();
+/**
+* Convenience function to execute a function with exclusive access using the default mutex.
+*
+* @param key - The unique identifier for the mutex lock
+* @param fn - The function to execute with exclusive access
+* @param timeout - Optional timeout in milliseconds for lock acquisition
+* @param signal - Optional AbortSignal for cancelling the lock acquisition
+* @returns Promise resolving to the result of the function execution
+*
+* @example
+* ```typescript
+* const controller = new AbortController();
+* const result = await withMutex('shared-resource', async () => {
+*   // This code runs with exclusive access
+*   return await updateSharedResource();
+* }, 30000, controller.signal);
+* controller.abort(); // Cancels the lock acquisition
+* ```
+*/
+async function withMutex(key, fn, timeout, signal) {
+	return defaultMutex.withLock(key, fn, timeout, signal);
+}
+/**
+* Creates a new mutex instance with the specified configuration
+* @param options - Configuration options for the mutex
+* @returns New Mutex instance
+*
+* @example
+* ```typescript
+* const mutex = createMutex({
+*   timeout: 60000,
+*   storage: new RedisMutexStorage()
+* });
+* ```
+*/
+function createMutex(options) {
+	return new Mutex(options);
+}
+/**
+* Acquires a lock using the default mutex
+* @param key - The unique identifier for the mutex lock
+* @param timeout - Optional timeout in milliseconds for lock acquisition
+* @param signal - Optional AbortSignal for cancelling the acquisition
+* @returns Promise resolving to true if lock was acquired, false if timeout
+*/
+async function acquireLock(key, timeout, signal) {
+	return defaultMutex.acquire(key, timeout, signal);
+}
+/**
+* Releases a lock using the default mutex
+* @param key - The unique identifier for the mutex lock
+* @returns Promise that resolves when the lock is released
+*/
+async function releaseLock(key) {
+	return defaultMutex.release(key);
+}
+/**
+* Checks if a lock is held using the default mutex
+* @param key - The unique identifier for the mutex lock
+* @returns Promise resolving to true if the lock is held, false otherwise
+*/
+async function isLocked(key) {
+	return defaultMutex.isLocked(key);
+}
+
+//#endregion
+exports.MemoryMutexStorage = MemoryMutexStorage;
+exports.Mutex = Mutex;
+exports.acquireLock = acquireLock;
+exports.createMutex = createMutex;
+exports.defaultMutex = defaultMutex;
+exports.isLocked = isLocked;
+exports.releaseLock = releaseLock;
+exports.withMutex = withMutex;
+//# sourceMappingURL=mutex.js.map