actly 1.1.5 → 1.3.0

package/dist/index.cjs

@@ -1,22 +1,65 @@
 "use strict";
-// ─── Primary API ──────────────────────────────────────────────────────────────
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TotalTimeoutError = exports.TimeoutError = exports.isAsyncStore = exports.isSyncStore = exports.InMemoryStore = exports.REQUIRES_SYNC_STORE = exports.execute = exports.withStore = exports.invalidate = exports.act = void 0;
+exports.usePolicy = exports.noopPolicy = exports.poolSize = exports.releaseController = exports.acquireController = exports.sanitizeError = exports.sanitizeErrorMessage = exports.createAsyncTenantStore = exports.createTenantStore = exports.drainAll = exports.drain = exports.disableWatchdog = exports.unregisterWatchdogHooks = exports.registerWatchdogHooks = exports.enableWatchdog = exports.createHealthCheck = exports.ResourceExhaustedError = exports.RateLimitError = exports.BulkheadOverflowError = exports.CircuitBreakerOpenError = exports.LIMITS = exports.computeDelay = exports.sanitizeKey = exports.isAbortError = exports.linkSignal = exports.sleep = exports.raceAbort = exports.anySignal = exports.isActlyError = exports.ValidationError = exports.RetryExhaustedError = exports.TotalTimeoutError = exports.TimeoutError = exports.ActlyAbortError = exports.ActlyError = exports.isAsyncStore = exports.isSyncStore = exports.InMemoryStore = exports.REQUIRES_SYNC_STORE = exports.execute = exports.HedgeTimeoutError = exports.withStore = exports.invalidate = exports.act = void 0;
 var act_js_1 = require("./core/act.js");
 Object.defineProperty(exports, "act", { enumerable: true, get: function () { return act_js_1.act; } });
 Object.defineProperty(exports, "invalidate", { enumerable: true, get: function () { return act_js_1.invalidate; } });
 Object.defineProperty(exports, "withStore", { enumerable: true, get: function () { return act_js_1.withStore; } });
-// ─── Execution engine (for custom policy chains) ──────────────────────────────
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "HedgeTimeoutError", { enumerable: true, get: function () { return errors_js_1.HedgeTimeoutError; } });
 var executor_js_1 = require("./core/executor.js");
 Object.defineProperty(exports, "execute", { enumerable: true, get: function () { return executor_js_1.execute; } });
 Object.defineProperty(exports, "REQUIRES_SYNC_STORE", { enumerable: true, get: function () { return executor_js_1.REQUIRES_SYNC_STORE; } });
-// ─── Stores ───────────────────────────────────────────────────────────────────
 var memory_js_1 = require("./stores/memory.js");
 Object.defineProperty(exports, "InMemoryStore", { enumerable: true, get: function () { return memory_js_1.InMemoryStore; } });
 var base_js_1 = require("./stores/base.js");
 Object.defineProperty(exports, "isSyncStore", { enumerable: true, get: function () { return base_js_1.isSyncStore; } });
 Object.defineProperty(exports, "isAsyncStore", { enumerable: true, get: function () { return base_js_1.isAsyncStore; } });
-// ─── Error classes ────────────────────────────────────────────────────────────
-var timeout_js_1 = require("./policies/timeout.js");
-Object.defineProperty(exports, "TimeoutError", { enumerable: true, get: function () { return timeout_js_1.TimeoutError; } });
-Object.defineProperty(exports, "TotalTimeoutError", { enumerable: true, get: function () { return timeout_js_1.TotalTimeoutError; } });
+var errors_js_2 = require("./errors.js");
+Object.defineProperty(exports, "ActlyError", { enumerable: true, get: function () { return errors_js_2.ActlyError; } });
+Object.defineProperty(exports, "ActlyAbortError", { enumerable: true, get: function () { return errors_js_2.ActlyAbortError; } });
+Object.defineProperty(exports, "TimeoutError", { enumerable: true, get: function () { return errors_js_2.TimeoutError; } });
+Object.defineProperty(exports, "TotalTimeoutError", { enumerable: true, get: function () { return errors_js_2.TotalTimeoutError; } });
+Object.defineProperty(exports, "RetryExhaustedError", { enumerable: true, get: function () { return errors_js_2.RetryExhaustedError; } });
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return errors_js_2.ValidationError; } });
+Object.defineProperty(exports, "isActlyError", { enumerable: true, get: function () { return errors_js_2.isActlyError; } });
+var abort_js_1 = require("./utils/abort.js");
+Object.defineProperty(exports, "anySignal", { enumerable: true, get: function () { return abort_js_1.anySignal; } });
+Object.defineProperty(exports, "raceAbort", { enumerable: true, get: function () { return abort_js_1.raceAbort; } });
+Object.defineProperty(exports, "sleep", { enumerable: true, get: function () { return abort_js_1.sleep; } });
+Object.defineProperty(exports, "linkSignal", { enumerable: true, get: function () { return abort_js_1.linkSignal; } });
+Object.defineProperty(exports, "isAbortError", { enumerable: true, get: function () { return abort_js_1.isAbortError; } });
+var key_js_1 = require("./utils/key.js");
+Object.defineProperty(exports, "sanitizeKey", { enumerable: true, get: function () { return key_js_1.sanitizeKey; } });
+var backoff_js_1 = require("./utils/backoff.js");
+Object.defineProperty(exports, "computeDelay", { enumerable: true, get: function () { return backoff_js_1.computeDelay; } });
+var limits_js_1 = require("./utils/limits.js");
+Object.defineProperty(exports, "LIMITS", { enumerable: true, get: function () { return limits_js_1.LIMITS; } });
+var errors_js_3 = require("./errors.js");
+Object.defineProperty(exports, "CircuitBreakerOpenError", { enumerable: true, get: function () { return errors_js_3.CircuitBreakerOpenError; } });
+Object.defineProperty(exports, "BulkheadOverflowError", { enumerable: true, get: function () { return errors_js_3.BulkheadOverflowError; } });
+Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return errors_js_3.RateLimitError; } });
+Object.defineProperty(exports, "ResourceExhaustedError", { enumerable: true, get: function () { return errors_js_3.ResourceExhaustedError; } });
+var health_js_1 = require("./core/health.js");
+Object.defineProperty(exports, "createHealthCheck", { enumerable: true, get: function () { return health_js_1.createHealthCheck; } });
+Object.defineProperty(exports, "enableWatchdog", { enumerable: true, get: function () { return health_js_1.enableWatchdog; } });
+Object.defineProperty(exports, "registerWatchdogHooks", { enumerable: true, get: function () { return health_js_1.registerWatchdogHooks; } });
+Object.defineProperty(exports, "unregisterWatchdogHooks", { enumerable: true, get: function () { return health_js_1.unregisterWatchdogHooks; } });
+Object.defineProperty(exports, "disableWatchdog", { enumerable: true, get: function () { return health_js_1.disableWatchdog; } });
+var shutdown_js_1 = require("./core/shutdown.js");
+Object.defineProperty(exports, "drain", { enumerable: true, get: function () { return shutdown_js_1.drain; } });
+Object.defineProperty(exports, "drainAll", { enumerable: true, get: function () { return shutdown_js_1.drainAll; } });
+var tenant_js_1 = require("./core/tenant.js");
+Object.defineProperty(exports, "createTenantStore", { enumerable: true, get: function () { return tenant_js_1.createTenantStore; } });
+Object.defineProperty(exports, "createAsyncTenantStore", { enumerable: true, get: function () { return tenant_js_1.createAsyncTenantStore; } });
+var sanitize_js_1 = require("./utils/sanitize.js");
+Object.defineProperty(exports, "sanitizeErrorMessage", { enumerable: true, get: function () { return sanitize_js_1.sanitizeErrorMessage; } });
+Object.defineProperty(exports, "sanitizeError", { enumerable: true, get: function () { return sanitize_js_1.sanitizeError; } });
+var abortPool_js_1 = require("./utils/abortPool.js");
+Object.defineProperty(exports, "acquireController", { enumerable: true, get: function () { return abortPool_js_1.acquireController; } });
+Object.defineProperty(exports, "releaseController", { enumerable: true, get: function () { return abortPool_js_1.releaseController; } });
+Object.defineProperty(exports, "poolSize", { enumerable: true, get: function () { return abortPool_js_1.poolSize; } });
+var noop_js_1 = require("./policies/noop.js");
+Object.defineProperty(exports, "noopPolicy", { enumerable: true, get: function () { return noop_js_1.noopPolicy; } });
+var decorator_js_1 = require("./utils/decorator.js");
+Object.defineProperty(exports, "usePolicy", { enumerable: true, get: function () { return decorator_js_1.usePolicy; } });

package/dist/index.d.ts

@@ -1,10 +1,29 @@
 export { act, invalidate, withStore, } from './core/act.js';
 export type { ScopedActSync, ScopedActAsync, } from './core/act.js';
+export { HedgeTimeoutError, } from './errors.js';
 export { execute, REQUIRES_SYNC_STORE, } from './core/executor.js';
+export type { ExecutorInput, } from './core/executor.js';
+export type { ObservabilityContext, } from './observability.js';
 export { InMemoryStore } from './stores/memory.js';
 export type { InMemoryStoreOptions } from './stores/memory.js';
 export { isSyncStore, isAsyncStore, } from './stores/base.js';
-export { TimeoutError, TotalTimeoutError, } from './policies/timeout.js';
-export type { ActFn, ActResult, ActSuccess, ActFailure, ActSource, ActOptions, RetryOptions, TimeoutOptions, DedupeOptions, CacheOptions, PolicyApplier, PolicyContext, RunMeta, StateStore, // v1.0 alias for SyncStateStore (zero breakage)
-SyncStateStore, AsyncStateStore, AnyStateStore, } from './types/index.js';
+export { ActlyError, ActlyAbortError, TimeoutError, TotalTimeoutError, RetryExhaustedError, ValidationError, isActlyError, } from './errors.js';
+export type { ActlyEventType, ActlyEventBase, AttemptEvent, RetryEvent, CacheHitEvent, CacheMissEvent, DedupeJoinEvent, TimeoutEvent, FinalSuccessEvent, FinalFailureEvent, BackpressureEvent, WatchdogEvent, ActlyEvent, ObservabilityHooks, } from './observability.js';
+export type { ActFn, ActResult, ActSuccess, ActFailure, ActSource, ActOptions, RetryOptions, TimeoutOptions, DedupeOptions, CacheOptions, PolicyApplier, PolicyContext, RunMeta, StateStore, SyncStateStore, AsyncStateStore, AnyStateStore, } from './types/index.js';
+export { anySignal, raceAbort, sleep, linkSignal, isAbortError, } from './utils/abort.js';
+export { sanitizeKey, } from './utils/key.js';
+export { computeDelay, } from './utils/backoff.js';
+export { LIMITS, } from './utils/limits.js';
+export type { Limits } from './utils/limits.js';
+export { CircuitBreakerOpenError, BulkheadOverflowError, RateLimitError, ResourceExhaustedError, } from './errors.js';
+export { createHealthCheck, enableWatchdog, registerWatchdogHooks, unregisterWatchdogHooks, disableWatchdog, } from './core/health.js';
+export type { HealthStatus, HealthCheckFn } from './core/health.js';
+export { drain, drainAll, } from './core/shutdown.js';
+export { createTenantStore, createAsyncTenantStore, } from './core/tenant.js';
+export type { TenantStoreOptions, TenantManager } from './core/tenant.js';
+export { sanitizeErrorMessage, sanitizeError, } from './utils/sanitize.js';
+export { acquireController, releaseController, poolSize, } from './utils/abortPool.js';
+export type { CircuitBreakerOptions, BulkheadOptions, RateLimitOptions, HedgeOptions, FallbackOptions, AuditOptions, AuditEntry, } from './types/index.js';
+export { noopPolicy, } from './policies/noop.js';
+export { usePolicy, } from './utils/decorator.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,GAAG,EACH,UAAU,EACV,SAAS,GACV,MAAM,eAAe,CAAA;AAEtB,YAAY,EACV,aAAa,EACb,cAAc,GACf,MAAM,eAAe,CAAA;AAItB,OAAO,EACL,OAAO,EACP,mBAAmB,GACpB,MAAM,oBAAoB,CAAA;AAI3B,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAClD,YAAY,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAE9D,OAAO,EACL,WAAW,EACX,YAAY,GACb,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EACL,YAAY,EACZ,iBAAiB,GAClB,MAAM,uBAAuB,CAAA;AAI9B,YAAY,EAEV,KAAK,EACL,SAAS,EACT,UAAU,EACV,UAAU,EACV,SAAS,EACT,UAAU,EAGV,YAAY,EACZ,cAAc,EACd,aAAa,EACb,YAAY,EAGZ,aAAa,EACb,aAAa,EACb,OAAO,EAGP,UAAU,EAAS,gDAAgD;AACnE,cAAc,EACd,eAAe,EACf,aAAa,GACd,MAAM,kBAAkB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,GAAG,EACH,UAAU,EACV,SAAS,GACV,MAAM,eAAe,CAAA;AAEtB,YAAY,EACV,aAAa,EACb,cAAc,GACf,MAAM,eAAe,CAAA;AAItB,OAAO,EACL,iBAAiB,GAClB,MAAM,aAAa,CAAA;AAIpB,OAAO,EACL,OAAO,EACP,mBAAmB,GACpB,MAAM,oBAAoB,CAAA;AAI3B,YAAY,EACV,aAAa,GACd,MAAM,oBAAoB,CAAA;AAI3B,YAAY,EACV,oBAAoB,GACrB,MAAM,oBAAoB,CAAA;AAI3B,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAClD,YAAY,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAE9D,OAAO,EACL,WAAW,EACX,YAAY,GACb,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EACL,UAAU,EACV,eAAe,EACf,YAAY,EACZ,iBAAiB,EACjB,mBAAmB,EACnB,eAAe,EACf,YAAY,GACb,MAAM,aAAa,CAAA;AAIpB,YAAY,EACV,cAAc,EACd,cAAc,EACd,YAAY,EACZ,UAAU,EACV,aAAa,EACb,cAAc,EACd,eAAe,EACf,YAAY,EACZ,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,aAAa,EACb,UAAU,EACV,kBAAkB,GACnB,MAAM,oBAAoB,CAAA;AAI3B,YAAY,EAEV,KAAK,EACL,SAAS,EACT,UAAU,EACV,UAAU,EACV,SAAS,EACT,UAAU,EAGV,YAAY,EACZ,cAAc,EACd,aAAa,EACb,YAAY,EAGZ,aAAa,EACb,aAAa,EACb,OAAO,EAGP,UAAU,EACV,cAAc,EACd,eAAe,EACf,aAAa,GACd,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EACL,SAAS,EACT,SAAS,EACT,KAAK,EACL,UAAU,EACV,YAAY,GACb,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EACL,WAAW,GACZ,MAAM,gBAAgB,CAAA;AAEvB,OAAO,EACL,YAAY,GACb,MAAM,oBAAoB,CAAA;AAE3B,OAAO,EACL,MAAM,GACP,MAAM,mBAAmB,CAAA;AAE1B,YAAY,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAI/C,OAAO,EACL,uBAAuB,EACvB,qBAAqB,EACrB,cAAc,EACd,sBAAsB,GACvB,MAAM,aAAa,CAAA;AAGpB,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,qBAAqB,EACrB,uBAAuB,EACvB,eAAe,GAChB,MAAM,kBAAkB,CAAA;AACzB,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAEnE,OAAO,EACL,KAAK,EACL,QAAQ,GACT,MAAM,oBAAoB,CAAA;AAI3B,OAAO,EACL,iBAAiB,EACjB,sBAAsB,GACvB,MAAM,kBAAkB,CAAA;AACzB,YAAY,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAIzE,OAAO,EACL,oBAAoB,EACpB,aAAa,GACd,MAAM,qBAAqB,CAAA;AAI5B,OAAO,EACL,iBAAiB,EACjB,iBAAiB,EACjB,QAAQ,GACT,MAAM,sBAAsB,CAAA;AAI7B,YAAY,EACV,qBAAqB,EACrB,eAAe,EACf,gBAAgB,EAChB,YAAY,EACZ,eAAe,EACf,YAAY,EACZ,UAAU,GACX,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EACL,UAAU,GACX,MAAM,oBAAoB,CAAA;AAI3B,OAAO,EACL,SAAS,GACV,MAAM,sBAAsB,CAAA"}

package/dist/index.js

@@ -1,10 +1,18 @@
-// ─── Primary API ──────────────────────────────────────────────────────────────
 export { act, invalidate, withStore, } from './core/act.js';
-// ─── Execution engine (for custom policy chains) ──────────────────────────────
+export { HedgeTimeoutError, } from './errors.js';
 export { execute, REQUIRES_SYNC_STORE, } from './core/executor.js';
-// ─── Stores ───────────────────────────────────────────────────────────────────
 export { InMemoryStore } from './stores/memory.js';
 export { isSyncStore, isAsyncStore, } from './stores/base.js';
-// ─── Error classes ────────────────────────────────────────────────────────────
-export { TimeoutError, TotalTimeoutError, } from './policies/timeout.js';
-//# sourceMappingURL=index.js.map
+export { ActlyError, ActlyAbortError, TimeoutError, TotalTimeoutError, RetryExhaustedError, ValidationError, isActlyError, } from './errors.js';
+export { anySignal, raceAbort, sleep, linkSignal, isAbortError, } from './utils/abort.js';
+export { sanitizeKey, } from './utils/key.js';
+export { computeDelay, } from './utils/backoff.js';
+export { LIMITS, } from './utils/limits.js';
+export { CircuitBreakerOpenError, BulkheadOverflowError, RateLimitError, ResourceExhaustedError, } from './errors.js';
+export { createHealthCheck, enableWatchdog, registerWatchdogHooks, unregisterWatchdogHooks, disableWatchdog, } from './core/health.js';
+export { drain, drainAll, } from './core/shutdown.js';
+export { createTenantStore, createAsyncTenantStore, } from './core/tenant.js';
+export { sanitizeErrorMessage, sanitizeError, } from './utils/sanitize.js';
+export { acquireController, releaseController, poolSize, } from './utils/abortPool.js';
+export { noopPolicy, } from './policies/noop.js';
+export { usePolicy, } from './utils/decorator.js';

package/dist/observability.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasObservers = hasObservers;
+function hasObservers(ctx) {
+    return ctx.observability != null;
+}

package/dist/observability.d.ts

@@ -0,0 +1,86 @@
+import type { ActSource, ActlyFailedBy } from './types/index.js';
+export type ActlyEventType = 'attempt' | 'retry' | 'cache-hit' | 'cache-miss' | 'dedupe-join' | 'timeout' | 'final-success' | 'final-failure' | 'backpressure' | 'watchdog';
+export interface ActlyEventBase {
+    readonly key: string;
+    readonly traceId: string;
+    readonly timestamp: number;
+    readonly type: ActlyEventType;
+}
+export interface AttemptEvent extends ActlyEventBase {
+    readonly type: 'attempt';
+    readonly attempt: number;
+    readonly durationMs?: number;
+    readonly error?: unknown;
+}
+export interface RetryEvent extends ActlyEventBase {
+    readonly type: 'retry';
+    readonly attempt: number;
+    readonly delayMs: number;
+    readonly error: unknown;
+}
+export interface CacheHitEvent extends ActlyEventBase {
+    readonly type: 'cache-hit';
+    readonly ageMs: number;
+}
+export interface CacheMissEvent extends ActlyEventBase {
+    readonly type: 'cache-miss';
+}
+export interface DedupeJoinEvent extends ActlyEventBase {
+    readonly type: 'dedupe-join';
+    readonly joinerPosition: number;
+}
+export interface TimeoutEvent extends ActlyEventBase {
+    readonly type: 'timeout';
+    readonly kind: 'per-attempt' | 'total';
+    readonly ms: number;
+}
+export interface FinalSuccessEvent extends ActlyEventBase {
+    readonly type: 'final-success';
+    readonly source: ActSource;
+    readonly attempts: number;
+    readonly durationMs: number;
+}
+export interface FinalFailureEvent extends ActlyEventBase {
+    readonly type: 'final-failure';
+    readonly attempts: number;
+    readonly durationMs: number;
+    readonly failedBy: ActlyFailedBy;
+    readonly error: unknown;
+}
+export type ActlyEvent = AttemptEvent | RetryEvent | CacheHitEvent | CacheMissEvent | DedupeJoinEvent | TimeoutEvent | FinalSuccessEvent | FinalFailureEvent | BackpressureEvent | WatchdogEvent;
+export interface BackpressureEvent extends ActlyEventBase {
+    readonly type: 'backpressure';
+    readonly source: 'bulkhead';
+    readonly queueLength: number;
+    readonly maxConcurrent: number;
+    readonly maxQueueSize: number;
+    readonly utilization: number;
+}
+export interface WatchdogEvent extends ActlyEventBase {
+    readonly type: 'watchdog';
+    readonly elapsedMs: number;
+    readonly scope: string;
+}
+export interface ObservabilityHooks {
+    onAttempt?: (event: AttemptEvent) => void;
+    onRetry?: (event: RetryEvent) => void;
+    onCacheHit?: (event: CacheHitEvent) => void;
+    onCacheMiss?: (event: CacheMissEvent) => void;
+    onDedupeJoin?: (event: DedupeJoinEvent) => void;
+    onTimeout?: (event: TimeoutEvent) => void;
+    onFinalSuccess?: (event: FinalSuccessEvent) => void;
+    onFinalFailure?: (event: FinalFailureEvent) => void;
+    onBackpressure?: (event: BackpressureEvent) => void;
+    onWatchdog?: (event: WatchdogEvent) => void;
+}
+export interface ObservabilityContext {
+    traceId: string;
+    hooks: ObservabilityHooks;
+    joinerCounter: number;
+}
+export declare function hasObservers(ctx: {
+    observability?: ObservabilityContext;
+}): ctx is {
+    observability: ObservabilityContext;
+};
+//# sourceMappingURL=observability.d.ts.map

package/dist/observability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observability.d.ts","sourceRoot":"","sources":["../src/observability.ts"],"names":[],"mappings":"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"}

package/dist/observability.js

@@ -0,0 +1,3 @@
+export function hasObservers(ctx) {
+    return ctx.observability != null;
+}

package/dist/policies/bulkhead.cjs

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bulkheadPolicy = bulkheadPolicy;
+const executor_js_1 = require("../core/executor.js");
+const errors_js_1 = require("../errors.js");
+const safeCall_js_1 = require("../utils/safeCall.js");
+const NS = 'bulk:';
+function getState(store, key) {
+    return store.get(NS + key) ?? { active: 0, queue: [] };
+}
+function setState(store, key, state) {
+    store.set(NS + key, state);
+}
+function bulkheadPolicy(opts) {
+    const maxConcurrent = Math.max(1, Math.floor(opts.maxConcurrent));
+    const queueTimeoutMs = opts.queueTimeoutMs ?? 0;
+    const maxQueueSize = opts.maxQueueSize ?? Number.POSITIVE_INFINITY;
+    const applier = (fn, ctx) => {
+        const syncCtx = ctx;
+        return async (signal) => {
+            const key = syncCtx.key;
+            const acquireSlot = () => {
+                if (signal.aborted)
+                    return Promise.reject(signal.reason);
+                const state = getState(syncCtx.store, key);
+                if (state.active < maxConcurrent) {
+                    state.active++;
+                    setState(syncCtx.store, key, state);
+                    return Promise.resolve();
+                }
+                if (queueTimeoutMs === 0) {
+                    throw new errors_js_1.BulkheadOverflowError(key, maxConcurrent);
+                }
+                const currentState = getState(syncCtx.store, key);
+                if (currentState.queue.length >= maxQueueSize) {
+                    throw new errors_js_1.BulkheadOverflowError(key, maxConcurrent);
+                }
+                return new Promise((resolve, reject) => {
+                    const state2 = getState(syncCtx.store, key);
+                    const entry = {
+                        resolve,
+                        reject,
+                        timer: undefined,
+                        onAbort: undefined,
+                        signal,
+                    };
+                    entry.onAbort = () => {
+                        const s = getState(syncCtx.store, key);
+                        const idx = s.queue.indexOf(entry);
+                        if (idx >= 0) {
+                            s.queue.splice(idx, 1);
+                            setState(syncCtx.store, key, s);
+                        }
+                        if (entry.timer)
+                            clearTimeout(entry.timer);
+                        reject(signal.reason);
+                    };
+                    if (queueTimeoutMs > 0) {
+                        entry.timer = setTimeout(() => {
+                            const s = getState(syncCtx.store, key);
+                            const idx = s.queue.indexOf(entry);
+                            if (idx >= 0)
+                                s.queue.splice(idx, 1);
+                            setState(syncCtx.store, key, s);
+                            signal.removeEventListener('abort', entry.onAbort);
+                            reject(new errors_js_1.BulkheadOverflowError(key, maxConcurrent));
+                        }, queueTimeoutMs);
+                    }
+                    signal.addEventListener('abort', entry.onAbort, { once: true });
+                    state2.queue.push(entry);
+                    const obs = syncCtx.observability;
+                    if (obs && maxQueueSize !== Number.POSITIVE_INFINITY) {
+                        const utilization = state2.queue.length / maxQueueSize;
+                        const wasOver80 = state2.backpressureEmitted === true;
+                        if (utilization >= 0.8 && !wasOver80) {
+                            ;
+                            state2.backpressureEmitted = true;
+                            (0, safeCall_js_1.safeCall)(obs.hooks.onBackpressure, {
+                                type: 'backpressure',
+                                key: syncCtx.key,
+                                traceId: obs.traceId,
+                                timestamp: Date.now(),
+                                source: 'bulkhead',
+                                queueLength: state2.queue.length,
+                                maxConcurrent,
+                                maxQueueSize,
+                                utilization,
+                            });
+                        }
+                        else if (utilization < 0.8 && wasOver80) {
+                            ;
+                            state2.backpressureEmitted = false;
+                        }
+                    }
+                    setState(syncCtx.store, key, state2);
+                });
+            };
+            const releaseSlot = () => {
+                const state = getState(syncCtx.store, key);
+                state.active--;
+                if (state.queue.length > 0) {
+                    const next = state.queue.shift();
+                    state.active++;
+                    if (next.timer)
+                        clearTimeout(next.timer);
+                    if (next.onAbort && next.signal) {
+                        next.signal.removeEventListener('abort', next.onAbort);
+                    }
+                    next.resolve();
+                }
+                if (state.active < 0)
+                    state.active = 0;
+                if (maxQueueSize !== Number.POSITIVE_INFINITY && state.backpressureEmitted === true) {
+                    if (state.queue.length / maxQueueSize < 0.8) {
+                        ;
+                        state.backpressureEmitted = false;
+                    }
+                }
+                if (state.active === 0 && state.queue.length === 0) {
+                    syncCtx.store.delete(NS + key);
+                }
+                else {
+                    setState(syncCtx.store, key, state);
+                }
+            };
+            await acquireSlot();
+            try {
+                return await fn(signal);
+            }
+            finally {
+                releaseSlot();
+            }
+        };
+    };
+    applier[executor_js_1.REQUIRES_SYNC_STORE] = true;
+    return applier;
+}

package/dist/policies/bulkhead.d.ts

@@ -0,0 +1,3 @@
+import type { PolicyApplier, BulkheadOptions } from '../types/index.js';
+export declare function bulkheadPolicy<T>(opts: BulkheadOptions): PolicyApplier<T>;
+//# sourceMappingURL=bulkhead.d.ts.map

package/dist/policies/bulkhead.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bulkhead.d.ts","sourceRoot":"","sources":["../../src/policies/bulkhead.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAS,aAAa,EAAiB,eAAe,EAAE,MAAM,mBAAmB,CAAA;AA2B7F,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,eAAe,GAAG,aAAa,CAAC,CAAC,CAAC,CAkJzE"}

package/dist/policies/bulkhead.js

@@ -0,0 +1,134 @@
+import { REQUIRES_SYNC_STORE } from '../core/executor.js';
+import { BulkheadOverflowError } from '../errors.js';
+import { safeCall } from '../utils/safeCall.js';
+const NS = 'bulk:';
+function getState(store, key) {
+    return store.get(NS + key) ?? { active: 0, queue: [] };
+}
+function setState(store, key, state) {
+    store.set(NS + key, state);
+}
+export function bulkheadPolicy(opts) {
+    const maxConcurrent = Math.max(1, Math.floor(opts.maxConcurrent));
+    const queueTimeoutMs = opts.queueTimeoutMs ?? 0;
+    const maxQueueSize = opts.maxQueueSize ?? Number.POSITIVE_INFINITY;
+    const applier = (fn, ctx) => {
+        const syncCtx = ctx;
+        return async (signal) => {
+            const key = syncCtx.key;
+            const acquireSlot = () => {
+                if (signal.aborted)
+                    return Promise.reject(signal.reason);
+                const state = getState(syncCtx.store, key);
+                if (state.active < maxConcurrent) {
+                    state.active++;
+                    setState(syncCtx.store, key, state);
+                    return Promise.resolve();
+                }
+                if (queueTimeoutMs === 0) {
+                    throw new BulkheadOverflowError(key, maxConcurrent);
+                }
+                const currentState = getState(syncCtx.store, key);
+                if (currentState.queue.length >= maxQueueSize) {
+                    throw new BulkheadOverflowError(key, maxConcurrent);
+                }
+                return new Promise((resolve, reject) => {
+                    const state2 = getState(syncCtx.store, key);
+                    const entry = {
+                        resolve,
+                        reject,
+                        timer: undefined,
+                        onAbort: undefined,
+                        signal,
+                    };
+                    entry.onAbort = () => {
+                        const s = getState(syncCtx.store, key);
+                        const idx = s.queue.indexOf(entry);
+                        if (idx >= 0) {
+                            s.queue.splice(idx, 1);
+                            setState(syncCtx.store, key, s);
+                        }
+                        if (entry.timer)
+                            clearTimeout(entry.timer);
+                        reject(signal.reason);
+                    };
+                    if (queueTimeoutMs > 0) {
+                        entry.timer = setTimeout(() => {
+                            const s = getState(syncCtx.store, key);
+                            const idx = s.queue.indexOf(entry);
+                            if (idx >= 0)
+                                s.queue.splice(idx, 1);
+                            setState(syncCtx.store, key, s);
+                            signal.removeEventListener('abort', entry.onAbort);
+                            reject(new BulkheadOverflowError(key, maxConcurrent));
+                        }, queueTimeoutMs);
+                    }
+                    signal.addEventListener('abort', entry.onAbort, { once: true });
+                    state2.queue.push(entry);
+                    const obs = syncCtx.observability;
+                    if (obs && maxQueueSize !== Number.POSITIVE_INFINITY) {
+                        const utilization = state2.queue.length / maxQueueSize;
+                        const wasOver80 = state2.backpressureEmitted === true;
+                        if (utilization >= 0.8 && !wasOver80) {
+                            ;
+                            state2.backpressureEmitted = true;
+                            safeCall(obs.hooks.onBackpressure, {
+                                type: 'backpressure',
+                                key: syncCtx.key,
+                                traceId: obs.traceId,
+                                timestamp: Date.now(),
+                                source: 'bulkhead',
+                                queueLength: state2.queue.length,
+                                maxConcurrent,
+                                maxQueueSize,
+                                utilization,
+                            });
+                        }
+                        else if (utilization < 0.8 && wasOver80) {
+                            ;
+                            state2.backpressureEmitted = false;
+                        }
+                    }
+                    setState(syncCtx.store, key, state2);
+                });
+            };
+            const releaseSlot = () => {
+                const state = getState(syncCtx.store, key);
+                state.active--;
+                if (state.queue.length > 0) {
+                    const next = state.queue.shift();
+                    state.active++;
+                    if (next.timer)
+                        clearTimeout(next.timer);
+                    if (next.onAbort && next.signal) {
+                        next.signal.removeEventListener('abort', next.onAbort);
+                    }
+                    next.resolve();
+                }
+                if (state.active < 0)
+                    state.active = 0;
+                if (maxQueueSize !== Number.POSITIVE_INFINITY && state.backpressureEmitted === true) {
+                    if (state.queue.length / maxQueueSize < 0.8) {
+                        ;
+                        state.backpressureEmitted = false;
+                    }
+                }
+                if (state.active === 0 && state.queue.length === 0) {
+                    syncCtx.store.delete(NS + key);
+                }
+                else {
+                    setState(syncCtx.store, key, state);
+                }
+            };
+            await acquireSlot();
+            try {
+                return await fn(signal);
+            }
+            finally {
+                releaseSlot();
+            }
+        };
+    };
+    applier[REQUIRES_SYNC_STORE] = true;
+    return applier;
+}