abxbus 2.4.1

package/dist/cjs/retry.js

@@ -0,0 +1,257 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var retry_exports = {};
+__export(retry_exports, {
+  RetryTimeoutError: () => RetryTimeoutError,
+  SemaphoreTimeoutError: () => SemaphoreTimeoutError,
+  clearSemaphoreRegistry: () => clearSemaphoreRegistry,
+  retry: () => retry
+});
+module.exports = __toCommonJS(retry_exports);
+var import_async_context = require("./async_context.js");
+class RetryTimeoutError extends Error {
+  timeout_seconds;
+  attempt;
+  constructor(message, params) {
+    super(message);
+    this.name = "RetryTimeoutError";
+    this.timeout_seconds = params.timeout_seconds;
+    this.attempt = params.attempt;
+  }
+}
+class SemaphoreTimeoutError extends Error {
+  semaphore_name;
+  semaphore_limit;
+  timeout_seconds;
+  constructor(message, params) {
+    super(message);
+    this.name = "SemaphoreTimeoutError";
+    this.semaphore_name = params.semaphore_name;
+    this.semaphore_limit = params.semaphore_limit;
+    this.timeout_seconds = params.timeout_seconds;
+  }
+}
+const retry_context_storage = (0, import_async_context.createAsyncLocalStorage)();
+function getHeldSemaphores() {
+  return retry_context_storage?.getStore() ?? /* @__PURE__ */ new Set();
+}
+function runWithHeldSemaphores(held, fn) {
+  if (!retry_context_storage) return fn();
+  return retry_context_storage.run(held, fn);
+}
+let _next_instance_id = 1;
+const _instance_ids = /* @__PURE__ */ new WeakMap();
+function scopedSemaphoreKey(base_name, scope, context) {
+  if (scope === "class" && context && typeof context === "object") {
+    return `${context.constructor?.name ?? "Object"}.${base_name}`;
+  }
+  if (scope === "instance" && context && typeof context === "object") {
+    let id = _instance_ids.get(context);
+    if (id === void 0) {
+      id = _next_instance_id++;
+      _instance_ids.set(context, id);
+    }
+    return `${id}.${base_name}`;
+  }
+  return base_name;
+}
+class RetrySemaphore {
+  size;
+  inUse;
+  waiters;
+  constructor(size) {
+    this.size = size;
+    this.inUse = 0;
+    this.waiters = [];
+  }
+  async acquire() {
+    if (this.size === Infinity) {
+      return;
+    }
+    if (this.inUse < this.size) {
+      this.inUse += 1;
+      return;
+    }
+    await new Promise((resolve) => {
+      this.waiters.push(resolve);
+    });
+  }
+  release() {
+    if (this.size === Infinity) {
+      return;
+    }
+    const next = this.waiters.shift();
+    if (next) {
+      next();
+      return;
+    }
+    this.inUse = Math.max(0, this.inUse - 1);
+  }
+}
+const SEMAPHORE_REGISTRY = /* @__PURE__ */ new Map();
+function getOrCreateSemaphore(name, limit) {
+  const existing = SEMAPHORE_REGISTRY.get(name);
+  if (existing && existing.size === limit) return existing;
+  const sem = new RetrySemaphore(limit);
+  SEMAPHORE_REGISTRY.set(name, sem);
+  return sem;
+}
+function clearSemaphoreRegistry() {
+  SEMAPHORE_REGISTRY.clear();
+}
+function retry(options = {}) {
+  const {
+    max_attempts = 1,
+    retry_after = 0,
+    retry_backoff_factor = 1,
+    retry_on_errors,
+    timeout,
+    semaphore_limit,
+    semaphore_name: semaphore_name_option,
+    semaphore_lax = true,
+    semaphore_scope = "global",
+    semaphore_timeout
+  } = options;
+  return function decorator(target, _context) {
+    const fn_name = target.name || _context?.name || "anonymous";
+    const effective_max_attempts = Math.max(1, max_attempts);
+    const effective_retry_after = Math.max(0, retry_after);
+    async function retryWrapper(...args) {
+      const base_name = typeof semaphore_name_option === "function" ? semaphore_name_option(...args) : semaphore_name_option ?? fn_name;
+      const sem_name = typeof base_name === "string" ? base_name : String(base_name);
+      const scoped_key = scopedSemaphoreKey(sem_name, semaphore_scope, this);
+      const held = getHeldSemaphores();
+      const needs_semaphore = semaphore_limit != null && semaphore_limit > 0;
+      const is_reentrant = needs_semaphore && held.has(scoped_key);
+      let semaphore = null;
+      let semaphore_acquired = false;
+      if (needs_semaphore && !is_reentrant) {
+        semaphore = getOrCreateSemaphore(scoped_key, semaphore_limit);
+        const effective_sem_timeout = semaphore_timeout != null ? semaphore_timeout : timeout != null ? timeout * Math.max(1, semaphore_limit - 1) : null;
+        if (effective_sem_timeout != null && effective_sem_timeout > 0) {
+          semaphore_acquired = await acquireWithTimeout(semaphore, effective_sem_timeout * 1e3);
+          if (!semaphore_acquired) {
+            if (!semaphore_lax) {
+              throw new SemaphoreTimeoutError(
+                `Failed to acquire semaphore "${scoped_key}" within ${effective_sem_timeout}s (limit=${semaphore_limit})`,
+                { semaphore_name: scoped_key, semaphore_limit, timeout_seconds: effective_sem_timeout }
+              );
+            }
+          }
+        } else {
+          await semaphore.acquire();
+          semaphore_acquired = true;
+        }
+      }
+      const new_held = new Set(held);
+      if (semaphore_acquired) {
+        new_held.add(scoped_key);
+      }
+      const runRetryLoop = async () => {
+        for (let attempt = 1; attempt <= effective_max_attempts; attempt++) {
+          try {
+            if (timeout != null && timeout > 0) {
+              return await _runWithTimeout(() => Promise.resolve(target.apply(this, args)), timeout * 1e3, attempt);
+            } else {
+              return await Promise.resolve(target.apply(this, args));
+            }
+          } catch (error) {
+            if (retry_on_errors && retry_on_errors.length > 0) {
+              const is_retryable = retry_on_errors.some(
+                (matcher) => typeof matcher === "string" ? error?.name === matcher : matcher instanceof RegExp ? matcher.test(String(error)) : error instanceof matcher
+              );
+              if (!is_retryable) throw error;
+            }
+            if (attempt >= effective_max_attempts) throw error;
+            const delay_seconds = effective_retry_after * Math.pow(retry_backoff_factor, attempt - 1);
+            if (delay_seconds > 0) {
+              await sleep(delay_seconds * 1e3);
+            }
+          }
+        }
+        throw new Error(`retry(${fn_name}): unexpected end of retry loop`);
+      };
+      try {
+        return await runWithHeldSemaphores(new_held, runRetryLoop);
+      } finally {
+        if (semaphore_acquired && semaphore) {
+          semaphore.release();
+        }
+      }
+    }
+    Object.defineProperty(retryWrapper, "name", { value: fn_name, configurable: true });
+    return retryWrapper;
+  };
+}
+async function acquireWithTimeout(semaphore, timeout_ms) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        resolve(false);
+      }
+    }, timeout_ms);
+    semaphore.acquire().then(() => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timer);
+        resolve(true);
+      } else {
+        semaphore.release();
+      }
+    });
+  });
+}
+async function _runWithTimeout(fn, timeout_ms, attempt) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        reject(
+          new RetryTimeoutError(`Timed out after ${timeout_ms / 1e3}s (attempt ${attempt})`, {
+            timeout_seconds: timeout_ms / 1e3,
+            attempt
+          })
+        );
+      }
+    }, timeout_ms);
+    fn().then(
+      (value) => {
+        if (!settled) {
+          settled = true;
+          clearTimeout(timer);
+          resolve(value);
+        }
+      },
+      (error) => {
+        if (!settled) {
+          settled = true;
+          clearTimeout(timer);
+          reject(error);
+        }
+      }
+    );
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=retry.js.map

package/dist/cjs/retry.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/retry.ts"],
+  "sourcesContent": ["import { createAsyncLocalStorage, type AsyncLocalStorageLike } from './async_context.js'\n\n// \u2500\u2500\u2500 Types \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nexport interface RetryOptions {\n  /** Total number of attempts including the initial call (1 = no retry, 3 = up to 2 retries). Default: 1 */\n  max_attempts?: number\n\n  /** Seconds to wait between retries. Default: 0 */\n  retry_after?: number\n\n  /** Multiplier applied to retry_after after each attempt for exponential backoff. Default: 1.0 (constant delay) */\n  retry_backoff_factor?: number\n\n  /** Only retry when the thrown error matches one of these matchers. Accepts error class constructors,\n   *  string error names (matched against error.name), or RegExp patterns (tested against String(error)).\n   *  Default: undefined (retry on any error) */\n  retry_on_errors?: Array<(new (...args: any[]) => Error) | string | RegExp>\n\n  /** Per-attempt timeout in seconds. Default: undefined (no per-attempt timeout) */\n  timeout?: number | null\n\n  /** Maximum concurrent executions sharing this semaphore. Default: undefined (no concurrency limit) */\n  semaphore_limit?: number | null\n\n  /** Semaphore identifier. Functions with the same name share the same concurrency slot pool. Default: function name.\n   *  If a function is provided, it receives the same arguments as the wrapped function. */\n  semaphore_name?: string | ((...args: any[]) => string) | null\n\n  /** If true, proceed without concurrency limit when semaphore acquisition times out. Default: true */\n  semaphore_lax?: boolean\n\n  /** Semaphore scoping strategy. Default: 'global'\n   *  - 'global': all calls share one semaphore (keyed by semaphore_name)\n   *  - 'class': all instances of the same class share one semaphore (keyed by className.semaphore_name)\n   *  - 'instance': each object instance gets its own semaphore (keyed by instanceId.semaphore_name)\n   *  'class' and 'instance' require `this` to be an object; they fall back to 'global' for standalone calls. */\n  semaphore_scope?: 'global' | 'class' | 'instance'\n\n  /** Maximum seconds to wait for semaphore acquisition. Default: undefined \u2192 timeout * max(1, limit - 1) */\n  semaphore_timeout?: number | null\n}\n\n// \u2500\u2500\u2500 Errors \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n/** Thrown when a single attempt exceeds the per-attempt timeout. */\nexport class RetryTimeoutError extends Error {\n  timeout_seconds: number\n  attempt: number\n\n  constructor(message: string, params: { timeout_seconds: number; attempt: number }) {\n    super(message)\n    this.name = 'RetryTimeoutError'\n    this.timeout_seconds = params.timeout_seconds\n    this.attempt = params.attempt\n  }\n}\n\n/** Thrown (when semaphore_lax=false) if the semaphore cannot be acquired within the timeout. */\nexport class SemaphoreTimeoutError extends Error {\n  semaphore_name: string\n  semaphore_limit: number\n  timeout_seconds: number\n\n  constructor(message: string, params: { semaphore_name: string; semaphore_limit: number; timeout_seconds: number }) {\n    super(message)\n    this.name = 'SemaphoreTimeoutError'\n    this.semaphore_name = params.semaphore_name\n    this.semaphore_limit = params.semaphore_limit\n    this.timeout_seconds = params.timeout_seconds\n  }\n}\n\n// \u2500\u2500\u2500 Re-entrancy tracking via AsyncLocalStorage \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n//\n// Prevents deadlocks when a retry()-wrapped function calls another retry()-wrapped\n// function that shares the same semaphore (or calls itself recursively).\n//\n// Each async call stack tracks which semaphore names it currently holds. When a\n// nested call encounters a semaphore it already holds, it skips acquisition and\n// runs directly within the parent's slot.\n//\n// Uses the same AsyncLocalStorage polyfill as the rest of abxbus (see async_context.ts)\n// so it works in Node.js and gracefully degrades to a no-op in browsers.\n\ntype ReentrantStore = Set<string>\n\n// Separate AsyncLocalStorage instance for retry re-entrancy tracking.\n// Created via the shared factory in async_context.ts (returns null in browsers).\nconst retry_context_storage: AsyncLocalStorageLike | null = createAsyncLocalStorage()\n\nfunction getHeldSemaphores(): ReentrantStore {\n  return (retry_context_storage?.getStore() as ReentrantStore | undefined) ?? new Set()\n}\n\nfunction runWithHeldSemaphores<T>(held: ReentrantStore, fn: () => T): T {\n  if (!retry_context_storage) return fn()\n  return retry_context_storage.run(held, fn)\n}\n\n// \u2500\u2500\u2500 Semaphore scope helpers \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nlet _next_instance_id = 1\nconst _instance_ids = new WeakMap<object, number>()\n\nfunction scopedSemaphoreKey(base_name: string, scope: 'global' | 'class' | 'instance', context: unknown): string {\n  if (scope === 'class' && context && typeof context === 'object') {\n    return `${(context as object).constructor?.name ?? 'Object'}.${base_name}`\n  }\n  if (scope === 'instance' && context && typeof context === 'object') {\n    let id = _instance_ids.get(context as object)\n    if (id === undefined) {\n      id = _next_instance_id++\n      _instance_ids.set(context as object, id)\n    }\n    return `${id}.${base_name}`\n  }\n  return base_name\n}\n\n// \u2500\u2500\u2500 Global semaphore registry \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nclass RetrySemaphore {\n  readonly size: number\n  private inUse: number\n  private waiters: Array<() => void>\n\n  constructor(size: number) {\n    this.size = size\n    this.inUse = 0\n    this.waiters = []\n  }\n\n  async acquire(): Promise<void> {\n    if (this.size === Infinity) {\n      return\n    }\n    if (this.inUse < this.size) {\n      this.inUse += 1\n      return\n    }\n    await new Promise<void>((resolve) => {\n      this.waiters.push(resolve)\n    })\n  }\n\n  release(): void {\n    if (this.size === Infinity) {\n      return\n    }\n    const next = this.waiters.shift()\n    if (next) {\n      // Handoff: keep the permit accounted for and transfer it directly to the waiter.\n      next()\n      return\n    }\n    this.inUse = Math.max(0, this.inUse - 1)\n  }\n}\n\nconst SEMAPHORE_REGISTRY = new Map<string, RetrySemaphore>()\n\nfunction getOrCreateSemaphore(name: string, limit: number): RetrySemaphore {\n  const existing = SEMAPHORE_REGISTRY.get(name)\n  if (existing && existing.size === limit) return existing\n  const sem = new RetrySemaphore(limit)\n  SEMAPHORE_REGISTRY.set(name, sem)\n  return sem\n}\n\n/** Reset the global semaphore registry. Useful in tests. */\nexport function clearSemaphoreRegistry(): void {\n  SEMAPHORE_REGISTRY.clear()\n}\n\n// \u2500\u2500\u2500 retry() decorator / higher-order wrapper \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n//\n// Usage as a higher-order function (works on any async function):\n//\n//   const fetchWithRetry = retry({ max_attempts: 3, retry_after: 1 })(async (url: string) => {\n//     return await fetch(url)\n//   })\n//\n// Usage as a TC39 Stage 3 decorator on class methods (TS 5.0+):\n//\n//   class ApiClient {\n//     @retry({ max_attempts: 3, retry_after: 1 })\n//     async fetchData(): Promise<Data> { ... }\n//   }\n//\n// Usage on event bus handlers:\n//\n//   bus.on(MyEvent, retry({ max_attempts: 3 })(async (event) => {\n//     await riskyOperation(event.data)\n//   }))\n\nexport function retry(options: RetryOptions = {}) {\n  const {\n    max_attempts = 1,\n    retry_after = 0,\n    retry_backoff_factor = 1.0,\n    retry_on_errors,\n    timeout,\n    semaphore_limit,\n    semaphore_name: semaphore_name_option,\n    semaphore_lax = true,\n    semaphore_scope = 'global',\n    semaphore_timeout,\n  } = options\n\n  return function decorator<T extends (...args: any[]) => any>(target: T, _context?: ClassMethodDecoratorContext): T {\n    const fn_name = target.name || (_context?.name as string) || 'anonymous'\n    const effective_max_attempts = Math.max(1, max_attempts)\n    const effective_retry_after = Math.max(0, retry_after)\n\n    async function retryWrapper(this: any, ...args: any[]): Promise<any> {\n      const base_name = typeof semaphore_name_option === 'function' ? semaphore_name_option(...args) : (semaphore_name_option ?? fn_name)\n      const sem_name = typeof base_name === 'string' ? base_name : String(base_name)\n      // \u2500\u2500 Resolve scoped semaphore key at call time (uses `this` for class/instance scopes) \u2500\u2500\n      const scoped_key = scopedSemaphoreKey(sem_name, semaphore_scope, this)\n\n      // \u2500\u2500 Check re-entrancy: skip semaphore if we already hold it in this async context \u2500\u2500\n      const held = getHeldSemaphores()\n      const needs_semaphore = semaphore_limit != null && semaphore_limit > 0\n      const is_reentrant = needs_semaphore && held.has(scoped_key)\n\n      // \u2500\u2500 Semaphore acquisition (held across all retry attempts, skipped if re-entrant) \u2500\u2500\n      let semaphore: RetrySemaphore | null = null\n      let semaphore_acquired = false\n\n      if (needs_semaphore && !is_reentrant) {\n        semaphore = getOrCreateSemaphore(scoped_key, semaphore_limit!)\n\n        const effective_sem_timeout =\n          semaphore_timeout != null ? semaphore_timeout : timeout != null ? timeout * Math.max(1, semaphore_limit! - 1) : null\n\n        if (effective_sem_timeout != null && effective_sem_timeout > 0) {\n          semaphore_acquired = await acquireWithTimeout(semaphore, effective_sem_timeout * 1000)\n          if (!semaphore_acquired) {\n            if (!semaphore_lax) {\n              throw new SemaphoreTimeoutError(\n                `Failed to acquire semaphore \"${scoped_key}\" within ${effective_sem_timeout}s (limit=${semaphore_limit})`,\n                { semaphore_name: scoped_key, semaphore_limit: semaphore_limit!, timeout_seconds: effective_sem_timeout }\n              )\n            }\n            // lax mode: proceed without concurrency limit\n          }\n        } else {\n          // No timeout configured: wait indefinitely for a slot\n          await semaphore.acquire()\n          semaphore_acquired = true\n        }\n      }\n\n      // \u2500\u2500 Build the set of held semaphores for nested calls \u2500\u2500\n      const new_held = new Set(held)\n      if (semaphore_acquired) {\n        new_held.add(scoped_key)\n      }\n\n      // \u2500\u2500 Retry loop (runs inside the semaphore and re-entrancy context) \u2500\u2500\n      const runRetryLoop = async (): Promise<any> => {\n        for (let attempt = 1; attempt <= effective_max_attempts; attempt++) {\n          try {\n            if (timeout != null && timeout > 0) {\n              return await _runWithTimeout(() => Promise.resolve(target.apply(this, args)), timeout * 1000, attempt)\n            } else {\n              return await Promise.resolve(target.apply(this, args))\n            }\n          } catch (error) {\n            // Check if this error type should trigger a retry\n            if (retry_on_errors && retry_on_errors.length > 0) {\n              const is_retryable = retry_on_errors.some((matcher) =>\n                typeof matcher === 'string'\n                  ? (error as Error)?.name === matcher\n                  : matcher instanceof RegExp\n                    ? matcher.test(String(error))\n                    : error instanceof matcher\n              )\n              if (!is_retryable) throw error\n            }\n\n            // Last attempt: rethrow\n            if (attempt >= effective_max_attempts) throw error\n\n            // Wait before next attempt with exponential backoff\n            const delay_seconds = effective_retry_after * Math.pow(retry_backoff_factor, attempt - 1)\n            if (delay_seconds > 0) {\n              await sleep(delay_seconds * 1000)\n            }\n          }\n        }\n\n        // Unreachable, but satisfies the type checker\n        throw new Error(`retry(${fn_name}): unexpected end of retry loop`)\n      }\n\n      try {\n        return await runWithHeldSemaphores(new_held, runRetryLoop)\n      } finally {\n        if (semaphore_acquired && semaphore) {\n          semaphore.release()\n        }\n      }\n    }\n\n    Object.defineProperty(retryWrapper, 'name', { value: fn_name, configurable: true })\n    return retryWrapper as unknown as T\n  }\n}\n\n// \u2500\u2500\u2500 Internal helpers \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n/**\n * Try to acquire a semaphore within a timeout. Returns true if acquired, false if timed out.\n * If the semaphore is acquired after the timeout (due to the waiter remaining queued),\n * it is immediately released to avoid leaking slots.\n */\nasync function acquireWithTimeout(semaphore: RetrySemaphore, timeout_ms: number): Promise<boolean> {\n  return new Promise<boolean>((resolve) => {\n    let settled = false\n\n    const timer = setTimeout(() => {\n      if (!settled) {\n        settled = true\n        resolve(false)\n      }\n    }, timeout_ms)\n\n    semaphore.acquire().then(() => {\n      if (!settled) {\n        settled = true\n        clearTimeout(timer)\n        resolve(true)\n      } else {\n        // Acquired after timeout fired \u2014 release immediately to avoid slot leak\n        semaphore.release()\n      }\n    })\n  })\n}\n\n/** Run fn() with a timeout. Rejects with RetryTimeoutError if the timeout fires first. */\nasync function _runWithTimeout<T>(fn: () => Promise<T>, timeout_ms: number, attempt: number): Promise<T> {\n  return new Promise<T>((resolve, reject) => {\n    let settled = false\n\n    const timer = setTimeout(() => {\n      if (!settled) {\n        settled = true\n        reject(\n          new RetryTimeoutError(`Timed out after ${timeout_ms / 1000}s (attempt ${attempt})`, {\n            timeout_seconds: timeout_ms / 1000,\n            attempt,\n          })\n        )\n      }\n    }, timeout_ms)\n\n    fn().then(\n      (value) => {\n        if (!settled) {\n          settled = true\n          clearTimeout(timer)\n          resolve(value)\n        }\n      },\n      (error) => {\n        if (!settled) {\n          settled = true\n          clearTimeout(timer)\n          reject(error)\n        }\n      }\n    )\n  })\n}\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms))\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/timing.d.ts

@@ -0,0 +1,3 @@
+export declare function _runWithTimeout<T>(timeout_seconds: number | null, on_timeout: () => Error, fn: () => Promise<T>): Promise<T>;
+export declare function _runWithSlowMonitor<T>(slow_timer: ReturnType<typeof setTimeout> | null, fn: () => Promise<T>): Promise<T>;
+export declare function _runWithAbortMonitor<T>(fn: () => T | Promise<T>, abort_signal: Promise<never>): Promise<T>;

package/dist/cjs/timing.js

@@ -0,0 +1,76 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var timing_exports = {};
+__export(timing_exports, {
+  _runWithAbortMonitor: () => _runWithAbortMonitor,
+  _runWithSlowMonitor: () => _runWithSlowMonitor,
+  _runWithTimeout: () => _runWithTimeout
+});
+module.exports = __toCommonJS(timing_exports);
+async function _runWithTimeout(timeout_seconds, on_timeout, fn) {
+  const task = Promise.resolve().then(fn);
+  if (timeout_seconds === null) {
+    return await task;
+  }
+  const timeout_ms = timeout_seconds * 1e3;
+  return await new Promise((resolve, reject) => {
+    let settled = false;
+    const finishResolve = (value) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const finishReject = (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      reject(error);
+    };
+    const timer = setTimeout(() => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      reject(on_timeout());
+      void task.catch(() => void 0);
+    }, timeout_ms);
+    task.then(finishResolve).catch(finishReject);
+  });
+}
+async function _runWithSlowMonitor(slow_timer, fn) {
+  try {
+    return await fn();
+  } finally {
+    if (slow_timer) {
+      clearTimeout(slow_timer);
+    }
+  }
+}
+async function _runWithAbortMonitor(fn, abort_signal) {
+  const task = Promise.resolve().then(fn);
+  const raced = Promise.race([task, abort_signal]);
+  void task.catch(() => void 0);
+  return await raced;
+}
+//# sourceMappingURL=timing.js.map

package/dist/cjs/timing.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/timing.ts"],
+  "sourcesContent": ["export async function _runWithTimeout<T>(timeout_seconds: number | null, on_timeout: () => Error, fn: () => Promise<T>): Promise<T> {\n  const task = Promise.resolve().then(fn)\n  if (timeout_seconds === null) {\n    return await task\n  }\n  const timeout_ms = timeout_seconds * 1000\n  return await new Promise<T>((resolve, reject) => {\n    let settled = false\n    const finishResolve = (value: T) => {\n      if (settled) {\n        return\n      }\n      settled = true\n      clearTimeout(timer)\n      resolve(value)\n    }\n    const finishReject = (error: unknown) => {\n      if (settled) {\n        return\n      }\n      settled = true\n      clearTimeout(timer)\n      reject(error)\n    }\n    const timer = setTimeout(() => {\n      if (settled) {\n        return\n      }\n      settled = true\n      reject(on_timeout())\n      void task.catch(() => undefined)\n    }, timeout_ms)\n    task.then(finishResolve).catch(finishReject)\n  })\n}\n\nexport async function _runWithSlowMonitor<T>(slow_timer: ReturnType<typeof setTimeout> | null, fn: () => Promise<T>): Promise<T> {\n  try {\n    return await fn()\n  } finally {\n    if (slow_timer) {\n      clearTimeout(slow_timer)\n    }\n  }\n}\n\nexport async function _runWithAbortMonitor<T>(fn: () => T | Promise<T>, abort_signal: Promise<never>): Promise<T> {\n  const task = Promise.resolve().then(fn)\n  const raced = Promise.race([task, abort_signal])\n  void task.catch(() => undefined)\n  return await raced\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,eAAsB,gBAAmB,iBAAgC,YAAyB,IAAkC;AAClI,QAAM,OAAO,QAAQ,QAAQ,EAAE,KAAK,EAAE;AACtC,MAAI,oBAAoB,MAAM;AAC5B,WAAO,MAAM;AAAA,EACf;AACA,QAAM,aAAa,kBAAkB;AACrC,SAAO,MAAM,IAAI,QAAW,CAAC,SAAS,WAAW;AAC/C,QAAI,UAAU;AACd,UAAM,gBAAgB,CAAC,UAAa;AAClC,UAAI,SAAS;AACX;AAAA,MACF;AACA,gBAAU;AACV,mBAAa,KAAK;AAClB,cAAQ,KAAK;AAAA,IACf;AACA,UAAM,eAAe,CAAC,UAAmB;AACvC,UAAI,SAAS;AACX;AAAA,MACF;AACA,gBAAU;AACV,mBAAa,KAAK;AAClB,aAAO,KAAK;AAAA,IACd;AACA,UAAM,QAAQ,WAAW,MAAM;AAC7B,UAAI,SAAS;AACX;AAAA,MACF;AACA,gBAAU;AACV,aAAO,WAAW,CAAC;AACnB,WAAK,KAAK,MAAM,MAAM,MAAS;AAAA,IACjC,GAAG,UAAU;AACb,SAAK,KAAK,aAAa,EAAE,MAAM,YAAY;AAAA,EAC7C,CAAC;AACH;AAEA,eAAsB,oBAAuB,YAAkD,IAAkC;AAC/H,MAAI;AACF,WAAO,MAAM,GAAG;AAAA,EAClB,UAAE;AACA,QAAI,YAAY;AACd,mBAAa,UAAU;AAAA,IACzB;AAAA,EACF;AACF;AAEA,eAAsB,qBAAwB,IAA0B,cAA0C;AAChH,QAAM,OAAO,QAAQ,QAAQ,EAAE,KAAK,EAAE;AACtC,QAAM,QAAQ,QAAQ,KAAK,CAAC,MAAM,YAAY,CAAC;AAC/C,OAAK,KAAK,MAAM,MAAM,MAAS;AAC/B,SAAO,MAAM;AACf;",
+  "names": []
+}

package/dist/cjs/type_inference.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/types.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import type { BaseEvent } from './base_event.js';
+export type EventStatus = 'pending' | 'started' | 'completed';
+export type EventClass<T extends BaseEvent = BaseEvent> = {
+    event_type?: string;
+} & (new (...args: any[]) => T);
+export type EventPattern<T extends BaseEvent = BaseEvent> = string | EventClass<T>;
+export type EventWithResultSchema<TResult> = BaseEvent & {
+    __event_result_type__?: TResult;
+};
+export type EventResultType<TEvent extends BaseEvent> = TEvent extends {
+    __event_result_type__?: infer TResult;
+} ? TResult : unknown;
+export type EventResultTypeConstructor = StringConstructor | NumberConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor;
+export type EventResultTypeInput = z.ZodTypeAny | EventResultTypeConstructor | unknown;
+export type EventHandlerReturn<T extends BaseEvent = BaseEvent> = EventResultType<T> | BaseEvent | null | void;
+export type EventHandlerCallable<T extends BaseEvent = BaseEvent> = (event: T) => EventHandlerReturn<T> | Promise<EventHandlerReturn<T>>;
+export type UntypedEventHandlerFunction<T extends BaseEvent = BaseEvent> = (event: T) => EventHandlerReturn<T> | unknown | Promise<EventHandlerReturn<T> | unknown>;
+export type FindWindow = boolean | number;
+type FindReservedOptionKeys = 'past' | 'future' | 'child_of';
+type EventFilterFields<T extends BaseEvent> = {
+    [K in keyof T as string extends K ? never : number extends K ? never : symbol extends K ? never : K extends FindReservedOptionKeys ? never : T[K] extends (...args: any[]) => any ? never : K]?: T[K];
+};
+export type FindOptions<T extends BaseEvent = BaseEvent> = {
+    past?: FindWindow;
+    future?: FindWindow;
+    child_of?: BaseEvent | null;
+} & EventFilterFields<T> & Record<string, unknown>;
+export declare const normalizeEventPattern: (event_pattern: EventPattern | "*") => string | "*";
+export declare const isZodSchema: (value: unknown) => value is z.ZodTypeAny;
+export declare const eventResultTypeFromConstructor: (value: unknown) => z.ZodTypeAny | undefined;
+export declare const extractZodShape: (raw: Record<string, unknown>) => z.ZodRawShape;
+export declare const toJsonSchema: (schema: unknown) => unknown;
+export declare const fromJsonSchema: (schema: unknown) => z.ZodTypeAny;
+export declare const normalizeEventResultType: (value: EventResultTypeInput) => z.ZodTypeAny | undefined;
+export {};

package/dist/cjs/types.js

@@ -0,0 +1,104 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+__export(types_exports, {
+  eventResultTypeFromConstructor: () => eventResultTypeFromConstructor,
+  extractZodShape: () => extractZodShape,
+  fromJsonSchema: () => fromJsonSchema,
+  isZodSchema: () => isZodSchema,
+  normalizeEventPattern: () => normalizeEventPattern,
+  normalizeEventResultType: () => normalizeEventResultType,
+  toJsonSchema: () => toJsonSchema
+});
+module.exports = __toCommonJS(types_exports);
+var import_zod = require("zod");
+const normalizeEventPattern = (event_pattern) => {
+  if (event_pattern === "*") {
+    return "*";
+  }
+  if (typeof event_pattern === "string") {
+    return event_pattern;
+  }
+  const event_type = event_pattern.event_type;
+  if (typeof event_type === "string" && event_type.length > 0 && event_type !== "BaseEvent") {
+    return event_type;
+  }
+  const class_name = event_pattern.name;
+  if (typeof class_name === "string" && class_name.length > 0 && class_name !== "BaseEvent") {
+    return class_name;
+  }
+  let preview;
+  try {
+    const encoded = JSON.stringify(event_pattern);
+    preview = typeof encoded === "string" ? encoded.slice(0, 30) : String(event_pattern).slice(0, 30);
+  } catch {
+    preview = String(event_pattern).slice(0, 30);
+  }
+  throw new Error('bus.on(match_pattern, ...) must be a string event type, "*", or a BaseEvent class, got: ' + preview);
+};
+const isZodSchema = (value) => !!value && typeof value.safeParse === "function";
+const eventResultTypeFromConstructor = (value) => {
+  if (value === String) {
+    return import_zod.z.string();
+  }
+  if (value === Number) {
+    return import_zod.z.number();
+  }
+  if (value === Boolean) {
+    return import_zod.z.boolean();
+  }
+  if (value === Array) {
+    return import_zod.z.array(import_zod.z.unknown());
+  }
+  if (value === Object) {
+    return import_zod.z.record(import_zod.z.string(), import_zod.z.unknown());
+  }
+  return void 0;
+};
+const extractZodShape = (raw) => {
+  const shape = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (key === "event_result_type") continue;
+    if (isZodSchema(value)) shape[key] = value;
+  }
+  return shape;
+};
+const toJsonSchema = (schema) => {
+  if (!schema || !isZodSchema(schema)) return schema;
+  const zod_any = import_zod.z;
+  return zod_any.toJSONSchema(schema);
+};
+const fromJsonSchema = (schema) => {
+  const zod_any = import_zod.z;
+  return zod_any.fromJSONSchema(schema);
+};
+const normalizeEventResultType = (value) => {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (isZodSchema(value)) {
+    return value;
+  }
+  const constructor_schema = eventResultTypeFromConstructor(value);
+  if (constructor_schema) {
+    return constructor_schema;
+  }
+  return fromJsonSchema(value);
+};
+//# sourceMappingURL=types.js.map

package/dist/cjs/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/types.ts"],
+  "sourcesContent": ["import { z } from 'zod'\nimport type { BaseEvent } from './base_event.js'\n\nexport type EventStatus = 'pending' | 'started' | 'completed'\n\nexport type EventClass<T extends BaseEvent = BaseEvent> = { event_type?: string } & (new (...args: any[]) => T)\n\nexport type EventPattern<T extends BaseEvent = BaseEvent> = string | EventClass<T>\n\nexport type EventWithResultSchema<TResult> = BaseEvent & { __event_result_type__?: TResult }\n\nexport type EventResultType<TEvent extends BaseEvent> = TEvent extends { __event_result_type__?: infer TResult } ? TResult : unknown\n\nexport type EventResultTypeConstructor = StringConstructor | NumberConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor\n\nexport type EventResultTypeInput = z.ZodTypeAny | EventResultTypeConstructor | unknown\n\nexport type EventHandlerReturn<T extends BaseEvent = BaseEvent> = EventResultType<T> | BaseEvent | null | void\n\nexport type EventHandlerCallable<T extends BaseEvent = BaseEvent> = (event: T) => EventHandlerReturn<T> | Promise<EventHandlerReturn<T>>\n\n// For string and wildcard subscriptions we cannot reliably infer which event\n// type will arrive, so return type checking intentionally degrades to unknown.\nexport type UntypedEventHandlerFunction<T extends BaseEvent = BaseEvent> = (\n  event: T\n) => EventHandlerReturn<T> | unknown | Promise<EventHandlerReturn<T> | unknown>\n\nexport type FindWindow = boolean | number\n\ntype FindReservedOptionKeys = 'past' | 'future' | 'child_of'\n\ntype EventFilterFields<T extends BaseEvent> = {\n  [K in keyof T as string extends K\n    ? never\n    : number extends K\n      ? never\n      : symbol extends K\n        ? never\n        : K extends FindReservedOptionKeys\n          ? never\n          : T[K] extends (...args: any[]) => any\n            ? never\n            : K]?: T[K]\n}\n\nexport type FindOptions<T extends BaseEvent = BaseEvent> = {\n  past?: FindWindow\n  future?: FindWindow\n  child_of?: BaseEvent | null\n} & EventFilterFields<T> &\n  Record<string, unknown>\n\nexport const normalizeEventPattern = (event_pattern: EventPattern | '*'): string | '*' => {\n  if (event_pattern === '*') {\n    return '*'\n  }\n  if (typeof event_pattern === 'string') {\n    return event_pattern\n  }\n  const event_type = (event_pattern as { event_type?: unknown }).event_type\n  if (typeof event_type === 'string' && event_type.length > 0 && event_type !== 'BaseEvent') {\n    return event_type\n  }\n  const class_name = (event_pattern as { name?: unknown }).name\n  if (typeof class_name === 'string' && class_name.length > 0 && class_name !== 'BaseEvent') {\n    return class_name\n  }\n  let preview: string\n  try {\n    const encoded = JSON.stringify(event_pattern)\n    preview = typeof encoded === 'string' ? encoded.slice(0, 30) : String(event_pattern).slice(0, 30)\n  } catch {\n    preview = String(event_pattern).slice(0, 30)\n  }\n  throw new Error('bus.on(match_pattern, ...) must be a string event type, \"*\", or a BaseEvent class, got: ' + preview)\n}\n\nexport const isZodSchema = (value: unknown): value is z.ZodTypeAny => !!value && typeof (value as z.ZodTypeAny).safeParse === 'function'\n\nexport const eventResultTypeFromConstructor = (value: unknown): z.ZodTypeAny | undefined => {\n  if (value === String) {\n    return z.string()\n  }\n  if (value === Number) {\n    return z.number()\n  }\n  if (value === Boolean) {\n    return z.boolean()\n  }\n  if (value === Array) {\n    return z.array(z.unknown())\n  }\n  if (value === Object) {\n    return z.record(z.string(), z.unknown())\n  }\n  return undefined\n}\n\nexport const extractZodShape = (raw: Record<string, unknown>): z.ZodRawShape => {\n  const shape: Record<string, z.ZodTypeAny> = {}\n  for (const [key, value] of Object.entries(raw)) {\n    if (key === 'event_result_type') continue\n    if (isZodSchema(value)) shape[key] = value\n  }\n  return shape as z.ZodRawShape\n}\n\nexport const toJsonSchema = (schema: unknown): unknown => {\n  if (!schema || !isZodSchema(schema)) return schema\n  const zod_any = z as unknown as { toJSONSchema: (input: z.ZodTypeAny) => unknown }\n  // Cross-language roundtrips preserve core structural types; constraint keywords may not roundtrip exactly.\n  return zod_any.toJSONSchema(schema)\n}\n\nexport const fromJsonSchema = (schema: unknown): z.ZodTypeAny => {\n  const zod_any = z as unknown as { fromJSONSchema: (input: unknown) => z.ZodTypeAny }\n  return zod_any.fromJSONSchema(schema)\n}\n\nexport const normalizeEventResultType = (value: EventResultTypeInput): z.ZodTypeAny | undefined => {\n  if (value === undefined || value === null) {\n    return undefined\n  }\n  if (isZodSchema(value)) {\n    return value\n  }\n  const constructor_schema = eventResultTypeFromConstructor(value)\n  if (constructor_schema) {\n    return constructor_schema\n  }\n  return fromJsonSchema(value)\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAAkB;AAoDX,MAAM,wBAAwB,CAAC,kBAAoD;AACxF,MAAI,kBAAkB,KAAK;AACzB,WAAO;AAAA,EACT;AACA,MAAI,OAAO,kBAAkB,UAAU;AACrC,WAAO;AAAA,EACT;AACA,QAAM,aAAc,cAA2C;AAC/D,MAAI,OAAO,eAAe,YAAY,WAAW,SAAS,KAAK,eAAe,aAAa;AACzF,WAAO;AAAA,EACT;AACA,QAAM,aAAc,cAAqC;AACzD,MAAI,OAAO,eAAe,YAAY,WAAW,SAAS,KAAK,eAAe,aAAa;AACzF,WAAO;AAAA,EACT;AACA,MAAI;AACJ,MAAI;AACF,UAAM,UAAU,KAAK,UAAU,aAAa;AAC5C,cAAU,OAAO,YAAY,WAAW,QAAQ,MAAM,GAAG,EAAE,IAAI,OAAO,aAAa,EAAE,MAAM,GAAG,EAAE;AAAA,EAClG,QAAQ;AACN,cAAU,OAAO,aAAa,EAAE,MAAM,GAAG,EAAE;AAAA,EAC7C;AACA,QAAM,IAAI,MAAM,6FAA6F,OAAO;AACtH;AAEO,MAAM,cAAc,CAAC,UAA0C,CAAC,CAAC,SAAS,OAAQ,MAAuB,cAAc;AAEvH,MAAM,iCAAiC,CAAC,UAA6C;AAC1F,MAAI,UAAU,QAAQ;AACpB,WAAO,aAAE,OAAO;AAAA,EAClB;AACA,MAAI,UAAU,QAAQ;AACpB,WAAO,aAAE,OAAO;AAAA,EAClB;AACA,MAAI,UAAU,SAAS;AACrB,WAAO,aAAE,QAAQ;AAAA,EACnB;AACA,MAAI,UAAU,OAAO;AACnB,WAAO,aAAE,MAAM,aAAE,QAAQ,CAAC;AAAA,EAC5B;AACA,MAAI,UAAU,QAAQ;AACpB,WAAO,aAAE,OAAO,aAAE,OAAO,GAAG,aAAE,QAAQ,CAAC;AAAA,EACzC;AACA,SAAO;AACT;AAEO,MAAM,kBAAkB,CAAC,QAAgD;AAC9E,QAAM,QAAsC,CAAC;AAC7C,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,GAAG,GAAG;AAC9C,QAAI,QAAQ,oBAAqB;AACjC,QAAI,YAAY,KAAK,EAAG,OAAM,GAAG,IAAI;AAAA,EACvC;AACA,SAAO;AACT;AAEO,MAAM,eAAe,CAAC,WAA6B;AACxD,MAAI,CAAC,UAAU,CAAC,YAAY,MAAM,EAAG,QAAO;AAC5C,QAAM,UAAU;AAEhB,SAAO,QAAQ,aAAa,MAAM;AACpC;AAEO,MAAM,iBAAiB,CAAC,WAAkC;AAC/D,QAAM,UAAU;AAChB,SAAO,QAAQ,eAAe,MAAM;AACtC;AAEO,MAAM,2BAA2B,CAAC,UAA0D;AACjG,MAAI,UAAU,UAAa,UAAU,MAAM;AACzC,WAAO;AAAA,EACT;AACA,MAAI,YAAY,KAAK,GAAG;AACtB,WAAO;AAAA,EACT;AACA,QAAM,qBAAqB,+BAA+B,KAAK;AAC/D,MAAI,oBAAoB;AACtB,WAAO;AAAA,EACT;AACA,SAAO,eAAe,KAAK;AAC7B;",
+  "names": []
+}

package/dist/esm/async_context.js

@@ -0,0 +1,50 @@
+let _AsyncLocalStorageClass = null;
+const is_node = typeof process !== "undefined" && typeof process.versions !== "undefined" && typeof process.versions.node === "string";
+const loadAsyncLocalStorageClass = () => {
+  if (!is_node) return null;
+  const maybe_process = globalThis.process;
+  const get_builtin_module = maybe_process?.getBuiltinModule;
+  if (typeof get_builtin_module === "function") {
+    const mod = get_builtin_module("node:async_hooks");
+    if (mod?.AsyncLocalStorage) {
+      return mod.AsyncLocalStorage;
+    }
+  }
+  try {
+    const maybe_require = Function('return typeof require === "function" ? require : undefined')();
+    const mod = maybe_require?.("node:async_hooks");
+    if (mod?.AsyncLocalStorage) {
+      return mod.AsyncLocalStorage;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+};
+_AsyncLocalStorageClass = loadAsyncLocalStorageClass();
+const createAsyncLocalStorage = () => {
+  if (!_AsyncLocalStorageClass) return null;
+  return new _AsyncLocalStorageClass();
+};
+let async_local_storage = _AsyncLocalStorageClass ? new _AsyncLocalStorageClass() : null;
+const captureAsyncContext = () => {
+  if (!async_local_storage) {
+    return null;
+  }
+  return async_local_storage.getStore() ?? null;
+};
+const _runWithAsyncContext = (context, fn) => {
+  if (!async_local_storage) {
+    return fn();
+  }
+  return async_local_storage.run(context ?? void 0, fn);
+};
+const hasAsyncLocalStorage = () => async_local_storage !== null;
+export {
+  _runWithAsyncContext,
+  async_local_storage,
+  captureAsyncContext,
+  createAsyncLocalStorage,
+  hasAsyncLocalStorage
+};
+//# sourceMappingURL=async_context.js.map

package/dist/esm/async_context.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/async_context.ts"],
+  "sourcesContent": ["declare const process: { versions?: { node?: string } } | undefined\n\ntype AsyncLocalStorageLike = {\n  getStore(): unknown\n  run<T>(store: unknown, callback: () => T): T\n  enterWith?(store: unknown): void\n}\n\nexport type { AsyncLocalStorageLike }\n\n// Cache the AsyncLocalStorage constructor so multiple modules can create separate instances.\nlet _AsyncLocalStorageClass: (new () => AsyncLocalStorageLike) | null = null\n\nconst is_node = typeof process !== 'undefined' && typeof process.versions !== 'undefined' && typeof process.versions.node === 'string'\n\nconst loadAsyncLocalStorageClass = (): (new () => AsyncLocalStorageLike) | null => {\n  if (!is_node) return null\n\n  // Prefer process.getBuiltinModule when available (works in ESM and CJS without top-level await).\n  const maybe_process = (globalThis as { process?: { getBuiltinModule?: (name: string) => unknown } }).process\n  const get_builtin_module = maybe_process?.getBuiltinModule\n  if (typeof get_builtin_module === 'function') {\n    const mod = get_builtin_module('node:async_hooks') as { AsyncLocalStorage?: new () => AsyncLocalStorageLike } | undefined\n    if (mod?.AsyncLocalStorage) {\n      return mod.AsyncLocalStorage\n    }\n  }\n\n  // Fallback for older Node runtimes where require is available.\n  try {\n    const maybe_require = Function('return typeof require === \"function\" ? require : undefined')() as\n      | ((specifier: string) => { AsyncLocalStorage?: new () => AsyncLocalStorageLike })\n      | undefined\n    const mod = maybe_require?.('node:async_hooks')\n    if (mod?.AsyncLocalStorage) {\n      return mod.AsyncLocalStorage\n    }\n  } catch {\n    return null\n  }\n\n  return null\n}\n\n_AsyncLocalStorageClass = loadAsyncLocalStorageClass()\n\n/** Create a new AsyncLocalStorage instance, or null if unavailable (e.g. in browsers). */\nexport const createAsyncLocalStorage = (): AsyncLocalStorageLike | null => {\n  if (!_AsyncLocalStorageClass) return null\n  return new _AsyncLocalStorageClass()\n}\n\n// The primary AsyncLocalStorage instance used for event dispatch context propagation.\nexport let async_local_storage: AsyncLocalStorageLike | null = _AsyncLocalStorageClass ? new _AsyncLocalStorageClass() : null\n\nexport const captureAsyncContext = (): unknown | null => {\n  if (!async_local_storage) {\n    return null\n  }\n  return async_local_storage.getStore() ?? null\n}\n\nexport const _runWithAsyncContext = <T>(context: unknown | null, fn: () => T): T => {\n  if (!async_local_storage) {\n    return fn()\n  }\n  return async_local_storage.run(context ?? undefined, fn)\n}\n\nexport const hasAsyncLocalStorage = (): boolean => async_local_storage !== null\n"],
+  "mappings": "AAWA,IAAI,0BAAoE;AAExE,MAAM,UAAU,OAAO,YAAY,eAAe,OAAO,QAAQ,aAAa,eAAe,OAAO,QAAQ,SAAS,SAAS;AAE9H,MAAM,6BAA6B,MAAgD;AACjF,MAAI,CAAC,QAAS,QAAO;AAGrB,QAAM,gBAAiB,WAA8E;AACrG,QAAM,qBAAqB,eAAe;AAC1C,MAAI,OAAO,uBAAuB,YAAY;AAC5C,UAAM,MAAM,mBAAmB,kBAAkB;AACjD,QAAI,KAAK,mBAAmB;AAC1B,aAAO,IAAI;AAAA,IACb;AAAA,EACF;AAGA,MAAI;AACF,UAAM,gBAAgB,SAAS,4DAA4D,EAAE;AAG7F,UAAM,MAAM,gBAAgB,kBAAkB;AAC9C,QAAI,KAAK,mBAAmB;AAC1B,aAAO,IAAI;AAAA,IACb;AAAA,EACF,QAAQ;AACN,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAEA,0BAA0B,2BAA2B;AAG9C,MAAM,0BAA0B,MAAoC;AACzE,MAAI,CAAC,wBAAyB,QAAO;AACrC,SAAO,IAAI,wBAAwB;AACrC;AAGO,IAAI,sBAAoD,0BAA0B,IAAI,wBAAwB,IAAI;AAElH,MAAM,sBAAsB,MAAsB;AACvD,MAAI,CAAC,qBAAqB;AACxB,WAAO;AAAA,EACT;AACA,SAAO,oBAAoB,SAAS,KAAK;AAC3C;AAEO,MAAM,uBAAuB,CAAI,SAAyB,OAAmB;AAClF,MAAI,CAAC,qBAAqB;AACxB,WAAO,GAAG;AAAA,EACZ;AACA,SAAO,oBAAoB,IAAI,WAAW,QAAW,EAAE;AACzD;AAEO,MAAM,uBAAuB,MAAe,wBAAwB;",
+  "names": []
+}