actly 1.1.5 → 1.3.0

package/dist/utils/abort.js

@@ -1,87 +1,64 @@
-// ─── AbortSignal helpers ──────────────────────────────────────────────────────
-//
-// Centralised utilities for composing AbortSignals. These exist because
-// Node 18 lacks `AbortSignal.any` (added in Node 20) and we want to keep
-// the `engines` floor at 18 for backwards compatibility with existing
-// consumers.
-/**
- * Polyfill for `AbortSignal.any(signals)` (Node 20+).
- *
- * Returns a single signal that aborts when ANY of the input signals aborts,
- * with the same reason. If any input is already aborted, the returned signal
- * is aborted synchronously.
- *
- * Listener registration is `{ once: true }` — once any signal fires, we stop
- * listening on the others. The composite signal cannot be "un-aborted".
- */
+const NATIVE_ANY = AbortSignal.any;
 export function anySignal(signals) {
-    // Fast path: native implementation (Node 20+, modern browsers, Bun).
-    // The cast is safe — the runtime check guards the call.
-    const native = AbortSignal.any;
-    if (typeof native === 'function')
-        return native.call(AbortSignal, signals);
-    // Polyfill for Node 18.
+    const filtered = signals.filter((s) => s != null);
+    if (filtered.length === 0)
+        return new AbortController().signal;
+    if (filtered.length === 1)
+        return filtered[0];
+    if (NATIVE_ANY)
+        return NATIVE_ANY.call(AbortSignal, filtered);
     const controller = new AbortController();
-    for (const signal of signals) {
+    const listeners = [];
+    for (const signal of filtered) {
         if (signal.aborted) {
             controller.abort(signal.reason);
             break;
         }
-        signal.addEventListener('abort', () => controller.abort(signal.reason), { once: true });
+        const onAbort = () => {
+            controller.abort(signal.reason);
+            for (const off of listeners)
+                off();
+        };
+        signal.addEventListener('abort', onAbort, { once: true });
+        listeners.push(() => signal.removeEventListener('abort', onAbort));
+    }
+    if (controller.signal.aborted) {
+        for (const off of listeners)
+            off();
     }
     return controller.signal;
 }
-/**
- * Race a promise against an AbortSignal.
- *
- * - If the signal is already aborted, rejects immediately with `signal.reason`.
- * - If the signal aborts while the promise is pending, rejects with `signal.reason`.
- * - If the promise settles first, returns its value (or rejects with its error).
- *
- * The listener is registered with `{ once: true }` and never leaks: either
- * the signal fires (listener auto-removed) or the promise settles (the
- * signal will eventually be GC'd along with the listener).
- *
- * Used by `dedupePolicy` so joiners can cancel their own `await` even if the
- * originator's `fn` is still running.
- */
 export function raceAbort(promise, signal) {
-    if (signal.aborted)
+    if (signal.aborted) {
+        promise.catch(() => { });
         return Promise.reject(signal.reason);
+    }
     return new Promise((resolve, reject) => {
         let settled = false;
         const onAbort = () => {
             if (settled)
                 return;
             settled = true;
+            signal.removeEventListener('abort', onAbort);
             reject(signal.reason);
         };
-        signal.addEventListener('abort', onAbort, { once: true });
+        signal.addEventListener('abort', onAbort);
         promise.then((value) => {
             if (settled)
                 return;
             settled = true;
+            signal.removeEventListener('abort', onAbort);
             resolve(value);
         }, (error) => {
             if (settled)
                 return;
             settled = true;
+            signal.removeEventListener('abort', onAbort);
             reject(error);
         });
     });
 }
-/**
- * Sleep for `ms` milliseconds, but abort early if `signal` fires.
- *
- * Resolves normally on timer expiry. Rejects with `signal.reason` if the
- * signal aborts before the timer fires. If the signal is already aborted
- * when called, rejects synchronously (in microtask).
- *
- * Used by `retryPolicy` to make backoff delays interruptible: when an outer
- * `totalTimeout` fires mid-delay, the delay rejects immediately instead of
- * blocking the retry loop until the timer would have elapsed.
- */
-export function sleep(ms, signal) {
+export function sleep(ms, signal, opts) {
     if (ms <= 0) {
         if (signal?.aborted)
             return Promise.reject(signal.reason);
@@ -94,43 +71,38 @@ export function sleep(ms, signal) {
             signal?.removeEventListener('abort', onAbort);
             resolve();
         }, ms);
+        if (opts?.unref && typeof timer.unref === 'function') {
+            timer.unref();
+        }
         const onAbort = () => {
             clearTimeout(timer);
             reject(signal.reason);
         };
-        signal?.addEventListener('abort', onAbort, { once: true });
+        signal?.addEventListener('abort', onAbort);
     });
 }
-/**
- * True if `err` is an `AbortError` (DOMException name or Error name).
- *
- * The default `shouldRetry` predicate uses this to skip retrying on
- * cancellations — if the caller aborted, retrying would just abort again.
- */
 export function isAbortError(err) {
     if (err == null || typeof err !== 'object')
         return false;
+    if (err.code === 'ACTLY_ABORT')
+        return true;
     const name = err.name;
-    return name === 'AbortError' || name === 'TimeoutError' &&
+    if (name === 'AbortError')
+        return true;
+    if (name === 'TimeoutError' &&
         err instanceof Error &&
-        // DOMException with name 'TimeoutError' is what AbortSignal.timeout throws.
-        // Distinguish from our own TimeoutError class by checking for DOMException.
         typeof DOMException !== 'undefined' &&
-        err instanceof DOMException;
+        err instanceof DOMException) {
+        return true;
+    }
+    return false;
 }
-/**
- * Link a parent signal to a child controller: when the parent aborts, the
- * child is aborted with the same reason. No-op if the parent is already
- * aborted (the caller should check `parent.aborted` separately if it cares
- * about synchronous abort).
- *
- * The listener is `{ once: true }` — no leak.
- */
 export function linkSignal(parent, child) {
     if (parent.aborted) {
         child.abort(parent.reason);
-        return;
+        return () => { };
     }
-    parent.addEventListener('abort', () => child.abort(parent.reason), { once: true });
+    const onAbort = () => child.abort(parent.reason);
+    parent.addEventListener('abort', onAbort);
+    return () => parent.removeEventListener('abort', onAbort);
 }
-//# sourceMappingURL=abort.js.map

package/dist/utils/abortPool.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.acquireController = acquireController;
+exports.releaseController = releaseController;
+exports.poolSize = poolSize;
+const pool = [];
+const MAX_POOL_SIZE = 64;
+function acquireController() {
+    while (pool.length > 0) {
+        const c = pool.pop();
+        if (!c.signal.aborted)
+            return c;
+    }
+    return new AbortController();
+}
+function releaseController(c) {
+    if (c.signal.aborted)
+        return;
+    if (pool.length >= MAX_POOL_SIZE)
+        return;
+    pool.push(c);
+}
+function poolSize() {
+    return pool.length;
+}

package/dist/utils/abortPool.d.ts

@@ -0,0 +1,4 @@
+export declare function acquireController(): AbortController;
+export declare function releaseController(c: AbortController): void;
+export declare function poolSize(): number;
+//# sourceMappingURL=abortPool.d.ts.map

package/dist/utils/abortPool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abortPool.d.ts","sourceRoot":"","sources":["../../src/utils/abortPool.ts"],"names":[],"mappings":"AAMA,wBAAgB,iBAAiB,IAAI,eAAe,CAOnD;AAED,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,eAAe,GAAG,IAAI,CAK1D;AAED,wBAAgB,QAAQ,IAAI,MAAM,CAEjC"}

package/dist/utils/abortPool.js

@@ -0,0 +1,20 @@
+const pool = [];
+const MAX_POOL_SIZE = 64;
+export function acquireController() {
+    while (pool.length > 0) {
+        const c = pool.pop();
+        if (!c.signal.aborted)
+            return c;
+    }
+    return new AbortController();
+}
+export function releaseController(c) {
+    if (c.signal.aborted)
+        return;
+    if (pool.length >= MAX_POOL_SIZE)
+        return;
+    pool.push(c);
+}
+export function poolSize() {
+    return pool.length;
+}

package/dist/utils/backoff.cjs

@@ -1,22 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.computeDelay = computeDelay;
-/**
- * Compute the delay before the next retry attempt, applying backoff, cap, and
- * jitter in that order.
- *
- * Order matters:
- *  1. `backoff` grows the base delay geometrically/linearly.
- *  2. `maxDelay` caps the result (prevents exponential blowup).
- *  3. `jitter` randomises within `[0, delay]` (prevents thundering herd).
- *
- * Returns 0 if `delayMs` is 0 or undefined — skipping the sleep entirely.
- */
 function computeDelay(attempt, opts) {
     const base = opts.delayMs ?? 0;
     if (base === 0)
         return 0;
-    // Step 1: backoff
     let delay;
     switch (opts.backoff ?? 'none') {
         case 'linear':
@@ -27,17 +15,22 @@ function computeDelay(attempt, opts) {
             break;
         default: delay = base;
     }
-    // Step 2: cap (guard against Infinity and NaN before Math.min)
     const max = opts.maxDelay ?? Number.POSITIVE_INFINITY;
     if (!Number.isFinite(delay))
         delay = max;
     delay = Math.min(delay, max);
-    // Step 3: jitter
     switch (opts.jitter ?? 'full') {
         case 'none': return delay;
         case 'full': return Math.random() * delay;
         case 'equal': return delay / 2 + Math.random() * delay / 2;
-        case 'decorrelated': return base + Math.random() * (delay - base);
+        case 'decorrelated': {
+            if (delay < base)
+                return Math.random() * delay;
+            const lo = base;
+            const hi = delay;
+            const result = lo + Math.random() * (hi - lo);
+            return Math.max(0, Math.min(result, delay));
+        }
         default: return delay;
     }
 }

package/dist/utils/backoff.d.ts

@@ -1,14 +1,3 @@
 import type { RetryOptions } from '../types/index.js';
-/**
- * Compute the delay before the next retry attempt, applying backoff, cap, and
- * jitter in that order.
- *
- * Order matters:
- *  1. `backoff` grows the base delay geometrically/linearly.
- *  2. `maxDelay` caps the result (prevents exponential blowup).
- *  3. `jitter` randomises within `[0, delay]` (prevents thundering herd).
- *
- * Returns 0 if `delayMs` is 0 or undefined — skipping the sleep entirely.
- */
 export declare function computeDelay(attempt: number, opts: RetryOptions): number;
 //# sourceMappingURL=backoff.d.ts.map

package/dist/utils/backoff.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"backoff.d.ts","sourceRoot":"","sources":["../../src/utils/backoff.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAErD;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,GAAG,MAAM,CAyBxE"}
+{"version":3,"file":"backoff.d.ts","sourceRoot":"","sources":["../../src/utils/backoff.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AASrD,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,GAAG,MAAM,CAgCxE"}

package/dist/utils/backoff.js

@@ -1,19 +1,7 @@
-/**
- * Compute the delay before the next retry attempt, applying backoff, cap, and
- * jitter in that order.
- *
- * Order matters:
- *  1. `backoff` grows the base delay geometrically/linearly.
- *  2. `maxDelay` caps the result (prevents exponential blowup).
- *  3. `jitter` randomises within `[0, delay]` (prevents thundering herd).
- *
- * Returns 0 if `delayMs` is 0 or undefined — skipping the sleep entirely.
- */
 export function computeDelay(attempt, opts) {
     const base = opts.delayMs ?? 0;
     if (base === 0)
         return 0;
-    // Step 1: backoff
     let delay;
     switch (opts.backoff ?? 'none') {
         case 'linear':
@@ -24,18 +12,22 @@ export function computeDelay(attempt, opts) {
             break;
         default: delay = base;
     }
-    // Step 2: cap (guard against Infinity and NaN before Math.min)
     const max = opts.maxDelay ?? Number.POSITIVE_INFINITY;
     if (!Number.isFinite(delay))
         delay = max;
     delay = Math.min(delay, max);
-    // Step 3: jitter
     switch (opts.jitter ?? 'full') {
         case 'none': return delay;
         case 'full': return Math.random() * delay;
         case 'equal': return delay / 2 + Math.random() * delay / 2;
-        case 'decorrelated': return base + Math.random() * (delay - base);
+        case 'decorrelated': {
+            if (delay < base)
+                return Math.random() * delay;
+            const lo = base;
+            const hi = delay;
+            const result = lo + Math.random() * (hi - lo);
+            return Math.max(0, Math.min(result, delay));
+        }
         default: return delay;
     }
 }
-//# sourceMappingURL=backoff.js.map

package/dist/utils/decorator.cjs

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePolicy = usePolicy;
+function usePolicy(options) {
+    return function (_target, propertyKey, descriptor) {
+        if (!descriptor || !descriptor.value) {
+            throw new Error(`Actly: @usePolicy can only be applied to methods with a function value. ` +
+                `Got descriptor without value for property "${String(propertyKey)}".`);
+        }
+        const originalMethod = descriptor.value;
+        let actPromise;
+        const getAct = () => {
+            if (!actPromise)
+                actPromise = Promise.resolve().then(() => require('../core/act.js')).then(m => m.act);
+            return actPromise;
+        };
+        const wrappedMethod = async function (...args) {
+            const act = await getAct();
+            const ctorName = this?.constructor?.name ?? 'Anonymous';
+            const key = `${ctorName}.${String(propertyKey)}`;
+            const firstArg = args[0];
+            const isSignal = firstArg != null &&
+                typeof firstArg === 'object' &&
+                typeof firstArg.aborted === 'boolean' &&
+                typeof firstArg.addEventListener === 'function';
+            const signal = isSignal ? firstArg : undefined;
+            const fnArgs = signal ? args.slice(1) : args;
+            const result = await act(key, async (actSignal) => originalMethod.apply(this, [actSignal, ...fnArgs]), signal ? { ...options, signal } : options);
+            if (result.ok)
+                return result.value;
+            throw result.error;
+        };
+        try {
+            Object.defineProperty(wrappedMethod, 'name', {
+                value: typeof propertyKey === 'symbol' ? propertyKey.description ?? 'wrapped' : propertyKey,
+                configurable: true,
+            });
+        }
+        catch {
+        }
+        descriptor.value = wrappedMethod;
+        return descriptor;
+    };
+}

package/dist/utils/decorator.d.ts

@@ -0,0 +1,3 @@
+import type { ActOptions } from '../types/index.js';
+export declare function usePolicy(options: ActOptions): MethodDecorator;
+//# sourceMappingURL=decorator.d.ts.map

package/dist/utils/decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorator.d.ts","sourceRoot":"","sources":["../../src/utils/decorator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,mBAAmB,CAAA;AA0B9D,wBAAgB,SAAS,CAAC,OAAO,EAAE,UAAU,GAAG,eAAe,CAoE9D"}

package/dist/utils/decorator.js

@@ -0,0 +1,41 @@
+export function usePolicy(options) {
+    return function (_target, propertyKey, descriptor) {
+        if (!descriptor || !descriptor.value) {
+            throw new Error(`Actly: @usePolicy can only be applied to methods with a function value. ` +
+                `Got descriptor without value for property "${String(propertyKey)}".`);
+        }
+        const originalMethod = descriptor.value;
+        let actPromise;
+        const getAct = () => {
+            if (!actPromise)
+                actPromise = import('../core/act.js').then(m => m.act);
+            return actPromise;
+        };
+        const wrappedMethod = async function (...args) {
+            const act = await getAct();
+            const ctorName = this?.constructor?.name ?? 'Anonymous';
+            const key = `${ctorName}.${String(propertyKey)}`;
+            const firstArg = args[0];
+            const isSignal = firstArg != null &&
+                typeof firstArg === 'object' &&
+                typeof firstArg.aborted === 'boolean' &&
+                typeof firstArg.addEventListener === 'function';
+            const signal = isSignal ? firstArg : undefined;
+            const fnArgs = signal ? args.slice(1) : args;
+            const result = await act(key, async (actSignal) => originalMethod.apply(this, [actSignal, ...fnArgs]), signal ? { ...options, signal } : options);
+            if (result.ok)
+                return result.value;
+            throw result.error;
+        };
+        try {
+            Object.defineProperty(wrappedMethod, 'name', {
+                value: typeof propertyKey === 'symbol' ? propertyKey.description ?? 'wrapped' : propertyKey,
+                configurable: true,
+            });
+        }
+        catch {
+        }
+        descriptor.value = wrappedMethod;
+        return descriptor;
+    };
+}

package/dist/utils/key.cjs

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeKey = sanitizeKey;
+const limits_js_1 = require("./limits.js");
+const RESERVED_PREFIXES = ['dedupe:', 'cache:', 'inflight:', 'tenant:'];
+const FORBIDDEN_LITERALS = new Set([
+    '__proto__',
+    'constructor',
+    'prototype',
+    'hasOwnProperty',
+    'toString',
+    'valueOf',
+    'isPrototypeOf',
+    'propertyIsEnumerable',
+    'toLocaleString',
+]);
+const UNSAFE_CHAR = /[\x00-\x08\x0b\x0c\x0d\x0e-\x1f\x7f]/;
+function sanitizeKey(key) {
+    if (typeof key !== 'string') {
+        throw new TypeError(`Actly: key must be a string, got ${key === null ? 'null' : typeof key}`);
+    }
+    if (key.length === 0) {
+        throw new RangeError("Actly: key must be non-empty. An empty key collapses every caller " +
+            "onto the same dedupe/cache slot — almost certainly a bug.");
+    }
+    if (key.length > limits_js_1.LIMITS.MAX_KEY_LENGTH) {
+        throw new RangeError(`Actly: key length ${key.length} exceeds limit ${limits_js_1.LIMITS.MAX_KEY_LENGTH}. ` +
+            `Long keys bloat stores and slow iteration. Hash externally if you need longer keys.`);
+    }
+    if (FORBIDDEN_LITERALS.has(key)) {
+        throw new RangeError(`Actly: key ${JSON.stringify(key)} is forbidden (prototype-pollution vector). ` +
+            `Pick a different key.`);
+    }
+    if (UNSAFE_CHAR.test(key)) {
+        throw new RangeError(`Actly: key contains control characters or CRLF, which break store backends ` +
+            `and log serializers. Got ${JSON.stringify(key)}.`);
+    }
+    for (const prefix of RESERVED_PREFIXES) {
+        if (key.startsWith(prefix)) {
+            throw new RangeError(`Actly: key must not start with reserved prefix "${prefix}" ` +
+                `(got ${JSON.stringify(key)}). These namespaces are used internally.`);
+        }
+    }
+    return key;
+}

package/dist/utils/key.d.ts

@@ -0,0 +1,2 @@
+export declare function sanitizeKey(key: string): string;
+//# sourceMappingURL=key.d.ts.map

package/dist/utils/key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"key.d.ts","sourceRoot":"","sources":["../../src/utils/key.ts"],"names":[],"mappings":"AAwCA,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAqC/C"}

package/dist/utils/key.js

@@ -0,0 +1,42 @@
+import { LIMITS } from './limits.js';
+const RESERVED_PREFIXES = ['dedupe:', 'cache:', 'inflight:', 'tenant:'];
+const FORBIDDEN_LITERALS = new Set([
+    '__proto__',
+    'constructor',
+    'prototype',
+    'hasOwnProperty',
+    'toString',
+    'valueOf',
+    'isPrototypeOf',
+    'propertyIsEnumerable',
+    'toLocaleString',
+]);
+const UNSAFE_CHAR = /[\x00-\x08\x0b\x0c\x0d\x0e-\x1f\x7f]/;
+export function sanitizeKey(key) {
+    if (typeof key !== 'string') {
+        throw new TypeError(`Actly: key must be a string, got ${key === null ? 'null' : typeof key}`);
+    }
+    if (key.length === 0) {
+        throw new RangeError("Actly: key must be non-empty. An empty key collapses every caller " +
+            "onto the same dedupe/cache slot — almost certainly a bug.");
+    }
+    if (key.length > LIMITS.MAX_KEY_LENGTH) {
+        throw new RangeError(`Actly: key length ${key.length} exceeds limit ${LIMITS.MAX_KEY_LENGTH}. ` +
+            `Long keys bloat stores and slow iteration. Hash externally if you need longer keys.`);
+    }
+    if (FORBIDDEN_LITERALS.has(key)) {
+        throw new RangeError(`Actly: key ${JSON.stringify(key)} is forbidden (prototype-pollution vector). ` +
+            `Pick a different key.`);
+    }
+    if (UNSAFE_CHAR.test(key)) {
+        throw new RangeError(`Actly: key contains control characters or CRLF, which break store backends ` +
+            `and log serializers. Got ${JSON.stringify(key)}.`);
+    }
+    for (const prefix of RESERVED_PREFIXES) {
+        if (key.startsWith(prefix)) {
+            throw new RangeError(`Actly: key must not start with reserved prefix "${prefix}" ` +
+                `(got ${JSON.stringify(key)}). These namespaces are used internally.`);
+        }
+    }
+    return key;
+}

package/dist/utils/limits.cjs

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIMITS = void 0;
+exports.LIMITS = Object.freeze({
+    MAX_KEY_LENGTH: 1024,
+    MAX_RETRY_ATTEMPTS: 100,
+    MAX_TIMEOUT_MS: 100_000_000,
+    MAX_CACHE_TTL: 86_400_000,
+    MAX_RETRY_DELAY_MS: 300_000,
+    MAX_INFLIGHT_TTL: 86_400_000,
+    DEFAULT_INFLIGHT_TTL: 5 * 60_000,
+    DEFAULT_STORE_MAX_SIZE: 10_000,
+    DEFAULT_STORE_CLEANUP_INTERVAL_MS: 60_000,
+    MAX_GLOBAL_INFLIGHT: 100_000,
+    MAX_CIRCUIT_BREAKER_WINDOW: 1_000_000,
+    MAX_BULKHEAD_CONCURRENCY: 1_000_000,
+    MAX_BULKHEAD_QUEUE: 1_000_000,
+    MAX_RATE_LIMIT_CALLS: 1_000_000,
+    MAX_SANITIZED_ERROR_LENGTH: 8_192,
+    MAX_HEDGE_DELAY_MS: 300_000,
+    MAX_TENANTS: 10_000,
+});

package/dist/utils/limits.d.ts

@@ -0,0 +1,21 @@
+export declare const LIMITS: Readonly<{
+    MAX_KEY_LENGTH: 1024;
+    MAX_RETRY_ATTEMPTS: 100;
+    MAX_TIMEOUT_MS: 100000000;
+    MAX_CACHE_TTL: 86400000;
+    MAX_RETRY_DELAY_MS: 300000;
+    MAX_INFLIGHT_TTL: 86400000;
+    DEFAULT_INFLIGHT_TTL: number;
+    DEFAULT_STORE_MAX_SIZE: 10000;
+    DEFAULT_STORE_CLEANUP_INTERVAL_MS: 60000;
+    MAX_GLOBAL_INFLIGHT: 100000;
+    MAX_CIRCUIT_BREAKER_WINDOW: 1000000;
+    MAX_BULKHEAD_CONCURRENCY: 1000000;
+    MAX_BULKHEAD_QUEUE: 1000000;
+    MAX_RATE_LIMIT_CALLS: 1000000;
+    MAX_SANITIZED_ERROR_LENGTH: 8192;
+    MAX_HEDGE_DELAY_MS: 300000;
+    MAX_TENANTS: 10000;
+}>;
+export type Limits = typeof LIMITS;
+//# sourceMappingURL=limits.d.ts.map

package/dist/utils/limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"limits.d.ts","sourceRoot":"","sources":["../../src/utils/limits.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;EA8EjB,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAA"}

package/dist/utils/limits.js

@@ -0,0 +1,19 @@
+export const LIMITS = Object.freeze({
+    MAX_KEY_LENGTH: 1024,
+    MAX_RETRY_ATTEMPTS: 100,
+    MAX_TIMEOUT_MS: 100_000_000,
+    MAX_CACHE_TTL: 86_400_000,
+    MAX_RETRY_DELAY_MS: 300_000,
+    MAX_INFLIGHT_TTL: 86_400_000,
+    DEFAULT_INFLIGHT_TTL: 5 * 60_000,
+    DEFAULT_STORE_MAX_SIZE: 10_000,
+    DEFAULT_STORE_CLEANUP_INTERVAL_MS: 60_000,
+    MAX_GLOBAL_INFLIGHT: 100_000,
+    MAX_CIRCUIT_BREAKER_WINDOW: 1_000_000,
+    MAX_BULKHEAD_CONCURRENCY: 1_000_000,
+    MAX_BULKHEAD_QUEUE: 1_000_000,
+    MAX_RATE_LIMIT_CALLS: 1_000_000,
+    MAX_SANITIZED_ERROR_LENGTH: 8_192,
+    MAX_HEDGE_DELAY_MS: 300_000,
+    MAX_TENANTS: 10_000,
+});

package/dist/utils/safeCall.cjs

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeCall = safeCall;
+const IS_DEV = typeof process !== 'undefined' &&
+    typeof process.env === 'object' &&
+    process.env !== null &&
+    process.env.NODE_ENV !== 'production';
+function safeCall(fn, ...args) {
+    if (!fn)
+        return;
+    try {
+        const result = fn(...args);
+        if (result !== null && result !== undefined && typeof result.then === 'function') {
+            Promise.resolve(result).catch((err) => {
+                if (IS_DEV) {
+                    console.warn('Actly: async observability hook rejected — error swallowed to protect main path. ' +
+                        'Fix the hook to prevent silent observability loss.', err);
+                }
+            });
+        }
+    }
+    catch (err) {
+        if (IS_DEV) {
+            console.warn('Actly: observability hook threw — error swallowed to protect main path. ' +
+                'Fix the hook to prevent silent observability loss.', err);
+        }
+    }
+}

package/dist/utils/safeCall.d.ts

@@ -0,0 +1,2 @@
+export declare function safeCall<T extends unknown[]>(fn: ((...args: T) => void) | undefined, ...args: T): void;
+//# sourceMappingURL=safeCall.d.ts.map

package/dist/utils/safeCall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safeCall.d.ts","sourceRoot":"","sources":["../../src/utils/safeCall.ts"],"names":[],"mappings":"AAkBA,wBAAgB,QAAQ,CAAC,CAAC,SAAS,OAAO,EAAE,EAC1C,EAAE,EAAE,CAAC,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC,GAAG,SAAS,EACtC,GAAG,IAAI,EAAE,CAAC,GACT,IAAI,CA2BN"}