@md-oss/mutex 0.1.0

package/LICENSE

@@ -0,0 +1,5 @@
+Copyright 2026 Mirasaki Development
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,398 @@
+# @md-oss/mutex
+
+Mutex manager with automatic cleanup and TTL support for preventing race conditions in asynchronous operations.
+
+## Features
+
+- **Exclusive Execution** - Ensure only one operation runs at a time for a given key
+- **Automatic Cleanup** - Mutexes are automatically removed after a configurable TTL
+- **Flexible Keys** - Support for string keys or object-based keys with automatic normalization
+- **Wait for Unlock** - Wait for a mutex to become available without acquiring it
+- **Memory Efficient** - Unused mutexes are garbage collected based on TTL
+
+## Installation
+
+```bash
+pnpm add @md-oss/mutex
+```
+
+## Usage
+
+### Basic Usage
+
+```typescript
+import { MutexManager } from '@md-oss/mutex';
+
+// Create a mutex manager with 60 second TTL
+const mutexManager = new MutexManager(60000);
+
+// Run exclusive operation with string key
+await mutexManager.runExclusive('user-123', async () => {
+  // This code will only run when no other operation with key 'user-123' is running
+  await updateUserBalance(123);
+});
+```
+
+### Preventing Race Conditions
+
+```typescript
+import { MutexManager } from '@md-oss/mutex';
+
+const mutexManager = new MutexManager(30000);
+
+// Without mutex - race condition possible
+async function incrementCounter(userId: string) {
+  const current = await getCounter(userId);
+  await saveCounter(userId, current + 1);
+}
+
+// With mutex - safe from race conditions
+async function incrementCounterSafe(userId: string) {
+  await mutexManager.runExclusive(`counter-${userId}`, async () => {
+    const current = await getCounter(userId);
+    await saveCounter(userId, current + 1);
+  });
+}
+
+// Multiple concurrent calls are now safe
+await Promise.all([
+  incrementCounterSafe('user-1'),
+  incrementCounterSafe('user-1'),
+  incrementCounterSafe('user-1')
+]);
+// Counter will be incremented exactly 3 times, no race condition
+```
+
+### Object-Based Keys
+
+```typescript
+// Use object keys for complex identifiers
+await mutexManager.runExclusive(
+  { userId: '123', action: 'update-profile' },
+  async () => {
+    await updateUserProfile(123, profileData);
+  }
+);
+
+// Object keys are automatically normalized
+// These are equivalent:
+mutexManager.getMutex({ userId: '123', action: 'update' });
+mutexManager.getMutex({ action: 'update', userId: '123' }); // Same mutex
+```
+
+### Manual Mutex Management
+
+```typescript
+// Get a mutex without running code
+const mutex = mutexManager.getMutex('resource-key');
+
+// Acquire and release manually
+const release = await mutex.acquire();
+try {
+  // Do exclusive work
+  await someOperation();
+} finally {
+  release();
+}
+
+// Check if locked
+if (mutex.isLocked()) {
+  console.log('Mutex is currently held');
+}
+```
+
+### Wait for Unlock
+
+```typescript
+// Wait for a mutex to become available without acquiring it
+await mutexManager.waitIfLocked('resource-key');
+console.log('Mutex is now unlocked');
+
+// Useful for waiting on operations without blocking
+async function waitForUserUpdate(userId: string) {
+  await mutexManager.waitIfLocked(`user-${userId}`);
+  // User update is complete, safe to read
+  return await getUser(userId);
+}
+```
+
+## Use Cases
+
+### 1. Database Updates
+
+```typescript
+const dbMutex = new MutexManager(10000);
+
+async function updateUserBalance(userId: string, amount: number) {
+  await dbMutex.runExclusive(`balance-${userId}`, async () => {
+    const balance = await db.getBalance(userId);
+    await db.setBalance(userId, balance + amount);
+  });
+}
+
+// Safe concurrent balance updates
+await Promise.all([
+  updateUserBalance('123', 100),
+  updateUserBalance('123', -50),
+  updateUserBalance('123', 25)
+]);
+```
+
+### 2. File Operations
+
+```typescript
+const fileMutex = new MutexManager(5000);
+
+async function appendToFile(filename: string, content: string) {
+  await fileMutex.runExclusive(filename, async () => {
+    const existing = await fs.readFile(filename, 'utf-8');
+    await fs.writeFile(filename, existing + content);
+  });
+}
+```
+
+### 3. Cache Refreshing
+
+```typescript
+const cacheMutex = new MutexManager(60000);
+
+async function getCachedData(key: string) {
+  if (cache.has(key)) {
+    return cache.get(key);
+  }
+
+  // Only one request refreshes the cache
+  return await cacheMutex.runExclusive(`cache-${key}`, async () => {
+    // Double-check inside mutex
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+
+    const data = await fetchExpensiveData(key);
+    cache.set(key, data);
+    return data;
+  });
+}
+```
+
+### 4. API Rate Limiting
+
+```typescript
+const apiMutex = new MutexManager(1000);
+
+async function makeRateLimitedRequest(apiKey: string, request: any) {
+  await apiMutex.runExclusive(apiKey, async () => {
+    await fetch('https://api.example.com', {
+      headers: { 'X-API-Key': apiKey },
+      body: JSON.stringify(request)
+    });
+    // Wait 1 second before allowing next request
+    await new Promise(resolve => setTimeout(resolve, 1000));
+  });
+}
+```
+
+### 5. Resource Initialization
+
+```typescript
+const initMutex = new MutexManager(30000);
+const resources = new Map<string, Resource>();
+
+async function getOrCreateResource(id: string): Promise<Resource> {
+  await initMutex.runExclusive(`resource-${id}`, async () => {
+    if (!resources.has(id)) {
+      const resource = await initializeResource(id);
+      resources.set(id, resource);
+    }
+  });
+  
+  return resources.get(id)!;
+}
+```
+
+## TTL and Cleanup
+
+The mutex manager automatically cleans up unused mutexes after the configured TTL:
+
+```typescript
+// Create with 30 second TTL
+const manager = new MutexManager(30000);
+
+// Use a mutex
+await manager.runExclusive('key-1', async () => {
+  // Do work
+});
+
+// Timer resets on each use
+await manager.runExclusive('key-1', async () => {
+  // Do more work
+});
+
+// After 30 seconds of inactivity, 'key-1' mutex is cleaned up
+// Memory is freed and a new mutex will be created on next use
+```
+
+### TTL Configuration Guidelines
+
+```typescript
+// Short-lived operations (API requests, quick DB queries)
+const shortTTL = new MutexManager(5000); // 5 seconds
+
+// Medium-lived operations (file processing, cache updates)
+const mediumTTL = new MutexManager(30000); // 30 seconds
+
+// Long-lived operations (background jobs, user sessions)
+const longTTL = new MutexManager(300000); // 5 minutes
+```
+
+## Key Normalization
+
+Object keys are automatically normalized for consistency:
+
+```typescript
+const manager = new MutexManager(10000);
+
+// All of these use the same mutex
+manager.getMutex({ userId: '123', type: 'update' });
+manager.getMutex({ type: 'update', userId: '123' }); // Same
+manager.getMutex({ userId: '123', type: 'update' }); // Same
+
+// Normalized to: "mutex-type-update-userId-123"
+```
+
+## Error Handling
+
+```typescript
+const manager = new MutexManager(10000);
+
+try {
+  await manager.runExclusive('resource', async () => {
+    throw new Error('Operation failed');
+  });
+} catch (error) {
+  // Error is propagated, mutex is released
+  console.error('Operation failed:', error);
+}
+
+// Mutex is automatically released even on error
+```
+
+## Performance Considerations
+
+- **Mutex Creation**: O(1) - mutexes are created on-demand
+- **Key Normalization**: O(n log n) for object keys, O(1) for strings
+- **Memory**: Automatic cleanup prevents memory leaks
+- **Concurrency**: Each key has its own mutex, allowing parallel operations on different keys
+
+```typescript
+// These can run in parallel (different keys)
+await Promise.all([
+  manager.runExclusive('user-1', async () => { /* ... */ }),
+  manager.runExclusive('user-2', async () => { /* ... */ }),
+  manager.runExclusive('user-3', async () => { /* ... */ })
+]);
+
+// These run sequentially (same key)
+await Promise.all([
+  manager.runExclusive('user-1', async () => { /* ... */ }),
+  manager.runExclusive('user-1', async () => { /* ... */ }),
+  manager.runExclusive('user-1', async () => { /* ... */ })
+]);
+```
+
+## API Reference
+
+### Constructor
+
+```typescript
+new MutexManager(ttl: number)
+```
+
+Create a new mutex manager with the specified TTL in milliseconds.
+
+### Methods
+
+#### `getMutex(key)`
+
+```typescript
+getMutex(key: string | Record<string, string>): Mutex
+```
+
+Get or create a mutex for the given key. Resets the cleanup timer.
+
+#### `runExclusive(key, fn)`
+
+```typescript
+async runExclusive<T>(
+  key: string | Record<string, string>,
+  fn: () => Promise<T>
+): Promise<T>
+```
+
+Acquire the mutex for the given key, execute the function exclusively, then release the mutex.
+
+#### `waitIfLocked(key)`
+
+```typescript
+async waitIfLocked(key: string | Record<string, string>): Promise<void>
+```
+
+Wait for the mutex to become available without acquiring it. Returns immediately if the mutex is not locked.
+
+## Best Practices
+
+### 1. Choose Appropriate TTL
+
+```typescript
+// Match TTL to operation frequency
+const frequentOps = new MutexManager(5000);   // Operations every few seconds
+const infrequentOps = new MutexManager(60000); // Operations every few minutes
+```
+
+### 2. Use Descriptive Keys
+
+```typescript
+// Good - clear and specific
+manager.runExclusive(`user-${userId}-balance`, async () => { /* ... */ });
+
+// Bad - ambiguous
+manager.runExclusive(userId, async () => { /* ... */ });
+```
+
+### 3. Keep Critical Sections Small
+
+```typescript
+// Good - minimal time in mutex
+await manager.runExclusive('resource', async () => {
+  await criticalOperation();
+});
+await nonCriticalOperation();
+
+// Bad - unnecessary time in mutex
+await manager.runExclusive('resource', async () => {
+  await criticalOperation();
+  await nonCriticalOperation(); // Doesn't need mutex
+});
+```
+
+### 4. Handle Errors Properly
+
+```typescript
+await manager.runExclusive('key', async () => {
+  try {
+    await riskyOperation();
+  } catch (error) {
+    // Handle error inside mutex if needed
+    await rollback();
+    throw error; // Re-throw if appropriate
+  }
+});
+```
+
+## Underlying Library
+
+This package is built on top of [async-mutex](https://github.com/DirtyHairy/async-mutex) and adds:
+- Automatic cleanup with TTL
+- Key normalization for objects
+- Centralized mutex management
+- Simplified API for common patterns

package/dist/index.cjs

@@ -0,0 +1,2 @@
+"use strict";var u=Object.defineProperty;var r=(s,e)=>u(s,"name",{value:e,configurable:!0});var a=require("async-mutex");class n{static{r(this,"MutexManager")}mutexMap=new Map;cleanupTimers=new Map;ttl;constructor(e){this.ttl=e}cleanup(e){this.mutexMap.delete(e);const t=this.cleanupTimers.get(e);t&&(clearTimeout(t),this.cleanupTimers.delete(e))}resetCleanupTimer(e){const t=this.cleanupTimers.get(e);t&&clearTimeout(t);const i=setTimeout(()=>{this.cleanup(e)},this.ttl);this.cleanupTimers.set(e,i)}normalizeKey(e){return typeof e=="string"?e:`mutex-${Object.entries(e).sort(([t],[i])=>t.localeCompare(i)).map(([t,i])=>`${t}-${i}`).join("-")}`}getMutex(e){const t=this.normalizeKey(e);return this.mutexMap.has(t)||this.mutexMap.set(t,new a.Mutex),this.resetCleanupTimer(t),this.mutexMap.get(t)}async runExclusive(e,t){return this.getMutex(e).runExclusive(t)}async waitIfLocked(e){const t=this.getMutex(e);t.isLocked()&&await t.waitForUnlock()}}exports.MutexManager=n;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../src/index.ts"],"sourcesContent":["import { Mutex } from 'async-mutex';\n\nclass MutexManager {\n\tprivate readonly mutexMap = new Map<string, Mutex>();\n\tprivate readonly cleanupTimers = new Map<string, NodeJS.Timeout>();\n\tprivate readonly ttl: number;\n\n\tconstructor(ttl: number) {\n\t\tthis.ttl = ttl;\n\t}\n\n\tprivate cleanup(key: string) {\n\t\tthis.mutexMap.delete(key);\n\t\tconst timer = this.cleanupTimers.get(key);\n\t\tif (timer) {\n\t\t\tclearTimeout(timer);\n\t\t\tthis.cleanupTimers.delete(key);\n\t\t}\n\t}\n\n\tprivate resetCleanupTimer(key: string) {\n\t\tconst existingTimer = this.cleanupTimers.get(key);\n\t\tif (existingTimer) {\n\t\t\tclearTimeout(existingTimer);\n\t\t}\n\n\t\tconst timer = setTimeout(() => {\n\t\t\tthis.cleanup(key);\n\t\t}, this.ttl);\n\n\t\tthis.cleanupTimers.set(key, timer);\n\t}\n\n\tprivate normalizeKey(key: string | Record<string, string>): string {\n\t\tif (typeof key === 'string') return key;\n\n\t\treturn `mutex-${Object.entries(key)\n\t\t\t.sort(([a], [b]) => a.localeCompare(b))\n\t\t\t.map(([k, v]) => `${k}-${v}`)\n\t\t\t.join('-')}`;\n\t}\n\n\tpublic getMutex(key: string | Record<string, string>): Mutex {\n\t\tconst normalizedKey = this.normalizeKey(key);\n\n\t\tif (!this.mutexMap.has(normalizedKey)) {\n\t\t\tthis.mutexMap.set(normalizedKey, new Mutex());\n\t\t}\n\n\t\tthis.resetCleanupTimer(normalizedKey);\n\n\t\treturn this.mutexMap.get(normalizedKey) as Mutex;\n\t}\n\n\tpublic async runExclusive<T>(\n\t\tkey: string | Record<string, string>,\n\t\tfn: () => Promise<T>\n\t): Promise<T> {\n\t\tconst mutex = this.getMutex(key);\n\t\treturn mutex.runExclusive(fn);\n\t}\n\n\tpublic async waitIfLocked(\n\t\tkey: string | Record<string, string>\n\t): Promise<void> {\n\t\tconst mutex = this.getMutex(key);\n\t\tif (mutex.isLocked()) {\n\t\t\tawait mutex.waitForUnlock();\n\t\t}\n\t}\n}\n\nexport { MutexManager };\n"],"names":["MutexManager","__name","ttl","key","timer","existingTimer","a","b","k","v","normalizedKey","Mutex","fn","mutex"],"mappings":"yHAEA,MAAMA,CAAa,OAAA,CAAAC,EAAA,qBACD,aAAe,IACf,kBAAoB,IACpB,IAEjB,YAAYC,EAAa,CACxB,KAAK,IAAMA,CACZ,CAEQ,QAAQC,EAAa,CAC5B,KAAK,SAAS,OAAOA,CAAG,EACxB,MAAMC,EAAQ,KAAK,cAAc,IAAID,CAAG,EACpCC,IACH,aAAaA,CAAK,EAClB,KAAK,cAAc,OAAOD,CAAG,EAE/B,CAEQ,kBAAkBA,EAAa,CACtC,MAAME,EAAgB,KAAK,cAAc,IAAIF,CAAG,EAC5CE,GACH,aAAaA,CAAa,EAG3B,MAAMD,EAAQ,WAAW,IAAM,CAC9B,KAAK,QAAQD,CAAG,CACjB,EAAG,KAAK,GAAG,EAEX,KAAK,cAAc,IAAIA,EAAKC,CAAK,CAClC,CAEQ,aAAaD,EAA8C,CAClE,OAAI,OAAOA,GAAQ,SAAiBA,EAE7B,SAAS,OAAO,QAAQA,CAAG,EAChC,KAAK,CAAC,CAACG,CAAC,EAAG,CAACC,CAAC,IAAMD,EAAE,cAAcC,CAAC,CAAC,EACrC,IAAI,CAAC,CAACC,EAAGC,CAAC,IAAM,GAAGD,CAAC,IAAIC,CAAC,EAAE,EAC3B,KAAK,GAAG,CAAC,EACZ,CAEO,SAASN,EAA6C,CAC5D,MAAMO,EAAgB,KAAK,aAAaP,CAAG,EAE3C,OAAK,KAAK,SAAS,IAAIO,CAAa,GACnC,KAAK,SAAS,IAAIA,EAAe,IAAIC,EAAAA,KAAO,EAG7C,KAAK,kBAAkBD,CAAa,EAE7B,KAAK,SAAS,IAAIA,CAAa,CACvC,CAEA,MAAa,aACZP,EACAS,EACa,CAEb,OADc,KAAK,SAAST,CAAG,EAClB,aAAaS,CAAE,CAC7B,CAEA,MAAa,aACZT,EACgB,CAChB,MAAMU,EAAQ,KAAK,SAASV,CAAG,EAC3BU,EAAM,YACT,MAAMA,EAAM,cAAA,CAEd,CACD"}

package/dist/index.d.cts

@@ -0,0 +1,16 @@
+import { Mutex } from 'async-mutex';
+
+declare class MutexManager {
+    private readonly mutexMap;
+    private readonly cleanupTimers;
+    private readonly ttl;
+    constructor(ttl: number);
+    private cleanup;
+    private resetCleanupTimer;
+    private normalizeKey;
+    getMutex(key: string | Record<string, string>): Mutex;
+    runExclusive<T>(key: string | Record<string, string>, fn: () => Promise<T>): Promise<T>;
+    waitIfLocked(key: string | Record<string, string>): Promise<void>;
+}
+
+export { MutexManager };

package/dist/index.d.mts

@@ -0,0 +1,16 @@
+import { Mutex } from 'async-mutex';
+
+declare class MutexManager {
+    private readonly mutexMap;
+    private readonly cleanupTimers;
+    private readonly ttl;
+    constructor(ttl: number);
+    private cleanup;
+    private resetCleanupTimer;
+    private normalizeKey;
+    getMutex(key: string | Record<string, string>): Mutex;
+    runExclusive<T>(key: string | Record<string, string>, fn: () => Promise<T>): Promise<T>;
+    waitIfLocked(key: string | Record<string, string>): Promise<void>;
+}
+
+export { MutexManager };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+var n=Object.defineProperty;var r=(s,e)=>n(s,"name",{value:e,configurable:!0});import{Mutex as u}from"async-mutex";class a{static{r(this,"MutexManager")}mutexMap=new Map;cleanupTimers=new Map;ttl;constructor(e){this.ttl=e}cleanup(e){this.mutexMap.delete(e);const t=this.cleanupTimers.get(e);t&&(clearTimeout(t),this.cleanupTimers.delete(e))}resetCleanupTimer(e){const t=this.cleanupTimers.get(e);t&&clearTimeout(t);const i=setTimeout(()=>{this.cleanup(e)},this.ttl);this.cleanupTimers.set(e,i)}normalizeKey(e){return typeof e=="string"?e:`mutex-${Object.entries(e).sort(([t],[i])=>t.localeCompare(i)).map(([t,i])=>`${t}-${i}`).join("-")}`}getMutex(e){const t=this.normalizeKey(e);return this.mutexMap.has(t)||this.mutexMap.set(t,new u),this.resetCleanupTimer(t),this.mutexMap.get(t)}async runExclusive(e,t){return this.getMutex(e).runExclusive(t)}async waitIfLocked(e){const t=this.getMutex(e);t.isLocked()&&await t.waitForUnlock()}}export{a as MutexManager};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../src/index.ts"],"sourcesContent":["import { Mutex } from 'async-mutex';\n\nclass MutexManager {\n\tprivate readonly mutexMap = new Map<string, Mutex>();\n\tprivate readonly cleanupTimers = new Map<string, NodeJS.Timeout>();\n\tprivate readonly ttl: number;\n\n\tconstructor(ttl: number) {\n\t\tthis.ttl = ttl;\n\t}\n\n\tprivate cleanup(key: string) {\n\t\tthis.mutexMap.delete(key);\n\t\tconst timer = this.cleanupTimers.get(key);\n\t\tif (timer) {\n\t\t\tclearTimeout(timer);\n\t\t\tthis.cleanupTimers.delete(key);\n\t\t}\n\t}\n\n\tprivate resetCleanupTimer(key: string) {\n\t\tconst existingTimer = this.cleanupTimers.get(key);\n\t\tif (existingTimer) {\n\t\t\tclearTimeout(existingTimer);\n\t\t}\n\n\t\tconst timer = setTimeout(() => {\n\t\t\tthis.cleanup(key);\n\t\t}, this.ttl);\n\n\t\tthis.cleanupTimers.set(key, timer);\n\t}\n\n\tprivate normalizeKey(key: string | Record<string, string>): string {\n\t\tif (typeof key === 'string') return key;\n\n\t\treturn `mutex-${Object.entries(key)\n\t\t\t.sort(([a], [b]) => a.localeCompare(b))\n\t\t\t.map(([k, v]) => `${k}-${v}`)\n\t\t\t.join('-')}`;\n\t}\n\n\tpublic getMutex(key: string | Record<string, string>): Mutex {\n\t\tconst normalizedKey = this.normalizeKey(key);\n\n\t\tif (!this.mutexMap.has(normalizedKey)) {\n\t\t\tthis.mutexMap.set(normalizedKey, new Mutex());\n\t\t}\n\n\t\tthis.resetCleanupTimer(normalizedKey);\n\n\t\treturn this.mutexMap.get(normalizedKey) as Mutex;\n\t}\n\n\tpublic async runExclusive<T>(\n\t\tkey: string | Record<string, string>,\n\t\tfn: () => Promise<T>\n\t): Promise<T> {\n\t\tconst mutex = this.getMutex(key);\n\t\treturn mutex.runExclusive(fn);\n\t}\n\n\tpublic async waitIfLocked(\n\t\tkey: string | Record<string, string>\n\t): Promise<void> {\n\t\tconst mutex = this.getMutex(key);\n\t\tif (mutex.isLocked()) {\n\t\t\tawait mutex.waitForUnlock();\n\t\t}\n\t}\n}\n\nexport { MutexManager };\n"],"names":["MutexManager","__name","ttl","key","timer","existingTimer","a","b","k","v","normalizedKey","Mutex","fn","mutex"],"mappings":"mHAEA,MAAMA,CAAa,OAAA,CAAAC,EAAA,qBACD,aAAe,IACf,kBAAoB,IACpB,IAEjB,YAAYC,EAAa,CACxB,KAAK,IAAMA,CACZ,CAEQ,QAAQC,EAAa,CAC5B,KAAK,SAAS,OAAOA,CAAG,EACxB,MAAMC,EAAQ,KAAK,cAAc,IAAID,CAAG,EACpCC,IACH,aAAaA,CAAK,EAClB,KAAK,cAAc,OAAOD,CAAG,EAE/B,CAEQ,kBAAkBA,EAAa,CACtC,MAAME,EAAgB,KAAK,cAAc,IAAIF,CAAG,EAC5CE,GACH,aAAaA,CAAa,EAG3B,MAAMD,EAAQ,WAAW,IAAM,CAC9B,KAAK,QAAQD,CAAG,CACjB,EAAG,KAAK,GAAG,EAEX,KAAK,cAAc,IAAIA,EAAKC,CAAK,CAClC,CAEQ,aAAaD,EAA8C,CAClE,OAAI,OAAOA,GAAQ,SAAiBA,EAE7B,SAAS,OAAO,QAAQA,CAAG,EAChC,KAAK,CAAC,CAACG,CAAC,EAAG,CAACC,CAAC,IAAMD,EAAE,cAAcC,CAAC,CAAC,EACrC,IAAI,CAAC,CAACC,EAAGC,CAAC,IAAM,GAAGD,CAAC,IAAIC,CAAC,EAAE,EAC3B,KAAK,GAAG,CAAC,EACZ,CAEO,SAASN,EAA6C,CAC5D,MAAMO,EAAgB,KAAK,aAAaP,CAAG,EAE3C,OAAK,KAAK,SAAS,IAAIO,CAAa,GACnC,KAAK,SAAS,IAAIA,EAAe,IAAIC,CAAO,EAG7C,KAAK,kBAAkBD,CAAa,EAE7B,KAAK,SAAS,IAAIA,CAAa,CACvC,CAEA,MAAa,aACZP,EACAS,EACa,CAEb,OADc,KAAK,SAAST,CAAG,EAClB,aAAaS,CAAE,CAC7B,CAEA,MAAa,aACZT,EACgB,CAChB,MAAMU,EAAQ,KAAK,SAASV,CAAG,EAC3BU,EAAM,YACT,MAAMA,EAAM,cAAA,CAEd,CACD"}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@md-oss/mutex",
+  "version": "0.1.0",
+  "private": false,
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/Mirasaki-OSS/monorepo-template.git",
+    "directory": "vendor/mutex"
+  },
+  "type": "module",
+  "description": "Mutex manager with automatic cleanup and TTL support",
+  "license": "ISC",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    "require": {
+      "types": "./dist/index.d.cts",
+      "default": "./dist/index.cjs"
+    },
+    "import": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "dependencies": {
+    "async-mutex": "^0.5.0",
+    "@md-oss/config": "^0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.9",
+    "pkgroll": "^2.21.5",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "build": "pkgroll --minify --clean-dist --sourcemap  --define.process.env.NODE_ENV='\"production\"' --define.DEBUG=false",
+    "clean": "git clean -xdf .turbo dist node_modules tsconfig.tsbuildinfo",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit"
+  }
+}