adaptive-concurrency 0.9.1 → 0.10.1

package/dist/Limiter.d.ts

@@ -121,6 +121,8 @@ export declare class Limiter<Context = void> {
     private readonly acquireFailedCounter;
     private readonly acquireBypassedCounter;
     private readonly limitGauge;
+    private readonly acquireTimeOnSuccessDistribution;
+    private readonly acquireTimeOnUnavailableDistribution;
     static makeDefaultLimit(): AdaptiveLimit;
     constructor(options?: LimiterOptions<Context>);
     acquire(options?: AcquireOptions<Context>): AcquireResult;

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

@@ -28,6 +28,8 @@ export class Limiter {
     acquireFailedCounter;
     acquireBypassedCounter;
     limitGauge;
+    acquireTimeOnSuccessDistribution;
+    acquireTimeOnUnavailableDistribution;
     static makeDefaultLimit() {
         return new GradientLimit();
     }
@@ -66,6 +68,8 @@ export class Limiter {
         this.acquireSucceededCounter = registry.counter(MetricIds.ACQUIRE_ATTEMPT_NAME, { id: limiterName, status: "succeeded" });
         this.acquireFailedCounter = registry.counter(MetricIds.ACQUIRE_ATTEMPT_NAME, { id: limiterName, status: "failed" });
         this.acquireBypassedCounter = registry.counter(MetricIds.ACQUIRE_ATTEMPT_NAME, { id: limiterName, status: "bypassed" });
+        this.acquireTimeOnSuccessDistribution = registry.distribution(MetricIds.ACQUIRE_TIME_NAME, { id: limiterName, status: "success" });
+        this.acquireTimeOnUnavailableDistribution = registry.distribution(MetricIds.ACQUIRE_TIME_NAME, { id: limiterName, status: "unavailable" });
         this.acquireBypassedAllotment = {
             releaseAndRecordSuccess: async () => {
                 this.successCounter.increment();
@@ -88,6 +92,7 @@ export class Limiter {
             this.acquireBypassedCounter.increment();
             return this.acquireBypassedAllotment;
         }
+        const acquireStart = this.clock();
         const state = {
             limit: this._limit,
             inflight: this._inflight,
@@ -95,21 +100,32 @@ export class Limiter {
         if (!(await this.acquireStrategy.tryAcquireAllotment(ctx, state))) {
             this.acquireFailedCounter.increment();
             if (!this.rejectionStrategy) {
+                this.acquireTimeOnUnavailableDistribution.addSample(this.clock() - acquireStart);
                 return undefined;
             }
-            // if signal aborted here, nothing to cleanup, as we didn't acquire anything.
+            // if signal aborted here, nothing to cleanup, as we didn't acquire
+            // anything. Also, don't try to record the acquire time, as we aborted
+            // mid-way (didn't invoke the rejection strategy).
             if (options?.signal?.aborted) {
                 return undefined;
             }
-            return this.rejectionStrategy.onAllotmentUnavailable(ctx, async (retryCtx) => {
+            const result = await this.rejectionStrategy.onAllotmentUnavailable(ctx, async (retryCtx) => {
                 if (options?.signal?.aborted) {
                     return undefined;
                 }
                 return this.tryAcquireCore(retryCtx);
             }, options?.signal);
+            const distribution = result
+                ? this.acquireTimeOnSuccessDistribution
+                : this.acquireTimeOnUnavailableDistribution;
+            distribution.addSample(this.clock() - acquireStart);
+            return result;
         }
         this.acquireSucceededCounter.increment();
         const allotment = this.createAllotment(ctx);
+        // Record the acquire time as a success, since we did actually succeed even
+        // if we abort below.
+        this.acquireTimeOnSuccessDistribution.addSample(this.clock() - acquireStart);
         if (options?.signal?.aborted) {
             // here, we did acquire, so we need to try to cleanup.
             await allotment.releaseAndIgnore();

package/dist/MetricRegistry.d.ts

@@ -15,6 +15,7 @@ export declare const MetricIds: {
     readonly MIN_RTT_NAME: "min_rtt";
     readonly WINDOW_MIN_RTT_NAME: "min_window_rtt";
     readonly WINDOW_QUEUE_SIZE_NAME: "queue_size";
+    readonly ACQUIRE_TIME_NAME: "acquire_time";
 };
 /**
  * Listener to receive samples for a distribution.

package/dist/MetricRegistry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MetricRegistry.d.ts","sourceRoot":"","sources":["../src/MetricRegistry.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS;;;;;;;;;CASZ,CAAC;AAEX;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AAED;;;GAGG;AACH,MAAM,WAAW,OAAO;IACtB,SAAS,IAAI,IAAI,CAAC;CACnB;AAED,0FAA0F;AAC1F,MAAM,WAAW,KAAK;IACpB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;;;;OAQG;IACH,YAAY,CACV,EAAE,EAAE,MAAM,EACV,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAClC,kBAAkB,CAAC;IAEtB;;;;;;;;OAQG;IACH,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IAE9D;;;;;OAKG;IACH,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC;CACnE;AAMD;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,cAUhC,CAAC"}
+{"version":3,"file":"MetricRegistry.d.ts","sourceRoot":"","sources":["../src/MetricRegistry.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;CAUZ,CAAC;AAEX;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AAED;;;GAGG;AACH,MAAM,WAAW,OAAO;IACtB,SAAS,IAAI,IAAI,CAAC;CACnB;AAED,0FAA0F;AAC1F,MAAM,WAAW,KAAK;IACpB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;;;;OAQG;IACH,YAAY,CACV,EAAE,EAAE,MAAM,EACV,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAClC,kBAAkB,CAAC;IAEtB;;;;;;;;OAQG;IACH,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IAE9D;;;;;OAKG;IACH,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC;CACnE;AAMD;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,cAUhC,CAAC"}

package/dist/MetricRegistry.js

@@ -15,6 +15,7 @@ export const MetricIds = {
     MIN_RTT_NAME: "min_rtt",
     WINDOW_MIN_RTT_NAME: "min_window_rtt",
     WINDOW_QUEUE_SIZE_NAME: "queue_size",
+    ACQUIRE_TIME_NAME: "acquire_time",
 };
 const NOOP_SAMPLE_LISTENER = { addSample() { } };
 const NOOP_COUNTER = { increment() { } };

package/dist/limit/AIMDLimit.d.ts

@@ -17,6 +17,16 @@ export interface AIMDLimitOptions {
      * Default: 5000
      */
     timeout?: number;
+    /**
+     * Absolute amount to use as a +/- jitter band around `backoffRatio` for
+     * each multiplicative decrease. Breaks lockstep oscillation when multiple
+     * independent clients share the same configuration.
+     *
+     * For example, with `backoffRatio: 0.9` and `backoffJitter: 0.02`, each
+     * decrease multiplies by a uniformly random value in [0.88, 0.92].
+     * Must be in [0, 0.05]. Default: 0.02.
+     */
+    backoffJitter?: number;
 }
 export declare class AIMDLimit implements AdaptiveLimit {
     private _limit;
@@ -25,6 +35,7 @@ export declare class AIMDLimit implements AdaptiveLimit {
     private readonly timeout;
     private readonly minLimit;
     private readonly maxLimit;
+    private readonly backoffJitter;
     constructor(options?: AIMDLimitOptions);
     addSample(_startTime: number, rtt: number, inflight: number, didDrop: boolean): void;
     get currentLimit(): number;

package/dist/limit/AIMDLimit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AIMDLimit.d.ts","sourceRoot":"","sources":["../../src/limit/AIMDLimit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,SAAU,YAAW,aAAa;IAC7C,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAqB;IAEpD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;gBAEtB,OAAO,GAAE,gBAAqB;IAiB1C,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI;IAapF,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,OAAO,CAAC,aAAa;IAOrB,SAAS,CACP,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,EACpC,OAAO,GAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAO,GACrC,MAAM,IAAI;IAIb,QAAQ,IAAI,MAAM;CAGnB"}
+{"version":3,"file":"AIMDLimit.d.ts","sourceRoot":"","sources":["../../src/limit/AIMDLimit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;;;;;;OAQG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,qBAAa,SAAU,YAAW,aAAa;IAC7C,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAqB;IAEpD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;gBAE3B,OAAO,GAAE,gBAAqB;IA0B1C,SAAS,CACP,UAAU,EAAE,MAAM,EAClB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,OAAO,GACf,IAAI;IAuBP,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,OAAO,CAAC,aAAa;IAOrB,SAAS,CACP,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,EACpC,OAAO,GAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAO,GACrC,MAAM,IAAI;IAIb,QAAQ,IAAI,MAAM;CAGnB"}

package/dist/limit/AIMDLimit.js

@@ -6,6 +6,7 @@ export class AIMDLimit {
     timeout;
     minLimit;
     maxLimit;
+    backoffJitter;
     constructor(options = {}) {
         const initialLimit = options.initialLimit ?? 20;
         this._limit = initialLimit;
@@ -13,19 +14,27 @@ export class AIMDLimit {
         this.timeout = options.timeout ?? 5_000;
         this.minLimit = options.minLimit ?? 20;
         this.maxLimit = options.maxLimit ?? 200;
+        this.backoffJitter = options.backoffJitter ?? 0.02;
         if (this.backoffRatio >= 1.0 || this.backoffRatio < 0.5) {
             throw new Error("Backoff ratio must be in the range [0.5, 1.0)");
         }
         if (this.timeout <= 0) {
             throw new Error("Timeout must be positive");
         }
+        if (this.backoffJitter < 0 || this.backoffJitter > 0.05) {
+            throw new Error("backoffJitter must be in the range [0, 0.05]");
+        }
+        if (this.backoffRatio + this.backoffJitter >= 1.0) {
+            throw new Error("backoffRatio + backoffJitter must be < 1.0 to guarantee the limit decreases on drop");
+        }
     }
     addSample(_startTime, rtt, inflight, didDrop) {
         let currentLimit = this._limit;
         if (didDrop || rtt > this.timeout) {
-            currentLimit = Math.floor(currentLimit * this.backoffRatio);
+            const jitteredRatio = Math.max(0.5, Math.min(1 - Number.EPSILON, this.backoffRatio + (Math.random() * 2 - 1) * this.backoffJitter));
+            currentLimit = Math.floor(currentLimit * jitteredRatio);
         }
-        else if (inflight * 2 >= currentLimit) {
+        else if (inflight >= 0.5 * currentLimit) {
             currentLimit = currentLimit + 1;
         }
         const newLimit = Math.min(this.maxLimit, Math.max(this.minLimit, currentLimit));

package/dist/limit/OperationGroupedLimit.d.ts

@@ -0,0 +1,78 @@
+import type { AdaptiveLimit } from "./StreamingLimit.js";
+/**
+ * Decorator that normalizes RTT samples by operation group before forwarding
+ * them to a delegate {@link AdaptiveLimit}.
+ *
+ * When a single limiter covers heterogeneous operations (e.g. fast reads and
+ * slow writes), raw RTT variance can reflect the **operation mix** rather than
+ * downstream congestion. A shift toward slower operations looks like a latency
+ * spike and causes the delegate to needlessly reduce the limit.
+ *
+ * `OperationGroupedLimit` solves this by maintaining a per-group RTT baseline
+ * (exponential moving average with a long window). Each sample's RTT is
+ * expressed as a ratio relative to its group's own baseline, then scaled by a
+ * fixed reference value:
+ *
+ *     normalizedRtt = (rtt / groupBaseline) × referenceRtt
+ *
+ * `referenceRtt` is a constant configured at construction time (derived from
+ * the first group's baseline after warmup if not explicitly provided). Because
+ * it never changes, a shift in operation mix cannot cause a spurious RTT spike.
+ * Meanwhile, real congestion within any group shows through because it causes
+ * `rtt / groupBaseline > 1`.
+ *
+ * Per-group baselines use a long EMA window so they represent the group's
+ * **intrinsic** latency characteristic and don't absorb short-term congestion.
+ *
+ * The `groupFor` function maps each sample to a group key. Samples whose group
+ * cannot be determined (returns `undefined`) are forwarded with their raw RTT.
+ */
+export declare class OperationGroupedLimit implements AdaptiveLimit {
+    private readonly delegate;
+    private readonly groupFor;
+    private readonly groups;
+    private readonly groupWindow;
+    private readonly groupWarmup;
+    /**
+     * Fixed reference RTT used as the absolute scale for normalized values.
+     * Once set, it never changes, ensuring mix shifts don't affect normalization.
+     * `undefined` until enough samples have been seen to establish it.
+     */
+    private referenceRtt;
+    private readonly configuredReferenceRtt;
+    constructor(delegate: AdaptiveLimit, options: {
+        /**
+         * Maps a sample's `startTime` to its operation group key.
+         *
+         * In practice, the caller records the group when acquiring a limiter
+         * allotment (at which point `startTime` is captured by the `Limiter`),
+         * then provides a lookup here that resolves that `startTime` back to the
+         * group. Returning `undefined` forwards the sample unnormalized.
+         */
+        groupFor: (startTime: number) => string | undefined;
+        /**
+         * EMA window size for per-group RTT baselines. These should be long
+         * enough to represent the group's intrinsic latency so short-term
+         * congestion shows through as deviations. Default: 500
+         */
+        groupWindow?: number;
+        /**
+         * Number of initial samples averaged arithmetically before switching to
+         * exponential decay (per-group). Default: 10
+         */
+        groupWarmup?: number;
+        /**
+         * Fixed reference RTT (in milliseconds) used as the scale for all
+         * normalized values. If not provided, it is automatically set from the
+         * first group's baseline after its warmup phase completes.
+         */
+        referenceRtt?: number;
+    });
+    addSample(startTime: number, rtt: number, inflight: number, didDrop: boolean): void;
+    get currentLimit(): number;
+    subscribe(consumer: (newLimit: number) => void, options?: {
+        signal?: AbortSignal;
+    }): () => void;
+    toString(): string;
+}
+//# sourceMappingURL=OperationGroupedLimit.d.ts.map

package/dist/limit/OperationGroupedLimit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OperationGroupedLimit.d.ts","sourceRoot":"","sources":["../../src/limit/OperationGroupedLimit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,qBAAsB,YAAW,aAAa;IACzD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgB;IACzC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA4C;IACrE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuC;IAC9D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IAErC;;;;OAIG;IACH,OAAO,CAAC,YAAY,CAAqB;IACzC,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAqB;gBAG1D,QAAQ,EAAE,aAAa,EACvB,OAAO,EAAE;QACP;;;;;;;WAOG;QACH,QAAQ,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;QAEpD;;;;WAIG;QACH,WAAW,CAAC,EAAE,MAAM,CAAC;QAErB;;;WAGG;QACH,WAAW,CAAC,EAAE,MAAM,CAAC;QAErB;;;;WAIG;QACH,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB;IAUH,SAAS,CACP,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,OAAO,GACf,IAAI;IAqCP,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,SAAS,CACP,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,EACpC,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GACjC,MAAM,IAAI;IAIb,QAAQ,IAAI,MAAM;CAOnB"}

package/dist/limit/OperationGroupedLimit.js

@@ -0,0 +1,93 @@
+import { ExpMovingAverage } from "../statistics/ExpMovingAverage.js";
+/**
+ * Decorator that normalizes RTT samples by operation group before forwarding
+ * them to a delegate {@link AdaptiveLimit}.
+ *
+ * When a single limiter covers heterogeneous operations (e.g. fast reads and
+ * slow writes), raw RTT variance can reflect the **operation mix** rather than
+ * downstream congestion. A shift toward slower operations looks like a latency
+ * spike and causes the delegate to needlessly reduce the limit.
+ *
+ * `OperationGroupedLimit` solves this by maintaining a per-group RTT baseline
+ * (exponential moving average with a long window). Each sample's RTT is
+ * expressed as a ratio relative to its group's own baseline, then scaled by a
+ * fixed reference value:
+ *
+ *     normalizedRtt = (rtt / groupBaseline) × referenceRtt
+ *
+ * `referenceRtt` is a constant configured at construction time (derived from
+ * the first group's baseline after warmup if not explicitly provided). Because
+ * it never changes, a shift in operation mix cannot cause a spurious RTT spike.
+ * Meanwhile, real congestion within any group shows through because it causes
+ * `rtt / groupBaseline > 1`.
+ *
+ * Per-group baselines use a long EMA window so they represent the group's
+ * **intrinsic** latency characteristic and don't absorb short-term congestion.
+ *
+ * The `groupFor` function maps each sample to a group key. Samples whose group
+ * cannot be determined (returns `undefined`) are forwarded with their raw RTT.
+ */
+export class OperationGroupedLimit {
+    delegate;
+    groupFor;
+    groups = new Map();
+    groupWindow;
+    groupWarmup;
+    /**
+     * Fixed reference RTT used as the absolute scale for normalized values.
+     * Once set, it never changes, ensuring mix shifts don't affect normalization.
+     * `undefined` until enough samples have been seen to establish it.
+     */
+    referenceRtt;
+    configuredReferenceRtt;
+    constructor(delegate, options) {
+        this.delegate = delegate;
+        this.groupFor = options.groupFor;
+        this.groupWindow = options.groupWindow ?? 500;
+        this.groupWarmup = options.groupWarmup ?? 10;
+        this.configuredReferenceRtt = options.referenceRtt;
+        this.referenceRtt = options.referenceRtt;
+    }
+    addSample(startTime, rtt, inflight, didDrop) {
+        const group = this.groupFor(startTime);
+        if (group === undefined) {
+            this.delegate.addSample(startTime, rtt, inflight, didDrop);
+            return;
+        }
+        let groupEma = this.groups.get(group);
+        let isNew = false;
+        if (!groupEma) {
+            groupEma = new ExpMovingAverage(this.groupWindow, this.groupWarmup);
+            this.groups.set(group, groupEma);
+            isNew = true;
+        }
+        // Read the group baseline *before* incorporating this sample so that the
+        // current observation doesn't immediately anchor its own normalization.
+        const prevGroupBaseline = groupEma.currentValue;
+        groupEma.addSample(rtt);
+        // Auto-detect the reference RTT from the first group's baseline once its
+        // warmup is complete.
+        if (this.referenceRtt === undefined && !isNew && prevGroupBaseline > 0) {
+            this.referenceRtt = prevGroupBaseline;
+        }
+        let normalizedRtt;
+        if (prevGroupBaseline <= 0 || this.referenceRtt === undefined) {
+            normalizedRtt = rtt;
+        }
+        else {
+            normalizedRtt = (rtt / prevGroupBaseline) * this.referenceRtt;
+        }
+        this.delegate.addSample(startTime, normalizedRtt, inflight, didDrop);
+    }
+    get currentLimit() {
+        return this.delegate.currentLimit;
+    }
+    subscribe(consumer, options) {
+        return this.delegate.subscribe(consumer, options);
+    }
+    toString() {
+        return (`OperationGroupedLimit [groups=${this.groups.size}` +
+            `, referenceRtt=${this.referenceRtt?.toFixed(3) ?? "pending"}` +
+            `, delegate=${this.delegate}]`);
+    }
+}

package/dist/limit/VegasLimit.d.ts

@@ -43,9 +43,10 @@ export interface VegasLimitOptions {
          */
         increase?(limit: number): number;
         /**
-         * Compute the new limit when decreasing.
+         * Compute the new limit when decreasing. If didDrop is true, decrease() is
+         * being called because of a drop.
          */
-        decrease?(limit: number): number;
+        decrease?(limit: number, didDrop: boolean): number;
     };
     /**
      * The limiter will probe for a new noload RTT every
@@ -66,9 +67,9 @@ export declare class VegasLimit implements AdaptiveLimit {
     private readonly smoothing;
     private readonly policy;
     private readonly rttSampleListener;
-    private readonly probeMultiplier;
     private probeCount;
     private probeJitter;
+    private readonly probeMultiplier;
     constructor(options?: VegasLimitOptions);
     private resetProbeJitter;
     private shouldProbe;

package/dist/limit/VegasLimit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VegasLimit.d.ts","sourceRoot":"","sources":["../../src/limit/VegasLimit.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAsB,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE/E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAezD;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,iBAAiB;IAChC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,MAAM,CAAC,EAAE;QACP;;;;WAIG;QACH,KAAK,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;QAE9B;;;;WAIG;QACH,IAAI,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;QAE7B;;WAEG;QACH,SAAS,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;QAElC;;WAEG;QACH,QAAQ,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;QAEjC;;WAEG;QACH,QAAQ,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;KAClC,CAAC;IAEF;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;AAED,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC,WAAW,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;AAElF,qBAAa,UAAW,YAAW,aAAa;IAC9C,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAqB;IAEpD,yDAAyD;IACzD,OAAO,CAAC,cAAc,CAAS;IAE/B,OAAO,CAAC,SAAS,CAAK;IAEtB,8DAA8D;IAC9D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAElC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAmB;IAC1C,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAqB;IACvD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IACzC,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,WAAW,CAAS;gBAEhB,OAAO,GAAE,iBAAsB;IAuB3C,OAAO,CAAC,gBAAgB;IAKxB,OAAO,CAAC,WAAW;IAInB,SAAS,CACP,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,OAAO,GACf,IAAI;IAIP,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,OAAO,CAAC,aAAa;IAOrB,SAAS,CACP,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,EACpC,OAAO,GAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAO,GACrC,MAAM,IAAI;IAIb,OAAO,CAAC,gBAAgB;IA6BxB,OAAO,CAAC,oBAAoB;IA0C5B,QAAQ,IAAI,MAAM;CAGnB"}
+{"version":3,"file":"VegasLimit.d.ts","sourceRoot":"","sources":["../../src/limit/VegasLimit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAsB,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE/E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAezD;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,iBAAiB;IAChC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,MAAM,CAAC,EAAE;QACP;;;;WAIG;QACH,KAAK,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;QAE9B;;;;WAIG;QACH,IAAI,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;QAE7B;;WAEG;QACH,SAAS,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;QAElC;;WAEG;QACH,QAAQ,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;QAEjC;;;WAGG;QACH,QAAQ,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC;KACpD,CAAC;IAEF;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;AAED,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CACrC,WAAW,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC,CACzC,CAAC;AAEF,qBAAa,UAAW,YAAW,aAAa;IAC9C,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAqB;IAEpD,yDAAyD;IACzD,OAAO,CAAC,cAAc,CAAS;IAE/B,OAAO,CAAC,SAAS,CAAK;IAEtB,8DAA8D;IAC9D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAElC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAmB;IAC1C,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAqB;IAEvD,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;gBAE7B,OAAO,GAAE,iBAAsB;IAyB3C,OAAO,CAAC,gBAAgB;IAKxB,OAAO,CAAC,WAAW;IAOnB,SAAS,CACP,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,OAAO,GACf,IAAI;IAMP,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,OAAO,CAAC,aAAa;IAOrB,SAAS,CACP,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,EACpC,OAAO,GAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAO,GACrC,MAAM,IAAI;IAIb,OAAO,CAAC,gBAAgB;IA+BxB,OAAO,CAAC,oBAAoB;IA2C5B,QAAQ,IAAI,MAAM;CAGnB"}

package/dist/limit/VegasLimit.js

@@ -1,6 +1,5 @@
 import { ListenerSet } from "../ListenerSet.js";
-import { MetricIds } from "../MetricRegistry.js";
-import { NoopMetricRegistry } from "../MetricRegistry.js";
+import { MetricIds, NoopMetricRegistry } from "../MetricRegistry.js";
 /**
  * Sublinear scale of the concurrency limit (floor of log10, lower-bounded for
  * small n). Same idea as Netflix's Log10RootIntFunction. Used only for
@@ -21,9 +20,9 @@ export class VegasLimit {
     smoothing;
     policy;
     rttSampleListener;
-    probeMultiplier;
     probeCount = 0;
     probeJitter;
+    probeMultiplier;
     constructor(options = {}) {
         const initialLimit = options.initialLimit ?? 20;
         this._limit = initialLimit;
@@ -47,7 +46,8 @@ export class VegasLimit {
         return this.probeJitter;
     }
     shouldProbe() {
-        return this.probeJitter * this.probeMultiplier * this.estimatedLimit <= this.probeCount;
+        return (this.probeJitter * this.probeMultiplier * this.estimatedLimit <=
+            this.probeCount);
     }
     addSample(startTime, rtt, inflight, didDrop) {
         this.applyNewLimit(this.computeNextLimit(startTime, rtt, inflight, didDrop));
@@ -73,11 +73,13 @@ export class VegasLimit {
             this.resetProbeJitter();
             this.probeCount = 0;
             this.rttNoload = rtt;
+            this.rttSampleListener.addSample(rtt);
             return Math.floor(this.estimatedLimit);
         }
         const rttNoload = this.rttNoload;
         if (rttNoload === 0 || rtt < rttNoload) {
             this.rttNoload = rtt;
+            this.rttSampleListener.addSample(rtt);
             return Math.floor(this.estimatedLimit);
         }
         this.rttSampleListener.addSample(rttNoload);
@@ -89,7 +91,7 @@ export class VegasLimit {
         let newLimit;
         // Treat any drop (i.e timeout) as needing to reduce the limit
         if (didDrop) {
-            newLimit = this.policy.decrease(estimatedLimit);
+            newLimit = this.policy.decrease(estimatedLimit, didDrop);
             // Prevent upward drift if not close to the limit
         }
         else if (inflight * 2 < estimatedLimit) {
@@ -109,7 +111,7 @@ export class VegasLimit {
                 // Detecting latency so decrease
             }
             else if (queueSize > beta) {
-                newLimit = this.policy.decrease(estimatedLimit);
+                newLimit = this.policy.decrease(estimatedLimit, didDrop);
                 // We're within the sweet spot so nothing to do
             }
             else {
@@ -117,7 +119,8 @@ export class VegasLimit {
             }
         }
         newLimit = Math.max(1, Math.min(this.maxLimit, newLimit));
-        newLimit = (1 - this.smoothing) * estimatedLimit + this.smoothing * newLimit;
+        newLimit =
+            (1 - this.smoothing) * estimatedLimit + this.smoothing * newLimit;
         this.estimatedLimit = newLimit;
         return Math.floor(newLimit);
     }

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

@@ -0,0 +1,30 @@
+import type { AcquireResult, AllotmentUnavailableStrategy } from "../../Limiter.js";
+export type FifoBlockingRejectionOptions<ContextT> = {
+    /**
+     * Maximum number of blocked callers in the backlog.
+     * Default: unbounded
+     */
+    backlogSize?: number | undefined;
+    /**
+     * Maximum timeout for callers blocked on the limiter, in milliseconds.
+     * Can be a fixed number or a function that derives the timeout from the
+     * request context (e.g. from a deadline). Default: 3_600_000 (1 hour).
+     */
+    backlogTimeout?: number | ((context: ContextT) => number) | undefined;
+};
+/**
+ * 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
+ * fairness: callers are served in the order they arrived.
+ *
+ * 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> {
+    private readonly delegate;
+    constructor(options?: FifoBlockingRejectionOptions<ContextT>);
+    onAllotmentUnavailable(context: ContextT, retry: (context: ContextT) => AcquireResult, signal?: AbortSignal): Promise<import("../../LimitAllotment.js").LimitAllotment | undefined>;
+    onAllotmentReleased(): Promise<void>;
+    onLimitChanged(oldLimit: number, newLimit: number): void;
+}
+//# sourceMappingURL=FifoBlockingRejection.d.ts.map

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,EACV,aAAa,EACb,4BAA4B,EAC7B,MAAM,kBAAkB,CAAC;AAO1B,MAAM,MAAM,4BAA4B,CAAC,QAAQ,IAAI;IACnD;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAEjC;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,EAAE,QAAQ,KAAK,MAAM,CAAC,GAAG,SAAS,CAAC;CACvE,CAAC;AAEF;;;;;;;GAOG;AACH,qBAAa,qBAAqB,CAChC,QAAQ,CACR,YAAW,4BAA4B,CAAC,QAAQ,CAAC;IACjD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqC;gBAElD,OAAO,GAAE,4BAA4B,CAAC,QAAQ,CAAM;IAQhE,sBAAsB,CACpB,OAAO,EAAE,QAAQ,EACjB,KAAK,EAAE,CAAC,OAAO,EAAE,QAAQ,KAAK,aAAa,EAC3C,MAAM,CAAC,EAAE,WAAW;IAKtB,mBAAmB;IAInB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;CAGzD"}

package/dist/limiter/allocation-unavailable-strategies/FifoBlockingRejection.js

@@ -0,0 +1,29 @@
+import { LinkedWaiterQueue } from "../../utils/LinkedWaiterQueue.js";
+import { BlockingBacklogRejection, MAX_TIMEOUT, } from "./BlockingBacklogRejection.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
+ * fairness: callers are served in the order they arrived.
+ *
+ * Because JavaScript is single-threaded, "blocking" means awaiting a promise
+ * that resolves when a token becomes available.
+ */
+export class FifoBlockingRejection {
+    delegate;
+    constructor(options = {}) {
+        this.delegate = new BlockingBacklogRejection({
+            backlogSize: options.backlogSize ?? Number.POSITIVE_INFINITY,
+            backlogTimeout: options.backlogTimeout ?? MAX_TIMEOUT,
+            queue: new LinkedWaiterQueue("back"),
+        });
+    }
+    onAllotmentUnavailable(context, retry, signal) {
+        return this.delegate.onAllotmentUnavailable(context, retry, signal);
+    }
+    onAllotmentReleased() {
+        return this.delegate.onAllotmentReleased();
+    }
+    onLimitChanged(oldLimit, newLimit) {
+        this.delegate.onLimitChanged(oldLimit, newLimit);
+    }
+}

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

@@ -0,0 +1,27 @@
+import type { AcquireResult, AllotmentUnavailableStrategy } from "../../Limiter.js";
+export interface LifoBlockingRejectionOptions<ContextT> {
+    /**
+     * Maximum number of blocked callers in the backlog. Default: 100
+     */
+    backlogSize?: number | undefined;
+    /**
+     * Maximum timeout for callers blocked on the limiter, in milliseconds.
+     * Can be a fixed number or a function that derives the timeout from the
+     * request context (e.g. from a deadline). Default: 1000
+     */
+    backlogTimeout?: number | ((context: ContextT) => number) | undefined;
+}
+/**
+ * Rejection strategy that blocks the caller in a LIFO queue when the limit
+ * has been reached. This strategy favors availability over latency by
+ * processing the most recently blocked request first, keeping success
+ * latencies low and minimizing timeouts.
+ */
+export declare class LifoBlockingRejection<ContextT> implements AllotmentUnavailableStrategy<ContextT> {
+    private readonly delegate;
+    constructor(options?: LifoBlockingRejectionOptions<ContextT>);
+    onAllotmentUnavailable(context: ContextT, retry: (context: ContextT) => AcquireResult, signal?: AbortSignal): Promise<import("../../LimitAllotment.js").LimitAllotment | undefined>;
+    onAllotmentReleased(): Promise<void>;
+    onLimitChanged(oldLimit: number, newLimit: number): void;
+}
+//# sourceMappingURL=LifoBlockingRejection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LifoBlockingRejection.d.ts","sourceRoot":"","sources":["../../../src/limiter/allocation-unavailable-strategies/LifoBlockingRejection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,4BAA4B,EAC7B,MAAM,kBAAkB,CAAC;AAM1B,MAAM,WAAW,4BAA4B,CAAC,QAAQ;IACpD;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAEjC;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,EAAE,QAAQ,KAAK,MAAM,CAAC,GAAG,SAAS,CAAC;CACvE;AAED;;;;;GAKG;AACH,qBAAa,qBAAqB,CAChC,QAAQ,CACR,YAAW,4BAA4B,CAAC,QAAQ,CAAC;IACjD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqC;gBAElD,OAAO,GAAE,4BAA4B,CAAC,QAAQ,CAAM;IAQhE,sBAAsB,CACpB,OAAO,EAAE,QAAQ,EACjB,KAAK,EAAE,CAAC,OAAO,EAAE,QAAQ,KAAK,aAAa,EAC3C,MAAM,CAAC,EAAE,WAAW;IAKtB,mBAAmB;IAInB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;CAGzD"}

package/dist/limiter/allocation-unavailable-strategies/LifoBlockingRejection.js

@@ -0,0 +1,27 @@
+import { LinkedWaiterQueue } from "../../utils/LinkedWaiterQueue.js";
+import { BlockingBacklogRejection, } from "./BlockingBacklogRejection.js";
+/**
+ * Rejection strategy that blocks the caller in a LIFO queue when the limit
+ * has been reached. This strategy favors availability over latency by
+ * processing the most recently blocked request first, keeping success
+ * latencies low and minimizing timeouts.
+ */
+export class LifoBlockingRejection {
+    delegate;
+    constructor(options = {}) {
+        this.delegate = new BlockingBacklogRejection({
+            backlogSize: options.backlogSize ?? 100,
+            backlogTimeout: options.backlogTimeout ?? 1_000,
+            queue: new LinkedWaiterQueue("front"),
+        });
+    }
+    onAllotmentUnavailable(context, retry, signal) {
+        return this.delegate.onAllotmentUnavailable(context, retry, signal);
+    }
+    onAllotmentReleased() {
+        return this.delegate.onAllotmentReleased();
+    }
+    onLimitChanged(oldLimit, newLimit) {
+        this.delegate.onLimitChanged(oldLimit, newLimit);
+    }
+}

package/package.json

@@ -9,7 +9,7 @@
     "dynamic rate limiting"
   ],
   "author": "Ethan Resnick <ethan.resnick@gmail.com>",
-  "version": "0.9.1",
+  "version": "0.10.1",
   "type": "module",
   "exports": {
     ".": {