actly 1.2.0 → 1.3.0

package/dist/core/shutdown.js

@@ -17,16 +17,21 @@ export function unregisterDrainable(scope = 'default') {
         for (const r of s.resolvers)
             r();
         s.resolvers = [];
+        if (scope !== 'default') {
+            drainStates.delete(scope);
+        }
     }
 }
-/**
- * Wait for all in-flight act() calls in this scope to settle.
- * Returns true if all settled within timeoutMs, false if timed out.
- */
 export async function drain(timeoutMs, scope = 'default') {
-    const s = getState(scope);
-    if (s.inflight === 0)
+    const s = drainStates.get(scope);
+    if (!s)
+        return true;
+    if (s.inflight === 0) {
+        if (scope !== 'default' && s.resolvers.length === 0) {
+            drainStates.delete(scope);
+        }
         return true;
+    }
     return new Promise((resolve) => {
         let resolved = false;
         const resolver = () => {
@@ -34,7 +39,6 @@ export async function drain(timeoutMs, scope = 'default') {
                 return;
             resolved = true;
             clearTimeout(timer);
-            // Remove this resolver from the array
             const idx = s.resolvers.indexOf(resolver);
             if (idx >= 0)
                 s.resolvers.splice(idx, 1);
@@ -44,7 +48,6 @@ export async function drain(timeoutMs, scope = 'default') {
             if (resolved)
                 return;
             resolved = true;
-            // Remove this resolver from the array on timeout
             const idx = s.resolvers.indexOf(resolver);
             if (idx >= 0)
                 s.resolvers.splice(idx, 1);
@@ -53,4 +56,10 @@ export async function drain(timeoutMs, scope = 'default') {
         s.resolvers.push(resolver);
     });
 }
-//# sourceMappingURL=shutdown.js.map
+export async function drainAll(timeoutMs) {
+    const scopes = Array.from(drainStates.keys());
+    if (scopes.length === 0)
+        return true;
+    const results = await Promise.all(scopes.map(scope => drain(timeoutMs, scope)));
+    return results.every(r => r === true);
+}

package/dist/core/tenant.cjs

@@ -5,25 +5,37 @@ exports.createAsyncTenantStore = createAsyncTenantStore;
 const memory_js_1 = require("../stores/memory.js");
 const act_js_1 = require("./act.js");
 const limits_js_1 = require("../utils/limits.js");
-/**
- * Manages per-tenant stores for multi-tenant isolation.
- * Each tenant gets its own InMemoryStore — cache/dedupe entries
- * cannot leak across tenants.
- */
 function createTenantStore(options = {}) {
     const maxSize = options.maxSize ?? limits_js_1.LIMITS.DEFAULT_STORE_MAX_SIZE;
     const autoCleanup = options.autoCleanup ?? true;
     const cleanupIntervalMs = options.cleanupIntervalMs ?? 60_000;
+    const maxTenants = options.maxTenants ?? limits_js_1.LIMITS.MAX_TENANTS;
     const tenants = new Map();
     return {
         get(tenantId) {
             let entry = tenants.get(tenantId);
-            if (!entry) {
-                const store = new memory_js_1.InMemoryStore({ maxSize, autoCleanup, cleanupIntervalMs });
-                const scoped = (0, act_js_1.withStore)(store);
-                entry = { store, scoped };
+            if (entry) {
+                tenants.delete(tenantId);
                 tenants.set(tenantId, entry);
+                return entry.scoped;
+            }
+            if (maxTenants !== Number.POSITIVE_INFINITY && tenants.size >= maxTenants) {
+                const lruId = tenants.keys().next().value;
+                if (lruId !== undefined) {
+                    const lru = tenants.get(lruId);
+                    if (lru) {
+                        try {
+                            lru.store.destroy();
+                        }
+                        catch { }
+                    }
+                    tenants.delete(lruId);
+                }
             }
+            const store = new memory_js_1.InMemoryStore({ maxSize, autoCleanup, cleanupIntervalMs });
+            const scoped = (0, act_js_1.withStore)(store);
+            entry = { store, scoped };
+            tenants.set(tenantId, entry);
             return entry.scoped;
         },
         evict(tenantId) {
@@ -44,28 +56,58 @@ function createTenantStore(options = {}) {
         },
     };
 }
-/**
- * Async tenant manager for async stores (Redis, DynamoDB, etc).
- * Each tenant gets its own store instance with prefixed keys.
- */
-function createAsyncTenantStore(storeFactory) {
+function createAsyncTenantStore(storeFactory, options = {}) {
+    const maxTenants = options.maxTenants ?? limits_js_1.LIMITS.MAX_TENANTS;
     const tenants = new Map();
+    const safeDestroy = (store) => {
+        try {
+            const result = store.destroy?.();
+            if (result && typeof result.then === 'function') {
+                ;
+                result.catch(() => { });
+            }
+        }
+        catch {
+        }
+    };
     return {
         get(tenantId) {
             let entry = tenants.get(tenantId);
-            if (!entry) {
-                const store = storeFactory(tenantId);
-                const scoped = (0, act_js_1.withStore)(store);
-                entry = { store, scoped };
+            if (entry) {
+                tenants.delete(tenantId);
                 tenants.set(tenantId, entry);
+                return entry.scoped;
             }
+            if (maxTenants !== Number.POSITIVE_INFINITY && tenants.size >= maxTenants) {
+                const lruId = tenants.keys().next().value;
+                if (lruId !== undefined) {
+                    const lru = tenants.get(lruId);
+                    if (lru)
+                        safeDestroy(lru.store);
+                    tenants.delete(lruId);
+                }
+            }
+            const store = storeFactory(tenantId);
+            const scoped = (0, act_js_1.withStore)(store);
+            entry = { store, scoped };
+            tenants.set(tenantId, entry);
             return entry.scoped;
         },
         evict(tenantId) {
-            tenants.delete(tenantId);
+            const entry = tenants.get(tenantId);
+            if (entry) {
+                safeDestroy(entry.store);
+                tenants.delete(tenantId);
+            }
         },
         size() {
             return tenants.size;
         },
+        destroy() {
+            for (const [, entry] of tenants) {
+                safeDestroy(entry.store);
+            }
+            tenants.clear();
+        },
     };
 }

package/dist/core/tenant.d.ts

@@ -4,6 +4,7 @@ export interface TenantStoreOptions {
     maxSize?: number;
     autoCleanup?: boolean;
     cleanupIntervalMs?: number;
+    maxTenants?: number;
 }
 export interface TenantManager {
     get(tenantId: string): ScopedActSync | ScopedActAsync;
@@ -11,19 +12,13 @@ export interface TenantManager {
     size(): number;
     destroy(): void;
 }
-/**
- * Manages per-tenant stores for multi-tenant isolation.
- * Each tenant gets its own InMemoryStore — cache/dedupe entries
- * cannot leak across tenants.
- */
 export declare function createTenantStore(options?: TenantStoreOptions): TenantManager;
-/**
- * Async tenant manager for async stores (Redis, DynamoDB, etc).
- * Each tenant gets its own store instance with prefixed keys.
- */
-export declare function createAsyncTenantStore(storeFactory: (tenantId: string) => AsyncStateStore): {
+export declare function createAsyncTenantStore(storeFactory: (tenantId: string) => AsyncStateStore, options?: {
+    maxTenants?: number;
+}): {
     get: (tenantId: string) => ScopedActAsync;
     evict: (tenantId: string) => void;
     size: () => number;
+    destroy: () => void;
 };
 //# sourceMappingURL=tenant.d.ts.map

package/dist/core/tenant.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tenant.d.ts","sourceRoot":"","sources":["../../src/core/tenant.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAE7D,OAAO,KAAK,EAAkB,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAGxE,MAAM,WAAW,kBAAkB;IACjC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B;AAED,MAAM,WAAW,aAAa;IAC5B,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,aAAa,GAAG,cAAc,CAAA;IACrD,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,IAAI,IAAI,MAAM,CAAA;IACd,OAAO,IAAI,IAAI,CAAA;CAChB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,kBAAuB,GAAG,aAAa,CAsCjF;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,eAAe,GAClD;IACD,GAAG,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,cAAc,CAAA;IACzC,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;IACjC,IAAI,EAAE,MAAM,MAAM,CAAA;CACnB,CAuBA"}
+{"version":3,"file":"tenant.d.ts","sourceRoot":"","sources":["../../src/core/tenant.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAC7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAGxD,MAAM,WAAW,kBAAkB;IACjC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAa1B,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,WAAW,aAAa;IAC5B,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,aAAa,GAAG,cAAc,CAAA;IACrD,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,IAAI,IAAI,MAAM,CAAA;IACd,OAAO,IAAI,IAAI,CAAA;CAChB;AAWD,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,kBAAuB,GAAG,aAAa,CAwDjF;AAOD,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,eAAe,EACnD,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAO,GACpC;IACD,GAAG,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,cAAc,CAAA;IACzC,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;IACjC,IAAI,EAAE,MAAM,MAAM,CAAA;IAClB,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB,CAkEA"}

package/dist/core/tenant.js

@@ -1,25 +1,37 @@
 import { InMemoryStore } from '../stores/memory.js';
 import { withStore } from './act.js';
 import { LIMITS } from '../utils/limits.js';
-/**
- * Manages per-tenant stores for multi-tenant isolation.
- * Each tenant gets its own InMemoryStore — cache/dedupe entries
- * cannot leak across tenants.
- */
 export function createTenantStore(options = {}) {
     const maxSize = options.maxSize ?? LIMITS.DEFAULT_STORE_MAX_SIZE;
     const autoCleanup = options.autoCleanup ?? true;
     const cleanupIntervalMs = options.cleanupIntervalMs ?? 60_000;
+    const maxTenants = options.maxTenants ?? LIMITS.MAX_TENANTS;
     const tenants = new Map();
     return {
         get(tenantId) {
             let entry = tenants.get(tenantId);
-            if (!entry) {
-                const store = new InMemoryStore({ maxSize, autoCleanup, cleanupIntervalMs });
-                const scoped = withStore(store);
-                entry = { store, scoped };
+            if (entry) {
+                tenants.delete(tenantId);
                 tenants.set(tenantId, entry);
+                return entry.scoped;
+            }
+            if (maxTenants !== Number.POSITIVE_INFINITY && tenants.size >= maxTenants) {
+                const lruId = tenants.keys().next().value;
+                if (lruId !== undefined) {
+                    const lru = tenants.get(lruId);
+                    if (lru) {
+                        try {
+                            lru.store.destroy();
+                        }
+                        catch { }
+                    }
+                    tenants.delete(lruId);
+                }
             }
+            const store = new InMemoryStore({ maxSize, autoCleanup, cleanupIntervalMs });
+            const scoped = withStore(store);
+            entry = { store, scoped };
+            tenants.set(tenantId, entry);
             return entry.scoped;
         },
         evict(tenantId) {
@@ -40,29 +52,58 @@ export function createTenantStore(options = {}) {
         },
     };
 }
-/**
- * Async tenant manager for async stores (Redis, DynamoDB, etc).
- * Each tenant gets its own store instance with prefixed keys.
- */
-export function createAsyncTenantStore(storeFactory) {
+export function createAsyncTenantStore(storeFactory, options = {}) {
+    const maxTenants = options.maxTenants ?? LIMITS.MAX_TENANTS;
     const tenants = new Map();
+    const safeDestroy = (store) => {
+        try {
+            const result = store.destroy?.();
+            if (result && typeof result.then === 'function') {
+                ;
+                result.catch(() => { });
+            }
+        }
+        catch {
+        }
+    };
     return {
         get(tenantId) {
             let entry = tenants.get(tenantId);
-            if (!entry) {
-                const store = storeFactory(tenantId);
-                const scoped = withStore(store);
-                entry = { store, scoped };
+            if (entry) {
+                tenants.delete(tenantId);
                 tenants.set(tenantId, entry);
+                return entry.scoped;
             }
+            if (maxTenants !== Number.POSITIVE_INFINITY && tenants.size >= maxTenants) {
+                const lruId = tenants.keys().next().value;
+                if (lruId !== undefined) {
+                    const lru = tenants.get(lruId);
+                    if (lru)
+                        safeDestroy(lru.store);
+                    tenants.delete(lruId);
+                }
+            }
+            const store = storeFactory(tenantId);
+            const scoped = withStore(store);
+            entry = { store, scoped };
+            tenants.set(tenantId, entry);
             return entry.scoped;
         },
         evict(tenantId) {
-            tenants.delete(tenantId);
+            const entry = tenants.get(tenantId);
+            if (entry) {
+                safeDestroy(entry.store);
+                tenants.delete(tenantId);
+            }
         },
         size() {
             return tenants.size;
         },
+        destroy() {
+            for (const [, entry] of tenants) {
+                safeDestroy(entry.store);
+            }
+            tenants.clear();
+        },
     };
 }
-//# sourceMappingURL=tenant.js.map

package/dist/errors.cjs

@@ -1,35 +1,8 @@
 "use strict";
-/**
- * Actly error taxonomy.
- *
- * Six classes (one abstract base + five concrete). Each carries a stable
- * `code` field so consumers can switch on strings instead of brittle
- * `instanceof` chains across realm boundaries (e.g. errors serialised
- * over IPC).
- *
- * # Why these six?
- *
- *  - `ActlyError`         — abstract base for `instanceof ActlyError` checks
- *  - `ActlyAbortError`    — caller / signal cancellation
- *  - `TimeoutError`       — per-attempt deadline
- *  - `TotalTimeoutError`  — operation-wide budget
- *  - `RetryExhaustedError`— last attempt's error wrapped with context
- *  - `ValidationError`    — programmer error (invalid options)
- *
- * NO circuit/bulkhead/rate-limit errors — those policies don't exist in
- * core. Adding orphan error classes violates the "every feature must map
- * to a real runtime failure mode" rule.
- *
- * # `code` field
- *
- * Stable string identifier. Use this for switch statements and telemetry
- * tags. The class name can change across versions; `code` won't.
- */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RateLimitError = exports.BulkheadOverflowError = exports.CircuitBreakerOpenError = exports.ValidationError = exports.RetryExhaustedError = exports.TotalTimeoutError = exports.TimeoutError = exports.ActlyAbortError = exports.ActlyError = void 0;
-/** Base class for all actly errors. Enables `instanceof ActlyError` checks. */
+exports.HedgeTimeoutError = exports.ResourceExhaustedError = exports.RateLimitError = exports.BulkheadOverflowError = exports.CircuitBreakerOpenError = exports.ValidationError = exports.RetryExhaustedError = exports.TotalTimeoutError = exports.TimeoutError = exports.ActlyAbortError = exports.ActlyError = void 0;
+exports.isActlyError = isActlyError;
 class ActlyError extends Error {
-    /** The key associated with the failure, if applicable. */
     key;
     constructor(message, options) {
         super(message, options?.cause !== undefined ? { cause: options.cause } : undefined);
@@ -37,23 +10,49 @@ class ActlyError extends Error {
         if (options?.key !== undefined) {
             Object.defineProperty(this, 'key', { value: options.key, enumerable: true });
         }
-        // Restore prototype chain after Error inheritance (TS es2022 target
-        // may strip it). This ensures `instanceof` works correctly.
         Object.setPrototypeOf(this, new.target.prototype);
     }
+    toJSON(opts) {
+        const obj = {
+            name: this.name,
+            code: this.code,
+            message: opts?.redact ? sanitizeErrorMessageForJSON(this.message) : this.message,
+        };
+        if (this.key !== undefined)
+            obj.key = this.key;
+        if (this.stack !== undefined)
+            obj.stack = this.stack;
+        for (const prop of Object.keys(this)) {
+            if (!(prop in obj)) {
+                try {
+                    obj[prop] = this[prop];
+                }
+                catch {
+                }
+            }
+        }
+        return obj;
+    }
 }
 exports.ActlyError = ActlyError;
-/**
- * Thrown when the caller's signal, per-attempt timeout, or total timeout
- * aborts the operation.
- *
- * `cause` carries the original abort reason (e.g. user-supplied
- * `controller.abort(new Error('user-cancelled'))` → cause.message is
- * 'user-cancelled').
- *
- * Wraps the raw abort reason in a typed error so consumers can
- * `instanceof`-check it consistently across all abort sources.
- */
+function isActlyError(e) {
+    return (e != null &&
+        typeof e === 'object' &&
+        typeof e.code === 'string' &&
+        String(e.code).startsWith('ACTLY_'));
+}
+function sanitizeErrorMessageForJSON(msg) {
+    let str;
+    if (msg instanceof Error) {
+        str = String(msg.message ?? '');
+    }
+    else {
+        str = String(msg ?? '');
+    }
+    if (str.length > 4096)
+        str = str.slice(0, 4096) + '…[truncated]';
+    return str.replace(/[<>]/g, (c) => (c === '<' ? '&lt;' : '&gt;'));
+}
 class ActlyAbortError extends ActlyError {
     code = 'ACTLY_ABORT';
     constructor(options) {
@@ -62,17 +61,6 @@ class ActlyAbortError extends ActlyError {
     }
 }
 exports.ActlyAbortError = ActlyAbortError;
-/**
- * Thrown when a per-attempt `timeout` deadline fires.
- *
- * Carries the configured `ms` so callers can log/alert precisely:
- *
- * ```ts
- * if (!result.ok && result.error instanceof TimeoutError) {
- *   console.log(`attempt timed out after ${result.error.ms}ms`)
- * }
- * ```
- */
 class TimeoutError extends ActlyError {
     code = 'ACTLY_TIMEOUT';
     ms;
@@ -82,12 +70,6 @@ class TimeoutError extends ActlyError {
     }
 }
 exports.TimeoutError = TimeoutError;
-/**
- * Thrown when the operation-wide `totalTimeout` budget fires.
- *
- * Distinct from `TimeoutError` (per-attempt) so callers can `instanceof`-check
- * which deadline fired.
- */
 class TotalTimeoutError extends ActlyError {
     code = 'ACTLY_TOTAL_TIMEOUT';
     ms;
@@ -97,25 +79,6 @@ class TotalTimeoutError extends ActlyError {
     }
 }
 exports.TotalTimeoutError = TotalTimeoutError;
-/**
- * Thrown when all retry attempts are exhausted. The `lastError` is the
- * final attempt's error; `errors` is the array of all attempt errors
- * (useful for debugging patterns across retries).
- *
- * Wraps retry exhaustion with context so consumers can distinguish "single
- * fn error" from "retry exhausted after N attempts".
- *
- * # When is this thrown vs the raw error?
- *
- * `retryPolicy` throws `RetryExhaustedError` when:
- *  - `attempts > 1` AND
- *  - all attempts failed AND
- *  - the default `shouldRetry` (or user-supplied predicate) returned `true`
- *    for at least one failure
- *
- * If the user's `shouldRetry` returns `false` on the first attempt, the
- * raw error is thrown (no retries happened — not "exhausted").
- */
 class RetryExhaustedError extends ActlyError {
     code = 'ACTLY_RETRY_EXHAUSTED';
     attempts;
@@ -130,18 +93,10 @@ class RetryExhaustedError extends ActlyError {
     }
 }
 exports.RetryExhaustedError = RetryExhaustedError;
-/**
- * Thrown on invalid option shapes / keys / store contracts. Programmer
- * errors — these surface synchronously, NOT as `ActFailure`, because the
- * caller's code is broken.
- *
- * Wraps the underlying `TypeError` / `RangeError` so consumers catching
- * `ActlyError` get a consistent type for all actly-thrown errors.
- */
 class ValidationError extends ActlyError {
     code = 'ACTLY_VALIDATION';
     constructor(message, options) {
-        super(message);
+        super(message, options);
         if (options?.field !== undefined) {
             Object.defineProperty(this, 'field', { value: options.field, enumerable: true });
         }
@@ -149,34 +104,46 @@ class ValidationError extends ActlyError {
     field;
 }
 exports.ValidationError = ValidationError;
-// ─── Hardening error classes ─────────────────────────────────────────────────
-/** Thrown when a circuit breaker is open and blocks the call. */
 class CircuitBreakerOpenError extends ActlyError {
     code = 'ACTLY_CIRCUIT_OPEN';
-    key;
-    constructor(key, ms) {
-        super(`Circuit breaker open for key "${key}" — retry after ${ms}ms`);
-        this.key = key;
+    constructor(key, ms, options) {
+        super(`Circuit breaker open for key "${key}" — retry after ${ms}ms`, { key, cause: options?.cause });
     }
 }
 exports.CircuitBreakerOpenError = CircuitBreakerOpenError;
-/** Thrown when a bulkhead is full (maxConcurrent reached, queue timed out). */
 class BulkheadOverflowError extends ActlyError {
     code = 'ACTLY_BULKHEAD_FULL';
-    key;
-    constructor(key, maxConcurrent) {
-        super(`Bulkhead full for key "${key}" — maxConcurrent ${maxConcurrent} reached`);
-        this.key = key;
+    constructor(key, maxConcurrent, options) {
+        super(`Bulkhead full for key "${key}" — maxConcurrent ${maxConcurrent} reached`, { key, cause: options?.cause });
     }
 }
 exports.BulkheadOverflowError = BulkheadOverflowError;
-/** Thrown when a rate limit is exceeded. */
 class RateLimitError extends ActlyError {
     code = 'ACTLY_RATE_LIMIT';
-    key;
-    constructor(key, maxCalls, windowMs) {
-        super(`Rate limit exceeded for key "${key}" — ${maxCalls} calls per ${windowMs}ms`);
-        this.key = key;
+    constructor(key, maxCalls, windowMs, options) {
+        super(`Rate limit exceeded for key "${key}" — ${maxCalls} calls per ${windowMs}ms`, { key, cause: options?.cause });
     }
 }
 exports.RateLimitError = RateLimitError;
+class ResourceExhaustedError extends ActlyError {
+    code = 'ACTLY_RESOURCE_EXHAUSTED';
+    current;
+    limit;
+    constructor(current, limit, options) {
+        super(`Actly: resource exhausted — ${current} in-flight calls exceed process limit ${limit}. ` +
+            `Set ACTLY_NO_INFLIGHT_LIMIT=1 to disable this guard (at your own risk).`, options);
+        this.current = current;
+        this.limit = limit;
+    }
+}
+exports.ResourceExhaustedError = ResourceExhaustedError;
+class HedgeTimeoutError extends ActlyError {
+    code = 'ACTLY_HEDGE_TIMEOUT';
+    delayMs;
+    constructor(options) {
+        const ms = options?.delayMs ?? 0;
+        super(`ACT hedge timed out after ${ms}ms`, options);
+        this.delayMs = ms;
+    }
+}
+exports.HedgeTimeoutError = HedgeTimeoutError;