alepha 0.20.3 → 0.20.4

package/dist/lock/core/index.d.ts

@@ -2,9 +2,9 @@ import * as _$alepha from "alepha";
 import { AsyncFn, Middleware, Primitive, Static } from "alepha";
 import * as _$alepha_topic0 from "alepha/topic";
 import { TopicProvider } from "alepha/topic";
+import * as _$alepha_datetime0 from "alepha/datetime";
 import { DateTime, DateTimeProvider, DurationLike, Timeout } from "alepha/datetime";
 import * as _$alepha_logger0 from "alepha/logger";
-import * as _$dayjs_plugin_duration_js0 from "dayjs/plugin/duration.js";
 
 //#region ../../src/lock/core/providers/LockProvider.d.ts
 /**
@@ -293,7 +293,7 @@ declare class LockPrimitive<TFunc extends AsyncFn> extends Primitive<LockPrimiti
    */
   protected _id?: string;
   protected get id(): string;
-  readonly maxDuration: _$dayjs_plugin_duration_js0.Duration;
+  readonly maxDuration: _$alepha_datetime0.Duration;
   protected readonly topicLockEnd: _$alepha_topic0.TopicPrimitive<{
     payload: _$alepha.TObject<{
       name: _$alepha.TString;
@@ -340,6 +340,34 @@ declare class MemoryLockProvider implements LockProvider {
 }
 //#endregion
 //#region ../../src/lock/core/index.d.ts
+declare module "alepha" {
+  interface Hooks {
+    /**
+     * Fires when a lock is successfully acquired.
+     */
+    "lock:acquired": {
+      name: string;
+      id: string;
+      maxDurationMs: number;
+    };
+    /**
+     * Fires when a lock is released (handler completed or threw).
+     */
+    "lock:released": {
+      name: string;
+      id: string;
+      heldMs: number;
+    };
+    /**
+     * Fires when a lock acquisition contends with another holder.
+     * Emitted whether the caller eventually acquires (`wait: true`) or fails.
+     */
+    "lock:contended": {
+      name: string;
+      id: string;
+    };
+  }
+}
 /**
  * Resource locking for distributed systems.
  *

package/dist/lock/core/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/lock/core/providers/LockProvider.ts","../../../src/lock/core/primitives/$lock.ts","../../../src/lock/core/providers/LockTopicProvider.ts","../../../src/lock/core/providers/MemoryLockProvider.ts","../../../src/lock/core/index.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/lock/core/providers/LockProvider.ts","../../../src/lock/core/primitives/$lock.ts","../../../src/lock/core/providers/LockTopicProvider.ts","../../../src/lock/core/providers/MemoryLockProvider.ts","../../../src/lock/core/index.ts"],"mappings":"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"}

package/dist/lock/core/index.js

@@ -81,28 +81,51 @@ const $lock = (options) => {
 	return createMiddleware({
 		name: "$lock",
 		options,
-		handler: ({ next }) => {
+		handler: ({ alepha, next }) => {
 			const id = crypto.randomUUID();
 			const maxDurationMs = dateTimeProvider.duration(options.maxDuration ?? [5, "minutes"]).asMilliseconds();
 			return async (...args) => {
 				const name = typeof options.name === "function" ? options.name(...args) : options.name;
 				if (!name) throw new AlephaError("$lock middleware requires a name option (no class context available)");
 				const [lockId, _createdAtStr, endedAtStr] = (await lockProvider.set(name, `${id},${dateTimeProvider.nowISOString()}`, true, maxDurationMs)).split(",");
-				if (endedAtStr) throw new LockAcquireError(name);
-				if (lockId !== id) if (options.wait) {
-					const start = dateTimeProvider.nowMillis();
-					while (dateTimeProvider.nowMillis() - start < maxDurationMs) {
-						await dateTimeProvider.wait(500);
-						const [currentId] = (await lockProvider.set(name, `${id},${dateTimeProvider.nowISOString()}`, true, maxDurationMs)).split(",");
-						if (currentId === id) break;
-					}
-					const [finalId] = (await lockProvider.set(name, `${id},${dateTimeProvider.nowISOString()}`, true, maxDurationMs)).split(",");
-					if (finalId !== id) throw new LockAcquireError(name);
-				} else throw new LockAcquireError(name);
+				if (endedAtStr) {
+					await alepha.events.emit("lock:contended", {
+						name,
+						id
+					});
+					throw new LockAcquireError(name);
+				}
+				if (lockId !== id) {
+					await alepha.events.emit("lock:contended", {
+						name,
+						id
+					});
+					if (options.wait) {
+						const start = dateTimeProvider.nowMillis();
+						while (dateTimeProvider.nowMillis() - start < maxDurationMs) {
+							await dateTimeProvider.wait(500);
+							const [currentId] = (await lockProvider.set(name, `${id},${dateTimeProvider.nowISOString()}`, true, maxDurationMs)).split(",");
+							if (currentId === id) break;
+						}
+						const [finalId] = (await lockProvider.set(name, `${id},${dateTimeProvider.nowISOString()}`, true, maxDurationMs)).split(",");
+						if (finalId !== id) throw new LockAcquireError(name);
+					} else throw new LockAcquireError(name);
+				}
+				const acquiredAt = dateTimeProvider.nowMillis();
+				await alepha.events.emit("lock:acquired", {
+					name,
+					id,
+					maxDurationMs
+				});
 				try {
 					return await next(...args);
 				} finally {
 					await lockProvider.del(name);
+					await alepha.events.emit("lock:released", {
+						name,
+						id,
+						heldMs: dateTimeProvider.nowMillis() - acquiredAt
+					});
 				}
 			};
 		}

package/dist/lock/core/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../../src/lock/core/providers/LockProvider.ts","../../../src/lock/core/providers/LockTopicProvider.ts","../../../src/lock/core/providers/MemoryLockProvider.ts","../../../src/lock/core/errors/LockAcquireError.ts","../../../src/lock/core/primitives/$lock.ts","../../../src/lock/core/index.ts"],"sourcesContent":["/**\n * Store Provider Interface\n */\nexport abstract class LockProvider {\n  /**\n   * Set the string value of a key.\n   *\n   * @param key The key of the value to set.\n   * @param value The value to set.\n   * @param nx If set to true, the key will only be set if it does not already exist.\n   * @param px Set the specified expire time, in milliseconds.\n   */\n  public abstract set(\n    key: string,\n    value: string,\n    nx?: boolean,\n    px?: number,\n  ): Promise<string>;\n\n  /**\n   * Remove the specified keys.\n   *\n   * @param keys The keys to delete.\n   */\n  public abstract del(...keys: string[]): Promise<void>;\n}\n","import { TopicProvider } from \"alepha/topic\";\n\nexport abstract class LockTopicProvider extends TopicProvider {}\n","import { $inject } from \"alepha\";\nimport { DateTimeProvider, type Timeout } from \"alepha/datetime\";\nimport { $logger } from \"alepha/logger\";\nimport type { LockProvider } from \"./LockProvider.ts\";\n\n/**\n * A simple in-memory store provider.\n */\nexport class MemoryLockProvider implements LockProvider {\n  protected readonly dateTimeProvider = $inject(DateTimeProvider);\n  protected readonly log = $logger();\n\n  /**\n   * The in-memory store.\n   */\n  protected store: Record<string, string> = {};\n\n  /**\n   * Timeouts used to expire keys.\n   */\n  protected storeTimeout: Record<string, Timeout> = {};\n\n  public async set(\n    key: string,\n    value: string,\n    nx?: boolean,\n    px?: number,\n  ): Promise<string> {\n    if (nx && this.store[key] != null) {\n      return this.store[key];\n    }\n\n    if (px) {\n      this.ttl(key, px);\n    }\n\n    this.store[key] = value;\n\n    return this.store[key];\n  }\n\n  public async del(...keys: string[]): Promise<void> {\n    for (const key of keys) {\n      delete this.store[key];\n      if (this.storeTimeout[key] != null) {\n        this.storeTimeout[key].clear();\n        delete this.storeTimeout[key];\n      }\n    }\n  }\n\n  protected ttl(key: string, ms: number): void {\n    if (this.storeTimeout[key] != null) {\n      this.storeTimeout[key].clear();\n      delete this.storeTimeout[key];\n    }\n\n    this.storeTimeout[key] = this.dateTimeProvider.createTimeout(() => {\n      delete this.store[key];\n      delete this.storeTimeout[key];\n    }, ms);\n  }\n}\n","import { AlephaError } from \"alepha\";\n\nexport class LockAcquireError extends AlephaError {\n  constructor(name: string) {\n    super(`$lock: could not acquire lock '${name}'`);\n  }\n}\n","import {\n  $atom,\n  $context,\n  $inject,\n  $state,\n  AlephaError,\n  type AsyncFn,\n  createMiddleware,\n  type Middleware,\n  Primitive,\n  type Static,\n  t,\n} from \"alepha\";\nimport {\n  type DateTime,\n  DateTimeProvider,\n  type DurationLike,\n} from \"alepha/datetime\";\nimport { $logger } from \"alepha/logger\";\nimport { $topic } from \"alepha/topic\";\nimport { LockAcquireError } from \"../errors/LockAcquireError.ts\";\nimport { LockProvider } from \"../providers/LockProvider.ts\";\nimport { LockTopicProvider } from \"../providers/LockTopicProvider.ts\";\n\n/**\n * Distributed lock middleware for `use` arrays in `$action`, `$job`, `$page`, `$pipeline`.\n *\n * Acquires a distributed lock before the handler runs and releases it after completion.\n * Throws `LockAcquireError` if the lock cannot be acquired (unless `wait: true`).\n *\n * ```ts\n * processOrder = $action({\n *   use: [$lock({ name: \"process-order\" })],\n *   handler: async ({ body }) => { ... },\n * });\n * ```\n */\nexport const $lock = (options: LockMiddlewareOptions): Middleware => {\n  const { alepha } = $context();\n  const lockProvider = alepha.inject(LockProvider);\n  const dateTimeProvider = alepha.inject(DateTimeProvider);\n\n  return createMiddleware({\n    name: \"$lock\",\n    options: options as unknown as Record<string, unknown>,\n    handler: ({ next }) => {\n      const id = crypto.randomUUID();\n      const maxDurationMs = dateTimeProvider\n        .duration(options.maxDuration ?? [5, \"minutes\"])\n        .asMilliseconds();\n\n      return async (...args: any[]) => {\n        const name =\n          typeof options.name === \"function\"\n            ? options.name(...args)\n            : options.name;\n        if (!name) {\n          throw new AlephaError(\n            \"$lock middleware requires a name option (no class context available)\",\n          );\n        }\n\n        const value = await lockProvider.set(\n          name,\n          `${id},${dateTimeProvider.nowISOString()}`,\n          true,\n          maxDurationMs,\n        );\n\n        const [lockId, _createdAtStr, endedAtStr] = value.split(\",\");\n\n        // Lock already ended (grace period active)\n        if (endedAtStr) {\n          throw new LockAcquireError(name);\n        }\n\n        // Lock held by someone else\n        if (lockId !== id) {\n          if (options.wait) {\n            // Poll until lock is released\n            const start = dateTimeProvider.nowMillis();\n            while (dateTimeProvider.nowMillis() - start < maxDurationMs) {\n              await dateTimeProvider.wait(500);\n              const current = await lockProvider.set(\n                name,\n                `${id},${dateTimeProvider.nowISOString()}`,\n                true,\n                maxDurationMs,\n              );\n              const [currentId] = current.split(\",\");\n              if (currentId === id) {\n                break;\n              }\n            }\n            // Check if we got the lock\n            const final = await lockProvider.set(\n              name,\n              `${id},${dateTimeProvider.nowISOString()}`,\n              true,\n              maxDurationMs,\n            );\n            const [finalId] = final.split(\",\");\n            if (finalId !== id) {\n              throw new LockAcquireError(name);\n            }\n          } else {\n            throw new LockAcquireError(name);\n          }\n        }\n\n        // We hold the lock — execute handler\n        try {\n          return await next(...args);\n        } finally {\n          await lockProvider.del(name);\n        }\n      };\n    },\n  });\n};\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Options for $lock in middleware mode (no handler).\n */\nexport interface LockMiddlewareOptions {\n  /**\n   * Lock key name. Required in middleware mode (no class context available).\n   * Can be a static string or a function that derives the key from handler args.\n   */\n  name: string | ((...args: any[]) => string);\n\n  /**\n   * Whether to wait for the lock to become available.\n   *\n   * @default false\n   */\n  wait?: boolean;\n\n  /**\n   * Maximum duration the lock can be held before automatic expiration.\n   *\n   * @default [5, \"minutes\"]\n   */\n  maxDuration?: DurationLike;\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport interface LockPrimitiveOptions<TFunc extends AsyncFn> {\n  /**\n   * The function to execute when the lock is successfully acquired.\n   *\n   * This function:\n   * - Only executes on the instance that successfully acquires the lock\n   * - Has exclusive access to the protected resource during execution\n   * - Should contain the critical section logic that must not run concurrently\n   * - Can be async and perform any operations needed\n   * - Will automatically release the lock upon completion or error\n   * - Has access to the full Alepha dependency injection container\n   *\n   * **Handler Design Guidelines**:\n   * - Keep critical sections as short as possible to minimize lock contention\n   * - Include proper error handling to ensure locks are released\n   * - Use timeouts for external operations to prevent deadlocks\n   * - Log important operations for debugging and monitoring\n   * - Consider idempotency for handlers that might be retried\n   *\n   * @param ...args - The arguments passed to the lock execution\n   * @returns Promise that resolves when the protected operation is complete\n   *\n   * @example\n   * ```ts\n   * handler: async (batchId: string) => {\n   *   console.log(`Processing batch ${batchId} - only one instance will run this`);\n   *\n   *   const batch = await this.getBatchData(batchId);\n   *   const results = await this.processBatchItems(batch.items);\n   *   await this.saveBatchResults(batchId, results);\n   *\n   *   console.log(`Batch ${batchId} completed successfully`);\n   * }\n   * ```\n   */\n  handler: TFunc;\n\n  /**\n   * Whether the lock should wait for other instances to complete before giving up.\n   *\n   * **wait = false (default)**:\n   * - Non-blocking behavior - if lock is held, immediately return without executing\n   * - Perfect for scheduled tasks where you only want one execution per trigger\n   * - Use when multiple triggers are acceptable but concurrent execution is not\n   * - Examples: periodic cleanup, cron jobs, background maintenance\n   *\n   * **wait = true**:\n   * - Blocking behavior - wait for the current lock holder to finish\n   * - All instances will eventually execute (one after another)\n   * - Perfect for initialization tasks where all instances need the work completed\n   * - Examples: database migrations, cache warming, resource initialization\n   *\n   * **Trade-offs**:\n   * - Non-waiting: Better performance, may miss executions if timing is off\n   * - Waiting: Guaranteed execution order, slower overall throughput\n   *\n   * @default false\n   *\n   * @example\n   * ```ts\n   * // Scheduled task - don't wait, just skip if already running\n   * scheduledCleanup = $lock({\n   *   wait: false,  // Skip if cleanup already running\n   *   handler: async () => { } // perform cleanup\n   * });\n   *\n   * // Migration - wait for completion before proceeding\n   * migration = $lock({\n   *   wait: true,   // All instances wait for migration to complete\n   *   handler: async () => { } // perform migration\n   * });\n   * ```\n   */\n  wait?: boolean;\n\n  /**\n   * The unique identifier for the lock.\n   *\n   * Can be either:\n   * - **Static string**: A fixed identifier for the lock\n   * - **Dynamic function**: A function that generates the lock key based on arguments\n   *\n   * **Dynamic Lock Keys**:\n   * - Enable per-resource locking (e.g., per-user, per-file, per-product)\n   * - Allow fine-grained concurrency control\n   * - Prevent unnecessary blocking between unrelated operations\n   *\n   * **Key Design Guidelines**:\n   * - Use descriptive names that indicate the protected resource\n   * - Include relevant identifiers for dynamic keys\n   * - Keep keys reasonably short but unique\n   * - Consider using hierarchical naming (e.g., \"service:operation:resource\")\n   *\n   * If not provided, defaults to `{serviceName}:{propertyKey}`.\n   *\n   * @example \"user-migration\"\n   * @example \"daily-report-generation\"\n   * @example (userId: string) => `user-profile-update:${userId}`\n   * @example (fileId: string, operation: string) => `file-${operation}:${fileId}`\n   *\n   * @example\n   * ```ts\n   * // Static lock key - all instances compete for the same lock\n   * globalCleanup = $lock({\n   *   name: \"system-cleanup\",\n   *   handler: async () => { } // perform cleanup\n   * });\n   *\n   * // Dynamic lock key - per-user locks, users don't block each other\n   * updateUserProfile = $lock({\n   *   name: (userId: string) => `user-update:${userId}`,\n   *   handler: async (userId: string, data: UserData) => {\n   *     // Only one update per user at a time, but different users can update concurrently\n   *   }\n   * });\n   * ```\n   */\n  name?: string | ((...args: Parameters<TFunc>) => string);\n\n  /**\n   * Maximum duration the lock can be held before it expires automatically.\n   *\n   * This prevents deadlocks when a process dies while holding a lock or when\n   * operations take longer than expected. The lock will be automatically released\n   * after this duration, allowing other instances to proceed.\n   *\n   * **Duration Guidelines**:\n   * - Set based on expected operation duration plus safety margin\n   * - Too short: Operations may be interrupted by early expiration\n   * - Too long: Failed processes block others for extended periods\n   * - Consider worst-case scenarios and external dependency timeouts\n   *\n   * **Typical Values**:\n   * - Quick operations: 30 seconds - 2 minutes\n   * - Database operations: 5 - 15 minutes\n   * - File processing: 10 - 30 minutes\n   * - Large migrations: 30 minutes - 2 hours\n   *\n   * @default [5, \"minutes\"]\n   *\n   * @example [30, \"seconds\"]    // Quick operations\n   * @example [10, \"minutes\"]    // Database migrations\n   * @example [1, \"hour\"]        // Long-running batch jobs\n   *\n   * @example\n   * ```ts\n   * quickTask = $lock({\n   *   maxDuration: [2, \"minutes\"],  // Quick timeout for fast operations\n   *   handler: async () => { } // perform quick task\n   * });\n   *\n   * heavyProcessing = $lock({\n   *   maxDuration: [30, \"minutes\"], // Longer timeout for heavy work\n   *   handler: async () => { } // perform heavy processing\n   * });\n   * ```\n   */\n  maxDuration?: DurationLike;\n\n  /**\n   * Additional time to keep the lock active after the handler completes successfully.\n   *\n   * This provides a \"cooling off\" period that can be useful for:\n   * - Preventing immediate re-execution of the same operation\n   * - Giving time for related systems to process the results\n   * - Avoiding race conditions with dependent operations\n   * - Providing a buffer for cleanup operations\n   *\n   * Can be either:\n   * - **Static duration**: Fixed grace period for all executions\n   * - **Dynamic function**: Grace period determined by execution arguments\n   * - **undefined**: No grace period, lock released immediately after completion\n   *\n   * **Grace Period Use Cases**:\n   * - File processing: Prevent immediate reprocessing of uploaded files\n   * - Cache updates: Allow time for cache propagation\n   * - Batch operations: Prevent overlapping batch processing\n   * - External API calls: Respect rate limiting requirements\n   *\n   * @default undefined (no grace period)\n   *\n   * @example [5, \"minutes\"]     // Fixed 5-minute grace period\n   * @example [30, \"seconds\"]    // Short grace for quick operations\n   * @example (userId: string) => userId.startsWith(\"premium\") ? [10, \"minutes\"] : [2, \"minutes\"]\n   *\n   * @example\n   * ```ts\n   * fileProcessor = $lock({\n   *   gracePeriod: [10, \"minutes\"],  // Prevent reprocessing same file immediately\n   *   handler: async (filePath: string) => {\n   *     await this.processFile(filePath);\n   *   }\n   * });\n   *\n   * userOperation = $lock({\n   *   gracePeriod: (userId: string, operation: string) => {\n   *     // Dynamic grace based on operation type\n   *     return operation === 'migration' ? [30, \"minutes\"] : [5, \"minutes\"];\n   *   },\n   *   handler: async (userId: string, operation: string) => {\n   *     await this.performUserOperation(userId, operation);\n   *   }\n   * });\n   * ```\n   */\n  gracePeriod?:\n    | ((...args: Parameters<TFunc>) => DurationLike | undefined)\n    | DurationLike;\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Lock configuration atom.\n */\nexport const lockOptions = $atom({\n  name: \"alepha.lock.options\",\n  schema: t.object({\n    prefixKey: t.text({\n      default: \"\",\n      description: \"Prefix for all lock keys.\",\n    }),\n  }),\n  default: {\n    prefixKey: \"\",\n  },\n});\n\nexport type LockAtomOptions = Static<typeof lockOptions.schema>;\n\ndeclare module \"alepha\" {\n  interface State {\n    [lockOptions.key]: LockAtomOptions;\n  }\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport class LockPrimitive<TFunc extends AsyncFn> extends Primitive<\n  LockPrimitiveOptions<TFunc>\n> {\n  protected readonly log = $logger();\n  protected readonly provider = $inject(LockProvider);\n  protected readonly settings = $state(lockOptions);\n  protected readonly dateTimeProvider = $inject(DateTimeProvider);\n\n  /**\n   * Lazy-initialized UUID to avoid calling crypto.randomUUID() in global scope.\n   * Cloudflare Workers doesn't allow random value generation during initialization.\n   */\n  protected _id?: string;\n  protected get id(): string {\n    if (!this._id) {\n      this._id = crypto.randomUUID();\n    }\n    return this._id;\n  }\n\n  public readonly maxDuration = this.dateTimeProvider.duration(\n    this.options.maxDuration ?? [5, \"minutes\"],\n  );\n\n  protected readonly topicLockEnd = $topic({\n    name: `${this.settings.prefixKey}lock:end`,\n    provider: LockTopicProvider,\n    schema: {\n      payload: t.object({\n        name: t.text(),\n      }),\n    },\n  });\n\n  public async run(...args: Parameters<TFunc>): Promise<void> {\n    const key = this.key(...args);\n    const handler = this.options.handler;\n\n    const lock = await this.lock(key);\n    if (lock.endedAt) {\n      return;\n    }\n\n    if (lock.id !== this.id) {\n      if (this.options.wait) {\n        // Poll until the lock is released, then re-attempt\n        const start = this.dateTimeProvider.nowMillis();\n        const maxMs = this.maxDuration.as(\"milliseconds\");\n        let acquired = false;\n        while (this.dateTimeProvider.nowMillis() - start < maxMs) {\n          await this.dateTimeProvider.wait(500);\n          const current = await this.lock(key);\n          if (current.id === this.id || !current.id || current.endedAt) {\n            acquired = true;\n            break;\n          }\n        }\n        if (acquired) {\n          return this.run(...args);\n        }\n        this.log.warn(`Lock wait timeout for '${key}', giving up`);\n      }\n\n      return;\n    }\n\n    this.log.debug(`Lock '${key}' ...`);\n\n    try {\n      await handler(...args);\n    } finally {\n      await this.topicLockEnd.publish({\n        name: key,\n      });\n\n      await this.setGracePeriod(key, lock, ...args);\n\n      this.log.debug(`Lock '${key}' OK`);\n    }\n  }\n\n  /**\n   * Set the lock for the given key.\n   */\n  protected async lock(key: string): Promise<LockResult> {\n    const value = await this.provider.set(\n      key,\n      `${this.id},${this.dateTimeProvider.nowISOString()}`,\n      true,\n      this.maxDuration.as(\"milliseconds\"),\n    );\n\n    return this.parse(value);\n  }\n\n  protected async setGracePeriod(\n    key: string,\n    lock: LockResult,\n    ...args: Parameters<TFunc>\n  ): Promise<void> {\n    const gracePeriod = this.options.gracePeriod\n      ? this.dateTimeProvider.isDurationLike(this.options.gracePeriod)\n        ? this.options.gracePeriod\n        : this.options.gracePeriod(...args)\n      : undefined;\n\n    if (gracePeriod) {\n      await this.provider.set(\n        key,\n        `${this.id},${lock.createdAt.toISOString()},${this.dateTimeProvider.nowISOString()}`,\n        false,\n        this.dateTimeProvider.duration(gracePeriod).as(\"milliseconds\"),\n      );\n    } else {\n      await this.provider.del(key);\n    }\n  }\n\n  protected async wait(key: string, maxDuration: DurationLike): Promise<void> {\n    this.log.debug(`Wait for lock '${key}' ...`);\n\n    await this.topicLockEnd.wait({\n      filter: (message) => message.payload.name === key,\n      timeout: maxDuration,\n    });\n\n    this.log.debug(`Wait for lock '${key}' OK`);\n  }\n\n  protected key(...args: Parameters<TFunc>) {\n    let base = \"\";\n\n    if (this.options.name) {\n      if (typeof this.options.name === \"string\") {\n        base = this.options.name;\n      } else {\n        base = this.options.name(...args);\n      }\n    } else {\n      base = `${this.config.service.name}:${this.config.propertyKey}`;\n    }\n\n    return `${this.settings.prefixKey}${base}`;\n  }\n\n  protected parse(value: string): LockResult {\n    const [id, createdAtStr, endedAtStr] = value.split(\",\");\n    const createdAt = this.dateTimeProvider.of(createdAtStr);\n    const endedAt = endedAtStr\n      ? this.dateTimeProvider.of(endedAtStr)\n      : undefined;\n\n    return {\n      id,\n      createdAt,\n      endedAt,\n    };\n  }\n}\n\nexport interface LockResult {\n  id: string;\n  createdAt: DateTime;\n  endedAt?: DateTime;\n  response?: string;\n}\n","import { $module } from \"alepha\";\nimport { MemoryTopicProvider } from \"alepha/topic\";\nimport { LockProvider } from \"./providers/LockProvider.ts\";\nimport { LockTopicProvider } from \"./providers/LockTopicProvider.ts\";\nimport { MemoryLockProvider } from \"./providers/MemoryLockProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport * from \"./primitives/$lock.ts\";\nexport * from \"./providers/LockProvider.ts\";\nexport * from \"./providers/LockTopicProvider.ts\";\nexport * from \"./providers/MemoryLockProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Resource locking for distributed systems.\n *\n * **Features:**\n * - Distributed locks with timeout\n * - Time-based lock expiration\n * - Automatic release on scope exit\n * - Distributed coordination via Redis\n * - Providers: Memory (dev), Redis (production)\n *\n * @module alepha.lock\n */\nexport const AlephaLock = $module({\n  name: \"alepha.lock\",\n  services: [LockProvider, LockTopicProvider],\n  variants: [MemoryLockProvider],\n  register: (alepha) =>\n    alepha\n      .with({\n        optional: true,\n        provide: LockTopicProvider,\n        use: MemoryTopicProvider,\n      })\n      .with({\n        optional: true,\n        provide: LockProvider,\n        use: MemoryLockProvider,\n      }),\n});\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/lock/core/providers/LockProvider.ts","../../../src/lock/core/providers/LockTopicProvider.ts","../../../src/lock/core/providers/MemoryLockProvider.ts","../../../src/lock/core/errors/LockAcquireError.ts","../../../src/lock/core/primitives/$lock.ts","../../../src/lock/core/index.ts"],"sourcesContent":["/**\n * Store Provider Interface\n */\nexport abstract class LockProvider {\n  /**\n   * Set the string value of a key.\n   *\n   * @param key The key of the value to set.\n   * @param value The value to set.\n   * @param nx If set to true, the key will only be set if it does not already exist.\n   * @param px Set the specified expire time, in milliseconds.\n   */\n  public abstract set(\n    key: string,\n    value: string,\n    nx?: boolean,\n    px?: number,\n  ): Promise<string>;\n\n  /**\n   * Remove the specified keys.\n   *\n   * @param keys The keys to delete.\n   */\n  public abstract del(...keys: string[]): Promise<void>;\n}\n","import { TopicProvider } from \"alepha/topic\";\n\nexport abstract class LockTopicProvider extends TopicProvider {}\n","import { $inject } from \"alepha\";\nimport { DateTimeProvider, type Timeout } from \"alepha/datetime\";\nimport { $logger } from \"alepha/logger\";\nimport type { LockProvider } from \"./LockProvider.ts\";\n\n/**\n * A simple in-memory store provider.\n */\nexport class MemoryLockProvider implements LockProvider {\n  protected readonly dateTimeProvider = $inject(DateTimeProvider);\n  protected readonly log = $logger();\n\n  /**\n   * The in-memory store.\n   */\n  protected store: Record<string, string> = {};\n\n  /**\n   * Timeouts used to expire keys.\n   */\n  protected storeTimeout: Record<string, Timeout> = {};\n\n  public async set(\n    key: string,\n    value: string,\n    nx?: boolean,\n    px?: number,\n  ): Promise<string> {\n    if (nx && this.store[key] != null) {\n      return this.store[key];\n    }\n\n    if (px) {\n      this.ttl(key, px);\n    }\n\n    this.store[key] = value;\n\n    return this.store[key];\n  }\n\n  public async del(...keys: string[]): Promise<void> {\n    for (const key of keys) {\n      delete this.store[key];\n      if (this.storeTimeout[key] != null) {\n        this.storeTimeout[key].clear();\n        delete this.storeTimeout[key];\n      }\n    }\n  }\n\n  protected ttl(key: string, ms: number): void {\n    if (this.storeTimeout[key] != null) {\n      this.storeTimeout[key].clear();\n      delete this.storeTimeout[key];\n    }\n\n    this.storeTimeout[key] = this.dateTimeProvider.createTimeout(() => {\n      delete this.store[key];\n      delete this.storeTimeout[key];\n    }, ms);\n  }\n}\n","import { AlephaError } from \"alepha\";\n\nexport class LockAcquireError extends AlephaError {\n  constructor(name: string) {\n    super(`$lock: could not acquire lock '${name}'`);\n  }\n}\n","import {\n  $atom,\n  $context,\n  $inject,\n  $state,\n  AlephaError,\n  type AsyncFn,\n  createMiddleware,\n  type Middleware,\n  Primitive,\n  type Static,\n  t,\n} from \"alepha\";\nimport {\n  type DateTime,\n  DateTimeProvider,\n  type DurationLike,\n} from \"alepha/datetime\";\nimport { $logger } from \"alepha/logger\";\nimport { $topic } from \"alepha/topic\";\nimport { LockAcquireError } from \"../errors/LockAcquireError.ts\";\nimport { LockProvider } from \"../providers/LockProvider.ts\";\nimport { LockTopicProvider } from \"../providers/LockTopicProvider.ts\";\n\n/**\n * Distributed lock middleware for `use` arrays in `$action`, `$job`, `$page`, `$pipeline`.\n *\n * Acquires a distributed lock before the handler runs and releases it after completion.\n * Throws `LockAcquireError` if the lock cannot be acquired (unless `wait: true`).\n *\n * ```ts\n * processOrder = $action({\n *   use: [$lock({ name: \"process-order\" })],\n *   handler: async ({ body }) => { ... },\n * });\n * ```\n */\nexport const $lock = (options: LockMiddlewareOptions): Middleware => {\n  const { alepha } = $context();\n  const lockProvider = alepha.inject(LockProvider);\n  const dateTimeProvider = alepha.inject(DateTimeProvider);\n\n  return createMiddleware({\n    name: \"$lock\",\n    options: options as unknown as Record<string, unknown>,\n    handler: ({ alepha, next }) => {\n      const id = crypto.randomUUID();\n      const maxDurationMs = dateTimeProvider\n        .duration(options.maxDuration ?? [5, \"minutes\"])\n        .asMilliseconds();\n\n      return async (...args: any[]) => {\n        const name =\n          typeof options.name === \"function\"\n            ? options.name(...args)\n            : options.name;\n        if (!name) {\n          throw new AlephaError(\n            \"$lock middleware requires a name option (no class context available)\",\n          );\n        }\n\n        const value = await lockProvider.set(\n          name,\n          `${id},${dateTimeProvider.nowISOString()}`,\n          true,\n          maxDurationMs,\n        );\n\n        const [lockId, _createdAtStr, endedAtStr] = value.split(\",\");\n\n        // Lock already ended (grace period active)\n        if (endedAtStr) {\n          await alepha.events.emit(\"lock:contended\", { name, id });\n          throw new LockAcquireError(name);\n        }\n\n        // Lock held by someone else\n        if (lockId !== id) {\n          await alepha.events.emit(\"lock:contended\", { name, id });\n          if (options.wait) {\n            // Poll until lock is released\n            const start = dateTimeProvider.nowMillis();\n            while (dateTimeProvider.nowMillis() - start < maxDurationMs) {\n              await dateTimeProvider.wait(500);\n              const current = await lockProvider.set(\n                name,\n                `${id},${dateTimeProvider.nowISOString()}`,\n                true,\n                maxDurationMs,\n              );\n              const [currentId] = current.split(\",\");\n              if (currentId === id) {\n                break;\n              }\n            }\n            // Check if we got the lock\n            const final = await lockProvider.set(\n              name,\n              `${id},${dateTimeProvider.nowISOString()}`,\n              true,\n              maxDurationMs,\n            );\n            const [finalId] = final.split(\",\");\n            if (finalId !== id) {\n              throw new LockAcquireError(name);\n            }\n          } else {\n            throw new LockAcquireError(name);\n          }\n        }\n\n        // We hold the lock — execute handler\n        const acquiredAt = dateTimeProvider.nowMillis();\n        await alepha.events.emit(\"lock:acquired\", {\n          name,\n          id,\n          maxDurationMs,\n        });\n        try {\n          return await next(...args);\n        } finally {\n          await lockProvider.del(name);\n          await alepha.events.emit(\"lock:released\", {\n            name,\n            id,\n            heldMs: dateTimeProvider.nowMillis() - acquiredAt,\n          });\n        }\n      };\n    },\n  });\n};\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Options for $lock in middleware mode (no handler).\n */\nexport interface LockMiddlewareOptions {\n  /**\n   * Lock key name. Required in middleware mode (no class context available).\n   * Can be a static string or a function that derives the key from handler args.\n   */\n  name: string | ((...args: any[]) => string);\n\n  /**\n   * Whether to wait for the lock to become available.\n   *\n   * @default false\n   */\n  wait?: boolean;\n\n  /**\n   * Maximum duration the lock can be held before automatic expiration.\n   *\n   * @default [5, \"minutes\"]\n   */\n  maxDuration?: DurationLike;\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport interface LockPrimitiveOptions<TFunc extends AsyncFn> {\n  /**\n   * The function to execute when the lock is successfully acquired.\n   *\n   * This function:\n   * - Only executes on the instance that successfully acquires the lock\n   * - Has exclusive access to the protected resource during execution\n   * - Should contain the critical section logic that must not run concurrently\n   * - Can be async and perform any operations needed\n   * - Will automatically release the lock upon completion or error\n   * - Has access to the full Alepha dependency injection container\n   *\n   * **Handler Design Guidelines**:\n   * - Keep critical sections as short as possible to minimize lock contention\n   * - Include proper error handling to ensure locks are released\n   * - Use timeouts for external operations to prevent deadlocks\n   * - Log important operations for debugging and monitoring\n   * - Consider idempotency for handlers that might be retried\n   *\n   * @param ...args - The arguments passed to the lock execution\n   * @returns Promise that resolves when the protected operation is complete\n   *\n   * @example\n   * ```ts\n   * handler: async (batchId: string) => {\n   *   console.log(`Processing batch ${batchId} - only one instance will run this`);\n   *\n   *   const batch = await this.getBatchData(batchId);\n   *   const results = await this.processBatchItems(batch.items);\n   *   await this.saveBatchResults(batchId, results);\n   *\n   *   console.log(`Batch ${batchId} completed successfully`);\n   * }\n   * ```\n   */\n  handler: TFunc;\n\n  /**\n   * Whether the lock should wait for other instances to complete before giving up.\n   *\n   * **wait = false (default)**:\n   * - Non-blocking behavior - if lock is held, immediately return without executing\n   * - Perfect for scheduled tasks where you only want one execution per trigger\n   * - Use when multiple triggers are acceptable but concurrent execution is not\n   * - Examples: periodic cleanup, cron jobs, background maintenance\n   *\n   * **wait = true**:\n   * - Blocking behavior - wait for the current lock holder to finish\n   * - All instances will eventually execute (one after another)\n   * - Perfect for initialization tasks where all instances need the work completed\n   * - Examples: database migrations, cache warming, resource initialization\n   *\n   * **Trade-offs**:\n   * - Non-waiting: Better performance, may miss executions if timing is off\n   * - Waiting: Guaranteed execution order, slower overall throughput\n   *\n   * @default false\n   *\n   * @example\n   * ```ts\n   * // Scheduled task - don't wait, just skip if already running\n   * scheduledCleanup = $lock({\n   *   wait: false,  // Skip if cleanup already running\n   *   handler: async () => { } // perform cleanup\n   * });\n   *\n   * // Migration - wait for completion before proceeding\n   * migration = $lock({\n   *   wait: true,   // All instances wait for migration to complete\n   *   handler: async () => { } // perform migration\n   * });\n   * ```\n   */\n  wait?: boolean;\n\n  /**\n   * The unique identifier for the lock.\n   *\n   * Can be either:\n   * - **Static string**: A fixed identifier for the lock\n   * - **Dynamic function**: A function that generates the lock key based on arguments\n   *\n   * **Dynamic Lock Keys**:\n   * - Enable per-resource locking (e.g., per-user, per-file, per-product)\n   * - Allow fine-grained concurrency control\n   * - Prevent unnecessary blocking between unrelated operations\n   *\n   * **Key Design Guidelines**:\n   * - Use descriptive names that indicate the protected resource\n   * - Include relevant identifiers for dynamic keys\n   * - Keep keys reasonably short but unique\n   * - Consider using hierarchical naming (e.g., \"service:operation:resource\")\n   *\n   * If not provided, defaults to `{serviceName}:{propertyKey}`.\n   *\n   * @example \"user-migration\"\n   * @example \"daily-report-generation\"\n   * @example (userId: string) => `user-profile-update:${userId}`\n   * @example (fileId: string, operation: string) => `file-${operation}:${fileId}`\n   *\n   * @example\n   * ```ts\n   * // Static lock key - all instances compete for the same lock\n   * globalCleanup = $lock({\n   *   name: \"system-cleanup\",\n   *   handler: async () => { } // perform cleanup\n   * });\n   *\n   * // Dynamic lock key - per-user locks, users don't block each other\n   * updateUserProfile = $lock({\n   *   name: (userId: string) => `user-update:${userId}`,\n   *   handler: async (userId: string, data: UserData) => {\n   *     // Only one update per user at a time, but different users can update concurrently\n   *   }\n   * });\n   * ```\n   */\n  name?: string | ((...args: Parameters<TFunc>) => string);\n\n  /**\n   * Maximum duration the lock can be held before it expires automatically.\n   *\n   * This prevents deadlocks when a process dies while holding a lock or when\n   * operations take longer than expected. The lock will be automatically released\n   * after this duration, allowing other instances to proceed.\n   *\n   * **Duration Guidelines**:\n   * - Set based on expected operation duration plus safety margin\n   * - Too short: Operations may be interrupted by early expiration\n   * - Too long: Failed processes block others for extended periods\n   * - Consider worst-case scenarios and external dependency timeouts\n   *\n   * **Typical Values**:\n   * - Quick operations: 30 seconds - 2 minutes\n   * - Database operations: 5 - 15 minutes\n   * - File processing: 10 - 30 minutes\n   * - Large migrations: 30 minutes - 2 hours\n   *\n   * @default [5, \"minutes\"]\n   *\n   * @example [30, \"seconds\"]    // Quick operations\n   * @example [10, \"minutes\"]    // Database migrations\n   * @example [1, \"hour\"]        // Long-running batch jobs\n   *\n   * @example\n   * ```ts\n   * quickTask = $lock({\n   *   maxDuration: [2, \"minutes\"],  // Quick timeout for fast operations\n   *   handler: async () => { } // perform quick task\n   * });\n   *\n   * heavyProcessing = $lock({\n   *   maxDuration: [30, \"minutes\"], // Longer timeout for heavy work\n   *   handler: async () => { } // perform heavy processing\n   * });\n   * ```\n   */\n  maxDuration?: DurationLike;\n\n  /**\n   * Additional time to keep the lock active after the handler completes successfully.\n   *\n   * This provides a \"cooling off\" period that can be useful for:\n   * - Preventing immediate re-execution of the same operation\n   * - Giving time for related systems to process the results\n   * - Avoiding race conditions with dependent operations\n   * - Providing a buffer for cleanup operations\n   *\n   * Can be either:\n   * - **Static duration**: Fixed grace period for all executions\n   * - **Dynamic function**: Grace period determined by execution arguments\n   * - **undefined**: No grace period, lock released immediately after completion\n   *\n   * **Grace Period Use Cases**:\n   * - File processing: Prevent immediate reprocessing of uploaded files\n   * - Cache updates: Allow time for cache propagation\n   * - Batch operations: Prevent overlapping batch processing\n   * - External API calls: Respect rate limiting requirements\n   *\n   * @default undefined (no grace period)\n   *\n   * @example [5, \"minutes\"]     // Fixed 5-minute grace period\n   * @example [30, \"seconds\"]    // Short grace for quick operations\n   * @example (userId: string) => userId.startsWith(\"premium\") ? [10, \"minutes\"] : [2, \"minutes\"]\n   *\n   * @example\n   * ```ts\n   * fileProcessor = $lock({\n   *   gracePeriod: [10, \"minutes\"],  // Prevent reprocessing same file immediately\n   *   handler: async (filePath: string) => {\n   *     await this.processFile(filePath);\n   *   }\n   * });\n   *\n   * userOperation = $lock({\n   *   gracePeriod: (userId: string, operation: string) => {\n   *     // Dynamic grace based on operation type\n   *     return operation === 'migration' ? [30, \"minutes\"] : [5, \"minutes\"];\n   *   },\n   *   handler: async (userId: string, operation: string) => {\n   *     await this.performUserOperation(userId, operation);\n   *   }\n   * });\n   * ```\n   */\n  gracePeriod?:\n    | ((...args: Parameters<TFunc>) => DurationLike | undefined)\n    | DurationLike;\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Lock configuration atom.\n */\nexport const lockOptions = $atom({\n  name: \"alepha.lock.options\",\n  schema: t.object({\n    prefixKey: t.text({\n      default: \"\",\n      description: \"Prefix for all lock keys.\",\n    }),\n  }),\n  default: {\n    prefixKey: \"\",\n  },\n});\n\nexport type LockAtomOptions = Static<typeof lockOptions.schema>;\n\ndeclare module \"alepha\" {\n  interface State {\n    [lockOptions.key]: LockAtomOptions;\n  }\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport class LockPrimitive<TFunc extends AsyncFn> extends Primitive<\n  LockPrimitiveOptions<TFunc>\n> {\n  protected readonly log = $logger();\n  protected readonly provider = $inject(LockProvider);\n  protected readonly settings = $state(lockOptions);\n  protected readonly dateTimeProvider = $inject(DateTimeProvider);\n\n  /**\n   * Lazy-initialized UUID to avoid calling crypto.randomUUID() in global scope.\n   * Cloudflare Workers doesn't allow random value generation during initialization.\n   */\n  protected _id?: string;\n  protected get id(): string {\n    if (!this._id) {\n      this._id = crypto.randomUUID();\n    }\n    return this._id;\n  }\n\n  public readonly maxDuration = this.dateTimeProvider.duration(\n    this.options.maxDuration ?? [5, \"minutes\"],\n  );\n\n  protected readonly topicLockEnd = $topic({\n    name: `${this.settings.prefixKey}lock:end`,\n    provider: LockTopicProvider,\n    schema: {\n      payload: t.object({\n        name: t.text(),\n      }),\n    },\n  });\n\n  public async run(...args: Parameters<TFunc>): Promise<void> {\n    const key = this.key(...args);\n    const handler = this.options.handler;\n\n    const lock = await this.lock(key);\n    if (lock.endedAt) {\n      return;\n    }\n\n    if (lock.id !== this.id) {\n      if (this.options.wait) {\n        // Poll until the lock is released, then re-attempt\n        const start = this.dateTimeProvider.nowMillis();\n        const maxMs = this.maxDuration.as(\"milliseconds\");\n        let acquired = false;\n        while (this.dateTimeProvider.nowMillis() - start < maxMs) {\n          await this.dateTimeProvider.wait(500);\n          const current = await this.lock(key);\n          if (current.id === this.id || !current.id || current.endedAt) {\n            acquired = true;\n            break;\n          }\n        }\n        if (acquired) {\n          return this.run(...args);\n        }\n        this.log.warn(`Lock wait timeout for '${key}', giving up`);\n      }\n\n      return;\n    }\n\n    this.log.debug(`Lock '${key}' ...`);\n\n    try {\n      await handler(...args);\n    } finally {\n      await this.topicLockEnd.publish({\n        name: key,\n      });\n\n      await this.setGracePeriod(key, lock, ...args);\n\n      this.log.debug(`Lock '${key}' OK`);\n    }\n  }\n\n  /**\n   * Set the lock for the given key.\n   */\n  protected async lock(key: string): Promise<LockResult> {\n    const value = await this.provider.set(\n      key,\n      `${this.id},${this.dateTimeProvider.nowISOString()}`,\n      true,\n      this.maxDuration.as(\"milliseconds\"),\n    );\n\n    return this.parse(value);\n  }\n\n  protected async setGracePeriod(\n    key: string,\n    lock: LockResult,\n    ...args: Parameters<TFunc>\n  ): Promise<void> {\n    const gracePeriod = this.options.gracePeriod\n      ? this.dateTimeProvider.isDurationLike(this.options.gracePeriod)\n        ? this.options.gracePeriod\n        : this.options.gracePeriod(...args)\n      : undefined;\n\n    if (gracePeriod) {\n      await this.provider.set(\n        key,\n        `${this.id},${lock.createdAt.toISOString()},${this.dateTimeProvider.nowISOString()}`,\n        false,\n        this.dateTimeProvider.duration(gracePeriod).as(\"milliseconds\"),\n      );\n    } else {\n      await this.provider.del(key);\n    }\n  }\n\n  protected async wait(key: string, maxDuration: DurationLike): Promise<void> {\n    this.log.debug(`Wait for lock '${key}' ...`);\n\n    await this.topicLockEnd.wait({\n      filter: (message) => message.payload.name === key,\n      timeout: maxDuration,\n    });\n\n    this.log.debug(`Wait for lock '${key}' OK`);\n  }\n\n  protected key(...args: Parameters<TFunc>) {\n    let base = \"\";\n\n    if (this.options.name) {\n      if (typeof this.options.name === \"string\") {\n        base = this.options.name;\n      } else {\n        base = this.options.name(...args);\n      }\n    } else {\n      base = `${this.config.service.name}:${this.config.propertyKey}`;\n    }\n\n    return `${this.settings.prefixKey}${base}`;\n  }\n\n  protected parse(value: string): LockResult {\n    const [id, createdAtStr, endedAtStr] = value.split(\",\");\n    const createdAt = this.dateTimeProvider.of(createdAtStr);\n    const endedAt = endedAtStr\n      ? this.dateTimeProvider.of(endedAtStr)\n      : undefined;\n\n    return {\n      id,\n      createdAt,\n      endedAt,\n    };\n  }\n}\n\nexport interface LockResult {\n  id: string;\n  createdAt: DateTime;\n  endedAt?: DateTime;\n  response?: string;\n}\n","import { $module } from \"alepha\";\nimport { MemoryTopicProvider } from \"alepha/topic\";\nimport { LockProvider } from \"./providers/LockProvider.ts\";\nimport { LockTopicProvider } from \"./providers/LockTopicProvider.ts\";\nimport { MemoryLockProvider } from \"./providers/MemoryLockProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport * from \"./primitives/$lock.ts\";\nexport * from \"./providers/LockProvider.ts\";\nexport * from \"./providers/LockTopicProvider.ts\";\nexport * from \"./providers/MemoryLockProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\ndeclare module \"alepha\" {\n  interface Hooks {\n    /**\n     * Fires when a lock is successfully acquired.\n     */\n    \"lock:acquired\": {\n      name: string;\n      id: string;\n      maxDurationMs: number;\n    };\n    /**\n     * Fires when a lock is released (handler completed or threw).\n     */\n    \"lock:released\": {\n      name: string;\n      id: string;\n      heldMs: number;\n    };\n    /**\n     * Fires when a lock acquisition contends with another holder.\n     * Emitted whether the caller eventually acquires (`wait: true`) or fails.\n     */\n    \"lock:contended\": {\n      name: string;\n      id: string;\n    };\n  }\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Resource locking for distributed systems.\n *\n * **Features:**\n * - Distributed locks with timeout\n * - Time-based lock expiration\n * - Automatic release on scope exit\n * - Distributed coordination via Redis\n * - Providers: Memory (dev), Redis (production)\n *\n * @module alepha.lock\n */\nexport const AlephaLock = $module({\n  name: \"alepha.lock\",\n  services: [LockProvider, LockTopicProvider],\n  variants: [MemoryLockProvider],\n  register: (alepha) =>\n    alepha\n      .with({\n        optional: true,\n        provide: LockTopicProvider,\n        use: MemoryTopicProvider,\n      })\n      .with({\n        optional: true,\n        provide: LockProvider,\n        use: MemoryLockProvider,\n      }),\n});\n"],"mappings":"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"}