adaptive-concurrency 0.1.0 → 0.2.0

package/dist/LimitAllotment.d.ts

@@ -1,23 +1,23 @@
 /**
  * Handle returned when a concurrency slot is acquired. The caller must invoke
- * exactly one of the report methods when the operation completes.
+ * exactly one of the release-and-record methods when the operation completes.
  */
 export interface LimitAllotment {
     /**
      * The operation succeeded and internally measured latency should be used as
      * an RTT sample.
      */
-    reportSuccess(): void;
+    releaseAndRecordSuccess(): Promise<void>;
     /**
      * The operation failed before any meaningful RTT measurement could be made
      * and should be ignored so it does not introduce an artificially low RTT.
      */
-    reportIgnore(): void;
+    releaseAndIgnore(): Promise<void>;
     /**
      * The request failed and was dropped due to being rejected by an external
      * limit or hitting a timeout. Loss based StreamingLimit implementations will
      * likely do an aggressive reduction in limit when this happens.
      */
-    reportDropped(): void;
+    releaseAndRecordDropped(): Promise<void>;
 }
 //# sourceMappingURL=LimitAllotment.d.ts.map

package/dist/LimitAllotment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LimitAllotment.d.ts","sourceRoot":"","sources":["../src/LimitAllotment.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,aAAa,IAAI,IAAI,CAAC;IAEtB;;;OAGG;IACH,YAAY,IAAI,IAAI,CAAC;IAErB;;;;OAIG;IACH,aAAa,IAAI,IAAI,CAAC;CACvB"}
+{"version":3,"file":"LimitAllotment.d.ts","sourceRoot":"","sources":["../src/LimitAllotment.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,uBAAuB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzC;;;OAGG;IACH,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAElC;;;;OAIG;IACH,uBAAuB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1C"}

package/dist/Limiter.d.ts

@@ -2,13 +2,11 @@ import type { AdaptiveLimit } from "./limit/StreamingLimit.js";
 import type { LimitAllotment } from "./LimitAllotment.js";
 import type { MetricRegistry } from "./MetricRegistry.js";
 import { QuotaNotAvailable, type RunResult } from "./RunResult.js";
-export type SyncAcquireResult = LimitAllotment | undefined;
-export type AsyncAcquireResult = Promise<LimitAllotment | undefined>;
+export type MaybePromise<T> = T | Promise<T>;
 /**
- * Union of all possible acquire return types. Useful for code that must handle
- * both sync and async limiters generically.
+ * Acquire is async-only.
  */
-export type AcquireResult = SyncAcquireResult | AsyncAcquireResult;
+export type AcquireResult = Promise<LimitAllotment | undefined>;
 export interface AcquireOptions<ContextT = void> {
     context?: ContextT;
     signal?: AbortSignal;
@@ -32,17 +30,17 @@ export interface AcquireStrategy<ContextT> {
      * When `true`, the strategy has reserved capacity for one inflight unit; when
      * `false`, an allotment was not available.
      */
-    tryAcquireAllotment(context: ContextT, state: LimiterState): boolean;
+    tryAcquireAllotment(context: ContextT, state: LimiterState): MaybePromise<boolean>;
     /**
      * Called when an acquired allotment completes (success, ignore, or drop).
      * Perform any cleanup (e.g. increment permits, release a partition slot).
      */
-    onAllotmentReleased(context: ContextT): void;
+    onAllotmentReleased(context: ContextT): MaybePromise<void>;
     /**
      * Called when the adaptive limit changes. The strategy can react
      * (e.g. adjust available permits by the delta, update partition sub-limits).
      */
-    onLimitChanged?(oldLimit: number, newLimit: number): void;
+    onLimitChanged?(oldLimit: number, newLimit: number): MaybePromise<void>;
 }
 /**
  * Determines what happens when a request is rejected by the
@@ -50,7 +48,7 @@ export interface AcquireStrategy<ContextT> {
  * {@link Limiter.acquire}'s return type, enabling the type system to
  * distinguish sync limiters (no promise) from async/blocking ones.
  */
-export interface AllotmentUnavailableStrategy<ContextT, ResultT extends SyncAcquireResult | AsyncAcquireResult> {
+export interface AllotmentUnavailableStrategy<ContextT> {
     /**
      * Called when the acquire strategy cannot allocate an allotment for a
      * request.
@@ -62,14 +60,14 @@ export interface AllotmentUnavailableStrategy<ContextT, ResultT extends SyncAcqu
      *   ready-to-use allotment with all required wrapping.
      * @param signal Optional abort signal from the caller.
      */
-    onAllotmentUnavailable(context: ContextT, retry: (context: ContextT) => SyncAcquireResult, signal?: AbortSignal): ResultT;
+    onAllotmentUnavailable(context: ContextT, retry: (context: ContextT) => AcquireResult, signal?: AbortSignal): AcquireResult;
     /**
      * Called whenever any allotment is released (success, ignore, or drop).
      * Blocking strategies use this to wake queued waiters.
      */
-    onAllotmentReleased(): void;
+    onAllotmentReleased(): MaybePromise<void>;
 }
-export interface LimiterOptions<ContextT, RejResultT extends SyncAcquireResult | AsyncAcquireResult = SyncAcquireResult> {
+export interface LimiterOptions<ContextT> {
     limit?: AdaptiveLimit;
     /**
      * Clock function returning the current time in fractional milliseconds
@@ -93,20 +91,17 @@ export interface LimiterOptions<ContextT, RejResultT extends SyncAcquireResult |
      * Strategy that decides what happens when the acquire strategy rejects a
      * request. When omitted, rejected requests immediately receive `undefined`.
      */
-    allotmentUnavailableStrategy?: AllotmentUnavailableStrategy<ContextT, RejResultT>;
+    allotmentUnavailableStrategy?: AllotmentUnavailableStrategy<ContextT>;
 }
 /**
  * Concurrency limiter with pluggable strategies for gating decisions and
  * rejection handling.
  *
- * When no rejection strategy is provided, `acquire()` returns synchronously
- * (`LimitAllotment | undefined`). When a blocking rejection strategy is
- * configured, `acquire()` may also return a `Promise`.
+ * `acquire()` always returns a `Promise<LimitAllotment | undefined>`.
  *
  * @typeParam ContextT Request context type (e.g. partition key).
- * @typeParam RejResultT The result type produced by the rejection strategy.
  */
-export declare class Limiter<Context = void, AcquireResult extends SyncAcquireResult | AsyncAcquireResult = SyncAcquireResult> {
+export declare class Limiter<Context = void> {
     private _inflight;
     private _limit;
     private readonly clock;
@@ -120,8 +115,8 @@ export declare class Limiter<Context = void, AcquireResult extends SyncAcquireRe
     private readonly rejectedCounter;
     private readonly bypassCounter;
     static makeDefaultLimit(): AdaptiveLimit;
-    constructor(options?: LimiterOptions<Context, AcquireResult>);
-    acquire(options?: AcquireOptions<Context>): SyncAcquireResult | AcquireResult;
+    constructor(options?: LimiterOptions<Context>);
+    acquire(options?: AcquireOptions<Context>): AcquireResult;
     private tryAcquireCore;
     private createAllotment;
     getLimit(): number;
@@ -139,11 +134,6 @@ export declare class SemaphoreStrategy {
     onAllotmentReleased(): void;
     onLimitChanged(oldLimit: number, newLimit: number): void;
 }
-/**
- * Run a callback when an acquire result is ready. If the result is a Promise,
- * waits asynchronously; otherwise invokes the callback synchronously.
- */
-export declare function whenAcquireSettled(result: AcquireResult, callback: (allotment: LimitAllotment | undefined) => void): void;
 export type RunCallbackArgs<ContextT> = {
     context: ContextT | undefined;
     signal: AbortSignal | undefined;
@@ -158,18 +148,11 @@ export interface LimitedFunction<ContextT> {
  * - If {@link Limiter.acquire} yields no allotment, returns
  *   {@link QuotaNotAvailable} without invoking `fn`.
  * - On {@link RunResult} `success` / `ignore`, returns the carried value after
- *   reporting to the allotment.
- * - On `dropped`, reports drop and throws the carried error.
- * - On uncaught exceptions from `fn`, reports ignore and rethrows, except for
- *   {@link AdaptiveTimeoutError}, which reports drop and rethrows.
+ *   recording success/ignore to the allotment.
+ * - On `dropped`, records drop and throws the carried error.
+ * - On uncaught exceptions from `fn`, records ignore and rethrows, except for
+ *   {@link AdaptiveTimeoutError}, which records drop and rethrows.
  * - Callback receives `{ context, signal }` from acquire options.
  */
-export declare function withLimiter<ContextT, RejResultT extends SyncAcquireResult | AsyncAcquireResult>(limiter: Limiter<ContextT, RejResultT>): LimitedFunction<ContextT>;
-/**
- * Synchronous try-acquire interface. A `Limiter<Ctx>` (with default sync
- * rejection) is structurally compatible with this interface.
- */
-export interface SyncLimiter<ContextT = void> {
-    acquire(options?: AcquireOptions<ContextT>): LimitAllotment | undefined;
-}
+export declare function withLimiter<ContextT>(limiter: Limiter<ContextT>): LimitedFunction<ContextT>;
 //# sourceMappingURL=Limiter.d.ts.map

package/dist/Limiter.d.ts.map

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

package/dist/Limiter.js

@@ -5,21 +5,18 @@ import { isAdaptiveTimeoutError, QuotaNotAvailable, } from "./RunResult.js";
 // Limiter options
 // ---------------------------------------------------------------------------
 const NOOP_ALLOTMENT = {
-    reportSuccess() { },
-    reportIgnore() { },
-    reportDropped() { },
+    async releaseAndRecordSuccess() { },
+    async releaseAndIgnore() { },
+    async releaseAndRecordDropped() { },
 };
 let idCounter = 0;
 /**
  * Concurrency limiter with pluggable strategies for gating decisions and
  * rejection handling.
  *
- * When no rejection strategy is provided, `acquire()` returns synchronously
- * (`LimitAllotment | undefined`). When a blocking rejection strategy is
- * configured, `acquire()` may also return a `Promise`.
+ * `acquire()` always returns a `Promise<LimitAllotment | undefined>`.
  *
  * @typeParam ContextT Request context type (e.g. partition key).
- * @typeParam RejResultT The result type produced by the rejection strategy.
  */
 export class Limiter {
     _inflight = 0;
@@ -48,7 +45,7 @@ export class Limiter {
         this.limitAlgorithm.subscribe((newLimit) => {
             const oldLimit = this._limit;
             this._limit = newLimit;
-            this.acquireStrategy.onLimitChanged?.(oldLimit, newLimit);
+            void Promise.resolve(this.acquireStrategy.onLimitChanged?.(oldLimit, newLimit));
         });
         const registry = options.metricRegistry ?? NoopMetricRegistry;
         const limiterName = options.name ?? `unnamed-${++idCounter}`;
@@ -74,7 +71,7 @@ export class Limiter {
             status: "bypassed",
         });
     }
-    acquire(options) {
+    async acquire(options) {
         if (options?.signal?.aborted)
             return undefined;
         const ctx = (options?.context ?? undefined);
@@ -86,7 +83,7 @@ export class Limiter {
             limit: this._limit,
             inflight: this._inflight,
         };
-        if (!this.acquireStrategy.tryAcquireAllotment(ctx, state)) {
+        if (!(await this.acquireStrategy.tryAcquireAllotment(ctx, state))) {
             this.rejectedCounter.increment();
             if (this.rejectionStrategy) {
                 return this.rejectionStrategy.onAllotmentUnavailable(ctx, (retryCtx) => this.tryAcquireCore(retryCtx), options?.signal);
@@ -95,12 +92,12 @@ export class Limiter {
         }
         return this.createAllotment(ctx);
     }
-    tryAcquireCore(ctx) {
+    async tryAcquireCore(ctx) {
         const state = {
             limit: this._limit,
             inflight: this._inflight,
         };
-        if (!this.acquireStrategy.tryAcquireAllotment(ctx, state)) {
+        if (!(await this.acquireStrategy.tryAcquireAllotment(ctx, state))) {
             return undefined;
         }
         return this.createAllotment(ctx);
@@ -109,25 +106,25 @@ export class Limiter {
         const startTime = this.clock();
         const currentInflight = ++this._inflight;
         return {
-            reportSuccess: () => {
+            releaseAndRecordSuccess: async () => {
                 this._inflight--;
-                this.acquireStrategy.onAllotmentReleased(ctx);
+                await this.acquireStrategy.onAllotmentReleased(ctx);
                 this.successCounter.increment();
                 this.limitAlgorithm.addSample(startTime, this.clock() - startTime, currentInflight, false);
-                this.rejectionStrategy?.onAllotmentReleased();
+                await this.rejectionStrategy?.onAllotmentReleased();
             },
-            reportIgnore: () => {
+            releaseAndIgnore: async () => {
                 this._inflight--;
-                this.acquireStrategy.onAllotmentReleased(ctx);
+                await this.acquireStrategy.onAllotmentReleased(ctx);
                 this.ignoredCounter.increment();
-                this.rejectionStrategy?.onAllotmentReleased();
+                await this.rejectionStrategy?.onAllotmentReleased();
             },
-            reportDropped: () => {
+            releaseAndRecordDropped: async () => {
                 this._inflight--;
-                this.acquireStrategy.onAllotmentReleased(ctx);
+                await this.acquireStrategy.onAllotmentReleased(ctx);
                 this.droppedCounter.increment();
                 this.limitAlgorithm.addSample(startTime, this.clock() - startTime, currentInflight, true);
-                this.rejectionStrategy?.onAllotmentReleased();
+                await this.rejectionStrategy?.onAllotmentReleased();
             },
         };
     }
@@ -164,35 +161,16 @@ export class SemaphoreStrategy {
         this.permits += newLimit - oldLimit;
     }
 }
-// ---------------------------------------------------------------------------
-// Helper: whenAcquireSettled
-// ---------------------------------------------------------------------------
-/**
- * Run a callback when an acquire result is ready. If the result is a Promise,
- * waits asynchronously; otherwise invokes the callback synchronously.
- */
-export function whenAcquireSettled(result, callback) {
-    if (result !== null &&
-        typeof result === "object" &&
-        "then" in result &&
-        typeof result.then ===
-            "function") {
-        void result.then(callback);
-    }
-    else {
-        callback(result);
-    }
-}
 /**
  * Creates a helper that runs callbacks under acquired limiter allotments.
  *
  * - If {@link Limiter.acquire} yields no allotment, returns
  *   {@link QuotaNotAvailable} without invoking `fn`.
  * - On {@link RunResult} `success` / `ignore`, returns the carried value after
- *   reporting to the allotment.
- * - On `dropped`, reports drop and throws the carried error.
- * - On uncaught exceptions from `fn`, reports ignore and rethrows, except for
- *   {@link AdaptiveTimeoutError}, which reports drop and rethrows.
+ *   recording success/ignore to the allotment.
+ * - On `dropped`, records drop and throws the carried error.
+ * - On uncaught exceptions from `fn`, records ignore and rethrows, except for
+ *   {@link AdaptiveTimeoutError}, which records drop and rethrows.
  * - Callback receives `{ context, signal }` from acquire options.
  */
 export function withLimiter(limiter) {
@@ -204,7 +182,7 @@ export function withLimiter(limiter) {
         const fn = hasOptions
             ? maybeFn
             : optionsOrFn;
-        const allotment = await Promise.resolve(limiter.acquire(options));
+        const allotment = await limiter.acquire(options);
         if (!allotment) {
             return QuotaNotAvailable;
         }
@@ -216,23 +194,23 @@ export function withLimiter(limiter) {
         ]);
         if (result.status === "rejected") {
             if (isAdaptiveTimeoutError(result.reason)) {
-                allotment.reportDropped();
+                await allotment.releaseAndRecordDropped();
             }
             else {
-                allotment.reportIgnore();
+                await allotment.releaseAndIgnore();
             }
             throw result.reason;
         }
         const outcome = result.value;
         switch (outcome.kind) {
             case "success":
-                allotment.reportSuccess();
+                await allotment.releaseAndRecordSuccess();
                 return outcome.value;
             case "ignore":
-                allotment.reportIgnore();
+                await allotment.releaseAndIgnore();
                 return outcome.value;
             case "dropped":
-                allotment.reportDropped();
+                await allotment.releaseAndRecordDropped();
                 throw outcome.error;
         }
     }

package/dist/RunResult.d.ts

@@ -7,7 +7,7 @@ export declare const QuotaNotAvailable: unique symbol;
 /**
  * Error type that signals the operation was dropped due to timeout or external
  * load shedding. When thrown from {@link Limiter.run}'s callback, run treats
- * it as dropped (calls `reportDropped`) and then rethrows it.
+ * it as dropped (calls `releaseAndRecordDropped`) and then rethrows it.
  */
 export declare class AdaptiveTimeoutError extends Error {
     readonly code: "ADAPTIVE_TIMEOUT";

package/dist/RunResult.js

@@ -8,7 +8,7 @@ export const QuotaNotAvailable = Symbol("QuotaNotAvailable");
 /**
  * Error type that signals the operation was dropped due to timeout or external
  * load shedding. When thrown from {@link Limiter.run}'s callback, run treats
- * it as dropped (calls `reportDropped`) and then rethrows it.
+ * it as dropped (calls `releaseAndRecordDropped`) and then rethrows it.
  */
 export class AdaptiveTimeoutError extends Error {
     code = ADAPTIVE_TIMEOUT_ERROR_CODE;

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export type { AdaptiveLimit } from "./limit/StreamingLimit.js";
 export type { LimitAllotment } from "./LimitAllotment.js";
-export { Limiter, SemaphoreStrategy, whenAcquireSettled, withLimiter, type AcquireOptions, type AcquireResult, type AcquireStrategy, type AllotmentUnavailableStrategy, type AsyncAcquireResult, type LimitedFunction, type LimiterOptions, type LimiterState, type RunCallbackArgs, type SyncAcquireResult, type SyncLimiter, } from "./Limiter.js";
+export { Limiter, SemaphoreStrategy, withLimiter, type AcquireOptions, type AcquireResult, type AcquireStrategy, type AllotmentUnavailableStrategy, type LimitedFunction, type LimiterOptions, type LimiterState, type RunCallbackArgs, type MaybePromise, } from "./Limiter.js";
 export { ListenerSet } from "./ListenerSet.js";
 export { MetricIds, NoopMetricRegistry, type Counter, type DistributionMetric, type GaugeMetric, type MetricRegistry, } from "./MetricRegistry.js";
 export { AdaptiveTimeoutError, dropped, ignore, isAdaptiveTimeoutError, QuotaNotAvailable, success, type RunDropped, type RunIgnore, type RunResult, type RunSuccess, } from "./RunResult.js";
@@ -19,9 +19,9 @@ export { createPercentileSampleWindow } from "./limit/window/PercentileSampleWin
 export type { SampleWindow } from "./limit/window/SampleWindow.js";
 export { squareRoot, squareRootWithBaseline } from "./utils/index.js";
 export * from "./limiter/factories/index.js";
-export { PartitionedStrategy, type PartitionConfig, } from "./limiter/PartitionedStrategy.js";
-export { DelayedRejectStrategy, type DelayedRejectStrategyOptions, } from "./limiter/DelayedRejectStrategy.js";
-export { DelayedThenBlockingRejection } from "./limiter/DelayedThenBlockingRejection.js";
-export { FifoBlockingRejection } from "./limiter/FifoBlockingRejection.js";
-export { LifoBlockingRejection, type LifoBlockingRejectionOptions, } from "./limiter/LifoBlockingRejection.js";
+export { PartitionedStrategy, type PartitionConfig, } from "./limiter/acquire-strategies/PartitionedStrategy.js";
+export { DelayedRejectStrategy, type DelayedRejectStrategyOptions, } from "./limiter/allocation-unavailable-strategies/DelayedRejectStrategy.js";
+export { DelayedThenBlockingRejection } from "./limiter/allocation-unavailable-strategies/DelayedThenBlockingRejection.js";
+export { FifoBlockingRejection } from "./limiter/allocation-unavailable-strategies/FifoBlockingRejection.js";
+export { LifoBlockingRejection, type LifoBlockingRejectionOptions, } from "./limiter/allocation-unavailable-strategies/LifoBlockingRejection.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":"AACA,YAAY,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC/D,YAAY,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EACL,OAAO,EACP,iBAAiB,EACjB,kBAAkB,EAClB,WAAW,EACX,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,4BAA4B,EACjC,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,WAAW,GACjB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EACL,SAAS,EACT,kBAAkB,EAClB,KAAK,OAAO,EACZ,KAAK,kBAAkB,EACvB,KAAK,WAAW,EAChB,KAAK,cAAc,GACpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,oBAAoB,EACpB,OAAO,EACP,MAAM,EACN,sBAAsB,EACtB,iBAAiB,EACjB,OAAO,EACP,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,SAAS,EACd,KAAK,UAAU,GAChB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxE,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EACL,aAAa,EACb,KAAK,qBAAqB,GAC3B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,EACL,UAAU,EACV,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,GACtB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,aAAa,EACb,KAAK,oBAAoB,GAC1B,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAC5D,YAAY,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAG7E,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,EAAE,4BAA4B,EAAE,MAAM,0CAA0C,CAAC;AACxF,YAAY,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAGnE,OAAO,EAAE,UAAU,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAGtE,cAAc,8BAA8B,CAAC;AAC7C,OAAO,EACL,mBAAmB,EACnB,KAAK,eAAe,GACrB,MAAM,kCAAkC,CAAC;AAG1C,OAAO,EACL,qBAAqB,EACrB,KAAK,4BAA4B,GAClC,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,4BAA4B,EAAE,MAAM,2CAA2C,CAAC;AACzF,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EACL,qBAAqB,EACrB,KAAK,4BAA4B,GAClC,MAAM,oCAAoC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,YAAY,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC/D,YAAY,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EACL,OAAO,EACP,iBAAiB,EACjB,WAAW,EACX,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,4BAA4B,EACjC,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,YAAY,GAClB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EACL,SAAS,EACT,kBAAkB,EAClB,KAAK,OAAO,EACZ,KAAK,kBAAkB,EACvB,KAAK,WAAW,EAChB,KAAK,cAAc,GACpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,oBAAoB,EACpB,OAAO,EACP,MAAM,EACN,sBAAsB,EACtB,iBAAiB,EACjB,OAAO,EACP,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,SAAS,EACd,KAAK,UAAU,GAChB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxE,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EACL,aAAa,EACb,KAAK,qBAAqB,GAC3B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,EACL,UAAU,EACV,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,GACtB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,aAAa,EACb,KAAK,oBAAoB,GAC1B,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAC5D,YAAY,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAG7E,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,EAAE,4BAA4B,EAAE,MAAM,0CAA0C,CAAC;AACxF,YAAY,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAGnE,OAAO,EAAE,UAAU,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAGtE,cAAc,8BAA8B,CAAC;AAC7C,OAAO,EACL,mBAAmB,EACnB,KAAK,eAAe,GACrB,MAAM,qDAAqD,CAAC;AAG7D,OAAO,EACL,qBAAqB,EACrB,KAAK,4BAA4B,GAClC,MAAM,sEAAsE,CAAC;AAC9E,OAAO,EAAE,4BAA4B,EAAE,MAAM,6EAA6E,CAAC;AAC3H,OAAO,EAAE,qBAAqB,EAAE,MAAM,sEAAsE,CAAC;AAC7G,OAAO,EACL,qBAAqB,EACrB,KAAK,4BAA4B,GAClC,MAAM,sEAAsE,CAAC"}

package/dist/index.js

@@ -1,4 +1,4 @@
-export { Limiter, SemaphoreStrategy, whenAcquireSettled, withLimiter, } from "./Limiter.js";
+export { Limiter, SemaphoreStrategy, withLimiter, } from "./Limiter.js";
 export { ListenerSet } from "./ListenerSet.js";
 export { MetricIds, NoopMetricRegistry, } from "./MetricRegistry.js";
 export { AdaptiveTimeoutError, dropped, ignore, isAdaptiveTimeoutError, QuotaNotAvailable, success, } from "./RunResult.js";
@@ -20,9 +20,9 @@ export { createPercentileSampleWindow } from "./limit/window/PercentileSampleWin
 export { squareRoot, squareRootWithBaseline } from "./utils/index.js";
 // Acquire strategies
 export * from "./limiter/factories/index.js";
-export { PartitionedStrategy, } from "./limiter/PartitionedStrategy.js";
+export { PartitionedStrategy, } from "./limiter/acquire-strategies/PartitionedStrategy.js";
 // Rejection strategies
-export { DelayedRejectStrategy, } from "./limiter/DelayedRejectStrategy.js";
-export { DelayedThenBlockingRejection } from "./limiter/DelayedThenBlockingRejection.js";
-export { FifoBlockingRejection } from "./limiter/FifoBlockingRejection.js";
-export { LifoBlockingRejection, } from "./limiter/LifoBlockingRejection.js";
+export { DelayedRejectStrategy, } from "./limiter/allocation-unavailable-strategies/DelayedRejectStrategy.js";
+export { DelayedThenBlockingRejection } from "./limiter/allocation-unavailable-strategies/DelayedThenBlockingRejection.js";
+export { FifoBlockingRejection } from "./limiter/allocation-unavailable-strategies/FifoBlockingRejection.js";
+export { LifoBlockingRejection, } from "./limiter/allocation-unavailable-strategies/LifoBlockingRejection.js";

package/dist/limiter/{PartitionedStrategy.d.ts → acquire-strategies/PartitionedStrategy.d.ts}

@@ -1,5 +1,5 @@
-import type { AcquireStrategy, LimiterState } from "../Limiter.js";
-import type { MetricRegistry } from "../MetricRegistry.js";
+import type { AcquireStrategy, LimiterState } from "../../Limiter.js";
+import type { MetricRegistry } from "../../MetricRegistry.js";
 export type PartitionConfig = {
     /**
      * Percentage of the total limit guaranteed to this partition. Must be in

package/dist/limiter/acquire-strategies/PartitionedStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PartitionedStrategy.d.ts","sourceRoot":"","sources":["../../../src/limiter/acquire-strategies/PartitionedStrategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACtE,OAAO,KAAK,EAGV,cAAc,EACf,MAAM,yBAAyB,CAAC;AAKjC,MAAM,MAAM,eAAe,GAAG;IAC5B;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,qBAAa,mBAAmB,CAC9B,QAAQ,EACR,aAAa,SAAS,MAAM,GAAG,MAAM,CACrC,YAAW,eAAe,CAAC,QAAQ,CAAC;IACpC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAG9B;IACF,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAuB;IACxD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAEH;gBAEnB,OAAO,EAAE;QACnB;;;WAGG;QACH,YAAY,EAAE,MAAM,CAAC;QAErB;;;;;WAKG;QACH,iBAAiB,EAAE,CAAC,OAAO,EAAE,QAAQ,KAAK,aAAa,GAAG,SAAS,CAAC;QACpE,UAAU,EAAE,MAAM,CAAC,aAAa,EAAE,eAAe,CAAC,CAAC;QAEnD,cAAc,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;KAC7C;IAkDD,mBAAmB,CAAC,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO;IAUpE,mBAAmB,CAAC,OAAO,EAAE,QAAQ,GAAG,IAAI;IAI5C,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAMzD;;;OAGG;IACH,YAAY,CAAC,IAAI,EAAE,aAAa;;;;;;;IAehC,OAAO,CAAC,gBAAgB;CAUzB"}

package/dist/limiter/{PartitionedStrategy.js → acquire-strategies/PartitionedStrategy.js}

@@ -1,4 +1,4 @@
-import { MetricIds, NoopMetricRegistry } from "../MetricRegistry.js";
+import { MetricIds, NoopMetricRegistry } from "../../MetricRegistry.js";
 const PARTITION_TAG_NAME = "partition";
 /**
  * ## Partitioned acquire strategy (guaranteed share + bursting)

package/dist/limiter/{DelayedRejectStrategy.d.ts → allocation-unavailable-strategies/DelayedRejectStrategy.d.ts}

@@ -1,5 +1,5 @@
-import type { LimitAllotment } from "../LimitAllotment.js";
-import type { AllotmentUnavailableStrategy, AsyncAcquireResult, SyncAcquireResult } from "../Limiter.js";
+import type { LimitAllotment } from "../../LimitAllotment.js";
+import type { AllotmentUnavailableStrategy, AcquireResult } from "../../Limiter.js";
 export interface DelayedRejectStrategyOptions<ContextT> {
     /**
      * Milliseconds to wait before resolving with no allotment. Return 0 to reject
@@ -11,7 +11,7 @@ export interface DelayedRejectStrategyOptions<ContextT> {
      * Maximum number of acquire attempts that may be waiting on a delay at once.
      * When exceeded, new rejections skip the delay (immediate `undefined`).
      */
-    maxConcurrentDelays?: number;
+    maxConcurrentDelays?: number | undefined;
 }
 /**
  * When the acquire strategy rejects, waits up to `delayMsForContext(context)`,
@@ -20,12 +20,12 @@ export interface DelayedRejectStrategyOptions<ContextT> {
  * reject," not "wait for capacity." Compose with `PartitionedStrategy` via
  * `Limiter.rejectionStrategy`; partition delays are not fields on `PartitionConfig`.
  */
-export declare class DelayedRejectStrategy<ContextT> implements AllotmentUnavailableStrategy<ContextT, AsyncAcquireResult> {
+export declare class DelayedRejectStrategy<ContextT> implements AllotmentUnavailableStrategy<ContextT> {
     private readonly delayMsForContext;
     private readonly maxConcurrentDelays;
     private concurrentDelays;
     constructor(options: DelayedRejectStrategyOptions<ContextT>);
-    onAllotmentUnavailable(context: ContextT, _retry: (context: ContextT) => SyncAcquireResult, signal?: AbortSignal): Promise<LimitAllotment | undefined>;
+    onAllotmentUnavailable(context: ContextT, _retry: (context: ContextT) => AcquireResult, signal?: AbortSignal): Promise<LimitAllotment | undefined>;
     onAllotmentReleased(): void;
     private run;
 }

package/dist/limiter/allocation-unavailable-strategies/DelayedRejectStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DelayedRejectStrategy.d.ts","sourceRoot":"","sources":["../../../src/limiter/allocation-unavailable-strategies/DelayedRejectStrategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,KAAK,EACV,4BAA4B,EAC5B,aAAa,EACd,MAAM,kBAAkB,CAAC;AAE1B,MAAM,WAAW,4BAA4B,CAAC,QAAQ;IACpD;;;;OAIG;IACH,iBAAiB,EAAE,CAAC,OAAO,EAAE,QAAQ,KAAK,MAAM,CAAC;IAEjD;;;OAGG;IACH,mBAAmB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1C;AAED;;;;;;GAMG;AACH,qBAAa,qBAAqB,CAChC,QAAQ,CACR,YAAW,4BAA4B,CAAC,QAAQ,CAAC;IACjD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAgC;IAClE,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAS;IAC7C,OAAO,CAAC,gBAAgB,CAAK;gBAEjB,OAAO,EAAE,4BAA4B,CAAC,QAAQ,CAAC;IAS3D,sBAAsB,CACpB,OAAO,EAAE,QAAQ,EACjB,MAAM,EAAE,CAAC,OAAO,EAAE,QAAQ,KAAK,aAAa,EAC5C,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC;IAItC,mBAAmB,IAAI,IAAI;YAIb,GAAG;CA0BlB"}

package/dist/limiter/{DelayedThenBlockingRejection.d.ts → allocation-unavailable-strategies/DelayedThenBlockingRejection.d.ts}

@@ -1,19 +1,19 @@
-import type { LimitAllotment } from "../LimitAllotment.js";
-import type { AllotmentUnavailableStrategy, AsyncAcquireResult, SyncAcquireResult } from "../Limiter.js";
+import type { LimitAllotment } from "../../LimitAllotment.js";
+import type { AllotmentUnavailableStrategy, AcquireResult } from "../../Limiter.js";
 import type { DelayedRejectStrategy } from "./DelayedRejectStrategy.js";
 /**
  * Composes "delay then reject" backoff with blocking behavior. On rejection:
  * first applies delayed-reject semantics, then delegates to a blocking strategy
  * (FIFO/LIFO) to await capacity.
  */
-export declare class DelayedThenBlockingRejection<ContextT> implements AllotmentUnavailableStrategy<ContextT, AsyncAcquireResult> {
+export declare class DelayedThenBlockingRejection<ContextT> implements AllotmentUnavailableStrategy<ContextT> {
     private readonly delayStrategy;
     private readonly blockingStrategy;
     constructor(options: {
         delayStrategy: DelayedRejectStrategy<ContextT>;
-        blockingStrategy: AllotmentUnavailableStrategy<ContextT, AsyncAcquireResult>;
+        blockingStrategy: AllotmentUnavailableStrategy<ContextT>;
     });
-    onAllotmentUnavailable(context: ContextT, retry: (context: ContextT) => SyncAcquireResult, signal?: AbortSignal): Promise<LimitAllotment | undefined>;
-    onAllotmentReleased(): void;
+    onAllotmentUnavailable(context: ContextT, retry: (context: ContextT) => AcquireResult, signal?: AbortSignal): Promise<LimitAllotment | undefined>;
+    onAllotmentReleased(): Promise<void>;
 }
 //# sourceMappingURL=DelayedThenBlockingRejection.d.ts.map

package/dist/limiter/allocation-unavailable-strategies/DelayedThenBlockingRejection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DelayedThenBlockingRejection.d.ts","sourceRoot":"","sources":["../../../src/limiter/allocation-unavailable-strategies/DelayedThenBlockingRejection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,KAAK,EACV,4BAA4B,EAC5B,aAAa,EACd,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAExE;;;;GAIG;AACH,qBAAa,4BAA4B,CACvC,QAAQ,CACR,YAAW,4BAA4B,CAAC,QAAQ,CAAC;IACjD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAkC;IAChE,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAyC;gBAE9D,OAAO,EAAE;QACnB,aAAa,EAAE,qBAAqB,CAAC,QAAQ,CAAC,CAAC;QAC/C,gBAAgB,EAAE,4BAA4B,CAAC,QAAQ,CAAC,CAAC;KAC1D;IAKK,sBAAsB,CAC1B,OAAO,EAAE,QAAQ,EACjB,KAAK,EAAE,CAAC,OAAO,EAAE,QAAQ,KAAK,aAAa,EAC3C,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC;IAYhC,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC;CAI3C"}

package/dist/limiter/{DelayedThenBlockingRejection.js → allocation-unavailable-strategies/DelayedThenBlockingRejection.js}

@@ -15,12 +15,12 @@ export class DelayedThenBlockingRejection {
         if (signal?.aborted) {
             return undefined;
         }
-        const allotment = retry(context);
+        const allotment = await retry(context);
         return (allotment ??
             this.blockingStrategy.onAllotmentUnavailable(context, retry, signal));
     }
-    onAllotmentReleased() {
-        this.delayStrategy.onAllotmentReleased();
-        this.blockingStrategy.onAllotmentReleased();
+    async onAllotmentReleased() {
+        await this.delayStrategy.onAllotmentReleased();
+        await this.blockingStrategy.onAllotmentReleased();
     }
 }

package/dist/limiter/{FifoBlockingRejection.d.ts → allocation-unavailable-strategies/FifoBlockingRejection.d.ts}

@@ -1,5 +1,5 @@
-import type { LimitAllotment } from "../LimitAllotment.js";
-import type { AllotmentUnavailableStrategy, AsyncAcquireResult, SyncAcquireResult } from "../Limiter.js";
+import type { LimitAllotment } from "../../LimitAllotment.js";
+import type { AllotmentUnavailableStrategy, AcquireResult } from "../../Limiter.js";
 /**
  * Rejection strategy that blocks the caller in a FIFO queue when the limit
  * has been reached, waiting for a slot to open up. This strategy favors
@@ -8,7 +8,7 @@ import type { AllotmentUnavailableStrategy, AsyncAcquireResult, SyncAcquireResul
  * Because JavaScript is single-threaded, "blocking" means awaiting a promise
  * that resolves when a token becomes available.
  */
-export declare class FifoBlockingRejection<ContextT> implements AllotmentUnavailableStrategy<ContextT, AsyncAcquireResult> {
+export declare class FifoBlockingRejection<ContextT> implements AllotmentUnavailableStrategy<ContextT> {
     private readonly timeout;
     private readonly waiters;
     constructor(options?: {
@@ -18,7 +18,7 @@ export declare class FifoBlockingRejection<ContextT> implements AllotmentUnavail
          */
         timeout?: number | undefined;
     });
-    onAllotmentUnavailable(_context: ContextT, retry: (context: ContextT) => SyncAcquireResult, signal?: AbortSignal): Promise<LimitAllotment | undefined>;
+    onAllotmentUnavailable(_context: ContextT, retry: (context: ContextT) => AcquireResult, signal?: AbortSignal): Promise<LimitAllotment | undefined>;
     onAllotmentReleased(): void;
     private acquireAsync;
     private waitForRelease;

package/dist/limiter/allocation-unavailable-strategies/FifoBlockingRejection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FifoBlockingRejection.d.ts","sourceRoot":"","sources":["../../../src/limiter/allocation-unavailable-strategies/FifoBlockingRejection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,KAAK,EACV,4BAA4B,EAC5B,aAAa,EACd,MAAM,kBAAkB,CAAC;AAM1B;;;;;;;GAOG;AACH,qBAAa,qBAAqB,CAChC,QAAQ,CACR,YAAW,4BAA4B,CAAC,QAAQ,CAAC;IACjD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;gBAG3C,OAAO,GAAE;QACP;;;WAGG;QACH,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;KACzB;IASR,sBAAsB,CACpB,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,CAAC,OAAO,EAAE,QAAQ,KAAK,aAAa,EAC3C,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC;IAItC,mBAAmB,IAAI,IAAI;YAOb,YAAY;IA6B1B,OAAO,CAAC,cAAc;CAoCvB"}

package/dist/limiter/{FifoBlockingRejection.js → allocation-unavailable-strategies/FifoBlockingRejection.js}

@@ -36,7 +36,7 @@ export class FifoBlockingRejection {
             if (signal?.aborted) {
                 return undefined;
             }
-            const allotment = retry(context);
+            const allotment = await retry(context);
             if (allotment) {
                 return allotment;
             }

package/dist/limiter/{LifoBlockingRejection.d.ts → allocation-unavailable-strategies/LifoBlockingRejection.d.ts}

@@ -1,5 +1,5 @@
-import type { LimitAllotment } from "../LimitAllotment.js";
-import type { AllotmentUnavailableStrategy, AsyncAcquireResult, SyncAcquireResult } from "../Limiter.js";
+import type { LimitAllotment } from "../../LimitAllotment.js";
+import type { AllotmentUnavailableStrategy, AcquireResult } from "../../Limiter.js";
 export interface LifoBlockingRejectionOptions<ContextT> {
     /**
      * Maximum number of blocked callers in the backlog. Default: 100
@@ -18,14 +18,14 @@ export interface LifoBlockingRejectionOptions<ContextT> {
  * processing the most recently blocked request first, keeping success
  * latencies low and minimizing timeouts.
  */
-export declare class LifoBlockingRejection<ContextT> implements AllotmentUnavailableStrategy<ContextT, AsyncAcquireResult> {
+export declare class LifoBlockingRejection<ContextT> implements AllotmentUnavailableStrategy<ContextT> {
     private readonly backlogSize;
     private readonly getBacklogTimeout;
     private readonly backlog;
     private retry;
     constructor(options?: LifoBlockingRejectionOptions<ContextT>);
-    onAllotmentUnavailable(context: ContextT, retry: (context: ContextT) => SyncAcquireResult, signal?: AbortSignal): Promise<LimitAllotment | undefined>;
-    onAllotmentReleased(): void;
+    onAllotmentUnavailable(context: ContextT, retry: (context: ContextT) => AcquireResult, signal?: AbortSignal): Promise<LimitAllotment | undefined>;
+    onAllotmentReleased(): Promise<void>;
     private waitForBacklog;
 }
 //# sourceMappingURL=LifoBlockingRejection.d.ts.map