adaptive-concurrency 0.1.0

package/dist/MetricRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetricRegistry.d.ts","sourceRoot":"","sources":["../src/MetricRegistry.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,SAAS;;;;;;;;CAQZ,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,WAAW;CAAG;AAE/B;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;;;;OAQG;IACH,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,iBAAiB,EAAE,MAAM,EAAE,GAAG,kBAAkB,CAAC;IAE7E;;;;;;;;OAQG;IACH,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,MAAM,EAAE,GAAG,iBAAiB,EAAE,MAAM,EAAE,GAAG,WAAW,CAAC;IAEvF;;;;;OAKG;IACH,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC;CAClE;AAMD;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,cAUhC,CAAC"}

package/dist/MetricRegistry.js

@@ -0,0 +1,30 @@
+/**
+ * Common metric ids used by the limiters and limit algorithms.
+ */
+export const MetricIds = {
+    LIMIT_NAME: "limit",
+    CALL_NAME: "call",
+    INFLIGHT_NAME: "inflight",
+    PARTITION_LIMIT_NAME: "limit.partition",
+    MIN_RTT_NAME: "min_rtt",
+    WINDOW_MIN_RTT_NAME: "min_window_rtt",
+    WINDOW_QUEUE_SIZE_NAME: "queue_size",
+};
+const NOOP_SAMPLE_LISTENER = { addSample() { } };
+const NOOP_COUNTER = { increment() { } };
+const NOOP_GAUGE = {};
+/**
+ * No-op MetricRegistry that discards all metrics. Used as the default when
+ * no registry is configured.
+ */
+export const NoopMetricRegistry = {
+    distribution() {
+        return NOOP_SAMPLE_LISTENER;
+    },
+    gauge() {
+        return NOOP_GAUGE;
+    },
+    counter() {
+        return NOOP_COUNTER;
+    },
+};

package/dist/RunResult.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Returned when {@link Limiter.run} cannot obtain an allotment (sync reject or
+ * async wait exhausted / aborted). Distinct from {@link runDropped}, which
+ * represents work that ran and then reported a drop.
+ */
+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.
+ */
+export declare class AdaptiveTimeoutError extends Error {
+    readonly code: "ADAPTIVE_TIMEOUT";
+    constructor(message?: string);
+}
+export declare function isAdaptiveTimeoutError(error: unknown): error is AdaptiveTimeoutError;
+export interface RunSuccess<T> {
+    readonly kind: "success";
+    readonly value: T;
+}
+export interface RunIgnore<T> {
+    readonly kind: "ignore";
+    readonly value: T;
+}
+export interface RunDropped<E extends Error = Error> {
+    readonly kind: "dropped";
+    readonly error: E;
+}
+export type RunResult<T, E extends Error = Error> = RunSuccess<T> | RunIgnore<T> | RunDropped<E>;
+export declare function success<T>(value: T): RunSuccess<T>;
+export declare function ignore<T>(value: T): RunIgnore<T>;
+export declare function dropped<E extends Error>(error: E): RunDropped<E>;
+//# sourceMappingURL=RunResult.d.ts.map

package/dist/RunResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RunResult.d.ts","sourceRoot":"","sources":["../src/RunResult.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,eAA8B,CAAC;AAE7D;;;;GAIG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,IAAI,qBAA+B;gBAEhC,OAAO,CAAC,EAAE,MAAM;CAI7B;AAED,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,oBAAoB,CAQ/B;AAED,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CACnB;AAED,MAAM,WAAW,SAAS,CAAC,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CACnB;AAED,MAAM,WAAW,UAAU,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK;IACjD,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CACnB;AAED,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,KAAK,GAAG,KAAK,IAC5C,UAAU,CAAC,CAAC,CAAC,GACb,SAAS,CAAC,CAAC,CAAC,GACZ,UAAU,CAAC,CAAC,CAAC,CAAC;AAElB,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAElD;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAEhD;AAED,wBAAgB,OAAO,CAAC,CAAC,SAAS,KAAK,EAAE,KAAK,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAEhE"}

package/dist/RunResult.js

@@ -0,0 +1,35 @@
+const ADAPTIVE_TIMEOUT_ERROR_CODE = "ADAPTIVE_TIMEOUT";
+/**
+ * Returned when {@link Limiter.run} cannot obtain an allotment (sync reject or
+ * async wait exhausted / aborted). Distinct from {@link runDropped}, which
+ * represents work that ran and then reported a drop.
+ */
+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.
+ */
+export class AdaptiveTimeoutError extends Error {
+    code = ADAPTIVE_TIMEOUT_ERROR_CODE;
+    constructor(message) {
+        super(message ?? "Operation timed out");
+        this.name = "AdaptiveTimeoutError";
+    }
+}
+export function isAdaptiveTimeoutError(error) {
+    return (error instanceof AdaptiveTimeoutError ||
+        (typeof error === "object" &&
+            error !== null &&
+            "code" in error &&
+            error.code === ADAPTIVE_TIMEOUT_ERROR_CODE));
+}
+export function success(value) {
+    return { kind: "success", value };
+}
+export function ignore(value) {
+    return { kind: "ignore", value };
+}
+export function dropped(error) {
+    return { kind: "dropped", error };
+}

package/dist/StreamingLimit.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Contract for an algorithm that maintains a concurrency limit from a stream
+ * of RTT samples, analogous to StreamingStatistic for numeric sample streams.
+ */
+export interface StreamingLimit {
+    /** Current estimated concurrency limit. */
+    get currentLimit(): number;
+    /**
+     * Subscribe to limit changes. The callback runs whenever the limit updates.
+     *
+     * Returns a function to unsubscribe. Optional AbortSignal support is
+     * provided for ergonomic cancellation.
+     */
+    subscribe(consumer: (newLimit: number) => void, options?: {
+        signal?: AbortSignal;
+    }): () => void;
+    /**
+     * Adjust the estimated limit using a completed request sample.
+     * @param startTime Start time in fractional milliseconds (from performance.now())
+     * @param rtt Round trip time in fractional milliseconds
+     * @param inflight Number of inflight requests at the time the request started
+     * @param didDrop Whether the request was dropped (timeout or rejection)
+     */
+    accumulateSample(startTime: number, rtt: number, inflight: number, didDrop: boolean): void;
+}
+//# sourceMappingURL=StreamingLimit.d.ts.map

package/dist/StreamingLimit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StreamingLimit.d.ts","sourceRoot":"","sources":["../src/StreamingLimit.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,2CAA2C;IAC3C,IAAI,YAAY,IAAI,MAAM,CAAC;IAE3B;;;;;OAKG;IACH,SAAS,CACP,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,EACpC,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GACjC,MAAM,IAAI,CAAC;IAEd;;;;;;OAMG;IACH,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;CAC5F"}

package/dist/StreamingLimit.js

@@ -0,0 +1 @@
+export {};

package/dist/executors/AdaptiveExecutor.d.ts

@@ -0,0 +1,50 @@
+import type { AcquireResult } from "../Limiter.js";
+/**
+ * Error type that represents an operation timeout or external drop event.
+ */
+export declare class AdaptiveTimeoutError extends Error {
+    readonly code: "ADAPTIVE_TIMEOUT";
+    constructor(message?: string);
+}
+/**
+ * @deprecated Use AdaptiveTimeoutError instead.
+ */
+export declare class UncheckedTimeoutError extends AdaptiveTimeoutError {
+    constructor(message?: string);
+}
+export declare function isAdaptiveTimeoutError(error: unknown): error is AdaptiveTimeoutError;
+/**
+ * Error type used when work is rejected because no execution slot is available.
+ */
+export declare class ConcurrencyLimitExceededError extends Error {
+    constructor(message?: string);
+}
+export interface AdaptiveExecutorOptions {
+    /**
+     * Limiter to gate concurrent executions. Must have an `acquire()` method
+     * that returns an AcquireResult. Default: Limiter with AIMDLimit.
+     */
+    limiter?: {
+        acquire(): AcquireResult;
+    };
+}
+/**
+ * Executor which uses a Limiter to determine the concurrency level.
+ * Any function submitted once the limit has been reached will be rejected.
+ *
+ * Operations submitted to this executor should be homogeneous and have similar
+ * long term latency characteristics. RTT samples will only be taken from
+ * successful operations. The function should throw an
+ * {@link AdaptiveTimeoutError} if a request timed out or some external limit
+ * was reached. All other exceptions will be ignored (treated as reportIgnore).
+ */
+export declare class AdaptiveExecutor {
+    private readonly limiter;
+    constructor(options?: AdaptiveExecutorOptions);
+    /**
+     * Execute an async function, gated by the adaptive concurrency limit.
+     * Throws if the limit has been reached and no token can be acquired.
+     */
+    execute<T>(fn: () => Promise<T>): Promise<T>;
+}
+//# sourceMappingURL=AdaptiveExecutor.d.ts.map

package/dist/executors/AdaptiveExecutor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdaptiveExecutor.d.ts","sourceRoot":"","sources":["../../src/executors/AdaptiveExecutor.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAKnD;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,IAAI,qBAA+B;gBAEhC,OAAO,CAAC,EAAE,MAAM;CAI7B;AAED;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,oBAAoB;gBACjD,OAAO,CAAC,EAAE,MAAM;CAI7B;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,oBAAoB,CAQpF;AAED;;GAEG;AACH,qBAAa,6BAA8B,SAAQ,KAAK;gBAC1C,OAAO,CAAC,EAAE,MAAM;CAI7B;AAED,MAAM,WAAW,uBAAuB;IACtC;;;OAGG;IACH,OAAO,CAAC,EAAE;QAAE,OAAO,IAAI,aAAa,CAAA;KAAE,CAAC;CACxC;AAED;;;;;;;;;GASG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA+B;gBAE3C,OAAO,GAAE,uBAA4B;IAMjD;;;OAGG;IACG,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;CAmBnD"}

package/dist/executors/AdaptiveExecutor.js

@@ -0,0 +1,80 @@
+import { Limiter } from "../Limiter.js";
+import { AIMDLimit } from "../limit/AIMDLimit.js";
+const ADAPTIVE_TIMEOUT_ERROR_CODE = "ADAPTIVE_TIMEOUT";
+/**
+ * Error type that represents an operation timeout or external drop event.
+ */
+export class AdaptiveTimeoutError extends Error {
+    code = ADAPTIVE_TIMEOUT_ERROR_CODE;
+    constructor(message) {
+        super(message ?? "Operation timed out");
+        this.name = "AdaptiveTimeoutError";
+    }
+}
+/**
+ * @deprecated Use AdaptiveTimeoutError instead.
+ */
+export class UncheckedTimeoutError extends AdaptiveTimeoutError {
+    constructor(message) {
+        super(message);
+        this.name = "UncheckedTimeoutError";
+    }
+}
+export function isAdaptiveTimeoutError(error) {
+    return (error instanceof AdaptiveTimeoutError ||
+        (typeof error === "object" &&
+            error !== null &&
+            "code" in error &&
+            error.code === ADAPTIVE_TIMEOUT_ERROR_CODE));
+}
+/**
+ * Error type used when work is rejected because no execution slot is available.
+ */
+export class ConcurrencyLimitExceededError extends Error {
+    constructor(message) {
+        super(message ?? "Concurrency limit exceeded");
+        this.name = "ConcurrencyLimitExceededError";
+    }
+}
+/**
+ * Executor which uses a Limiter to determine the concurrency level.
+ * Any function submitted once the limit has been reached will be rejected.
+ *
+ * Operations submitted to this executor should be homogeneous and have similar
+ * long term latency characteristics. RTT samples will only be taken from
+ * successful operations. The function should throw an
+ * {@link AdaptiveTimeoutError} if a request timed out or some external limit
+ * was reached. All other exceptions will be ignored (treated as reportIgnore).
+ */
+export class AdaptiveExecutor {
+    limiter;
+    constructor(options = {}) {
+        this.limiter =
+            options.limiter ??
+                new Limiter({ limit: new AIMDLimit() });
+    }
+    /**
+     * Execute an async function, gated by the adaptive concurrency limit.
+     * Throws if the limit has been reached and no token can be acquired.
+     */
+    async execute(fn) {
+        const allotment = await this.limiter.acquire();
+        if (!allotment) {
+            throw new ConcurrencyLimitExceededError();
+        }
+        try {
+            const result = await fn();
+            allotment.reportSuccess();
+            return result;
+        }
+        catch (e) {
+            if (isAdaptiveTimeoutError(e)) {
+                allotment.reportDropped();
+            }
+            else {
+                allotment.reportIgnore();
+            }
+            throw e;
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+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 { 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";
+export { AIMDLimit, type AIMDLimitOptions } from "./limit/AIMDLimit.js";
+export { FixedLimit } from "./limit/FixedLimit.js";
+export { GradientLimit, type Gradient2LimitOptions, } from "./limit/GradientLimit.js";
+export { SettableLimit } from "./limit/SettableLimit.js";
+export { TracingLimitDecorator } from "./limit/TracingLimitDecorator.js";
+export { VegasLimit, type VegasLimitOptions, type VegasLimitPolicy, } from "./limit/VegasLimit.js";
+export { WindowedLimit, type WindowedLimitOptions, } from "./limit/WindowedLimit.js";
+export { ExpMovingAverage } from "./statistics/ExpMovingAverage.js";
+export { MinimumValue } from "./statistics/MinimumValue.js";
+export type { StreamingStatistic } from "./statistics/StreamingStatistic.js";
+export { makeAverageSampleWindow } from "./limit/window/AverageSampleWindow.js";
+export { createPercentileSampleWindow } from "./limit/window/PercentileSampleWindow.js";
+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";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +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"}

package/dist/index.js

@@ -0,0 +1,28 @@
+export { Limiter, SemaphoreStrategy, whenAcquireSettled, 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";
+// Limit algorithms
+export { AIMDLimit } from "./limit/AIMDLimit.js";
+export { FixedLimit } from "./limit/FixedLimit.js";
+export { GradientLimit, } from "./limit/GradientLimit.js";
+export { SettableLimit } from "./limit/SettableLimit.js";
+export { TracingLimitDecorator } from "./limit/TracingLimitDecorator.js";
+export { VegasLimit, } from "./limit/VegasLimit.js";
+export { WindowedLimit, } from "./limit/WindowedLimit.js";
+// Streaming statistics
+export { ExpMovingAverage } from "./statistics/ExpMovingAverage.js";
+export { MinimumValue } from "./statistics/MinimumValue.js";
+// Sample window types
+export { makeAverageSampleWindow } from "./limit/window/AverageSampleWindow.js";
+export { createPercentileSampleWindow } from "./limit/window/PercentileSampleWindow.js";
+// Limit functions
+export { squareRoot, squareRootWithBaseline } from "./utils/index.js";
+// Acquire strategies
+export * from "./limiter/factories/index.js";
+export { PartitionedStrategy, } from "./limiter/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";

package/dist/limit/AIMDLimit.d.ts

@@ -0,0 +1,37 @@
+import type { AdaptiveLimit } from "./StreamingLimit.js";
+/**
+ * Loss based dynamic Limit that does an additive increment as long as
+ * there are no errors and a multiplicative decrement when there is an error.
+ */
+export interface AIMDLimitOptions {
+    initialLimit?: number;
+    minLimit?: number;
+    maxLimit?: number;
+    /**
+     * Ratio by which to reduce the limit on a drop. Must be in [0.5, 1.0).
+     * Default: 0.9
+     */
+    backoffRatio?: number;
+    /**
+     * Timeout threshold in milliseconds that when exceeded equates to a drop.
+     * Default: 5000
+     */
+    timeout?: number;
+}
+export declare class AIMDLimit implements AdaptiveLimit {
+    private _limit;
+    private readonly limitListeners;
+    private readonly backoffRatio;
+    private readonly timeout;
+    private readonly minLimit;
+    private readonly maxLimit;
+    constructor(options?: AIMDLimitOptions);
+    addSample(_startTime: number, rtt: number, inflight: number, didDrop: boolean): void;
+    get currentLimit(): number;
+    private applyNewLimit;
+    subscribe(consumer: (newLimit: number) => void, options?: {
+        signal?: AbortSignal;
+    }): () => void;
+    toString(): string;
+}
+//# sourceMappingURL=AIMDLimit.d.ts.map

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

@@ -0,0 +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"}

package/dist/limit/AIMDLimit.js

@@ -0,0 +1,49 @@
+import { ListenerSet } from "../ListenerSet.js";
+export class AIMDLimit {
+    _limit;
+    limitListeners = new ListenerSet();
+    backoffRatio;
+    timeout;
+    minLimit;
+    maxLimit;
+    constructor(options = {}) {
+        const initialLimit = options.initialLimit ?? 20;
+        this._limit = initialLimit;
+        this.backoffRatio = options.backoffRatio ?? 0.9;
+        this.timeout = options.timeout ?? 5_000;
+        this.minLimit = options.minLimit ?? 20;
+        this.maxLimit = options.maxLimit ?? 200;
+        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");
+        }
+    }
+    addSample(_startTime, rtt, inflight, didDrop) {
+        let currentLimit = this._limit;
+        if (didDrop || rtt > this.timeout) {
+            currentLimit = Math.floor(currentLimit * this.backoffRatio);
+        }
+        else if (inflight * 2 >= currentLimit) {
+            currentLimit = currentLimit + 1;
+        }
+        const newLimit = Math.min(this.maxLimit, Math.max(this.minLimit, currentLimit));
+        this.applyNewLimit(newLimit);
+    }
+    get currentLimit() {
+        return this._limit;
+    }
+    applyNewLimit(newLimit) {
+        if (newLimit !== this._limit) {
+            this._limit = newLimit;
+            this.limitListeners.notify(newLimit);
+        }
+    }
+    subscribe(consumer, options = {}) {
+        return this.limitListeners.subscribe(consumer, options);
+    }
+    toString() {
+        return `AIMDLimit [limit=${this.currentLimit}]`;
+    }
+}

package/dist/limit/FixedLimit.d.ts

@@ -0,0 +1,15 @@
+import type { AdaptiveLimit } from "./StreamingLimit.js";
+/**
+ * Non-dynamic limit with a fixed value.
+ */
+export declare class FixedLimit implements AdaptiveLimit {
+    private _limit;
+    constructor(limit: 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=FixedLimit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FixedLimit.d.ts","sourceRoot":"","sources":["../../src/limit/FixedLimit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAIzD;;GAEG;AACH,qBAAa,UAAW,YAAW,aAAa;IAC9C,OAAO,CAAC,MAAM,CAAS;gBAEX,KAAK,EAAE,MAAM;IAIzB,SAAS,CACP,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,OAAO,GAChB,IAAI;IAGP,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,SAAS,CACP,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,EACrC,QAAQ,GAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAO,GACtC,MAAM,IAAI;IAMb,QAAQ,IAAI,MAAM;CAGnB"}

package/dist/limit/FixedLimit.js

@@ -0,0 +1,23 @@
+const NOOP_UNSUBSCRIBE = () => { };
+/**
+ * Non-dynamic limit with a fixed value.
+ */
+export class FixedLimit {
+    _limit;
+    constructor(limit) {
+        this._limit = limit;
+    }
+    addSample(_startTime, _rtt, _inflight, _didDrop) {
+    }
+    get currentLimit() {
+        return this._limit;
+    }
+    subscribe(_consumer, _options = {}) {
+        // Listeners would never be called -- limit is fixed -- so we return a no-op
+        // function.
+        return NOOP_UNSUBSCRIBE;
+    }
+    toString() {
+        return `FixedLimit [limit=${this.currentLimit}]`;
+    }
+}

package/dist/limit/Gradient2Limit.d.ts

@@ -0,0 +1,122 @@
+import type { MetricRegistry } from "../MetricRegistry.js";
+import type { AdaptiveLimit } from "./StreamingLimit.js";
+/**
+ * Concurrency limit algorithm that adjusts the limit based on the gradient of
+ * change of the current average RTT and a long term exponentially smoothed
+ * average RTT. Unlike traditional congestion control algorithms we use average
+ * instead of minimum since RPC methods can be very bursty due to various
+ * factors such as non-homogenous request processing complexity as well as a
+ * wide distribution of data size. We have also found that using minimum can
+ * result in a bias towards an impractically low base RTT resulting in excessive
+ * load shedding. An exponential decay is applied to the base RTT so that the
+ * value is kept stable yet is allowed to adapt to long term changes in latency
+ * characteristics.
+ *
+ * The core algorithm re-calculates the limit every sampling window
+ * (e.g. 1 second) using the formula:
+ *
+ *   // Calculate the gradient limiting to the range [0.5, 1.0] to filter outliers
+ *   gradient = max(0.5, min(1.0, longtermRtt / currentRtt));
+ *
+ *   // Calculate the new limit by applying the gradient and allowing for some queuing
+ *   newLimit = gradient * currentLimit + queueSize;
+ *
+ *   // Update the limit using a smoothing factor (default 0.2)
+ *   newLimit = currentLimit * (1 - smoothing) + newLimit * smoothing
+ *
+ * The limit can be in one of three main states:
+ *
+ * 1. Steady state
+ *    The average RTT is very stable and the current measurement whipsaws around
+ *    this value, sometimes reducing the limit, sometimes increasing it.
+ *
+ * 2. Transition from steady state to load
+ *    Either the RPS or latency has spiked. The gradient is < 1.0 due to a
+ *    growing request queue that cannot be handled by the system. Excessive
+ *    requests are rejected due to the low limit. The baseline RTT grows using
+ *    exponential decay but lags the current measurement, which keeps the
+ *    gradient < 1.0 and limit low.
+ *
+ * 3. Transition from load to steady state
+ *    The system goes back to steady state after a prolonged period of excessive
+ *    load. Requests aren't rejected and the sample RTT remains low. During this
+ *    state the long term RTT may take some time to go back to normal and could
+ *    potentially be several multiples higher than the current RTT.
+ */
+export interface Gradient2LimitOptions {
+    /** Initial limit used by the limiter. Default: 20 */
+    initialLimit?: number;
+    /**
+     * Minimum concurrency limit allowed. The minimum helps prevent the algorithm
+     * from adjusting the limit too far down. Note that this limit is not
+     * desirable when used as backpressure for batch apps. Default: 20
+     */
+    minLimit?: number;
+    /**
+     * Maximum allowable concurrency. Any estimated concurrency will be capped at
+     * this value. Default: 200
+     */
+    maxConcurrency?: number;
+    /**
+     * Smoothing factor to limit how aggressively the estimated limit can shrink
+     * when queuing has been detected. Value of 0.0 to 1.0 where 1.0 means the
+     * limit is completely replaced by the new estimate. Default: 0.2
+     */
+    smoothing?: number;
+    /**
+     * Fixed amount the estimated limit can grow while latencies remain low.
+     * Can be a constant or a function of the current limit. Default: 4
+     */
+    queueSize?: number | ((concurrency: number) => number);
+    /**
+     * Tolerance for changes in minimum latency. Value >= 1.0 indicating how
+     * much change in minimum latency is acceptable before reducing the limit.
+     * For example, a value of 2.0 means that a 2x increase in latency is
+     * acceptable. Default: 1.5
+     */
+    rttTolerance?: number;
+    /**
+     * Number of samples in the long-term exponential average window.
+     * Default: 600
+     */
+    longWindow?: number;
+    metricRegistry?: MetricRegistry;
+}
+export declare class Gradient2Limit implements AdaptiveLimit {
+    private _limit;
+    private readonly limitListeners;
+    /** Estimated concurrency limit based on our algorithm */
+    private estimatedLimit;
+    /**
+     * Tracks a measurement of the short time, and more volatile, RTT meant to
+     * represent the current system latency.
+     */
+    private lastRtt;
+    /**
+     * Tracks a measurement of the long term, less volatile, RTT meant to
+     * represent the baseline latency. When the system is under load this number
+     * is expected to trend higher.
+     */
+    private readonly longRtt;
+    /** Maximum allowed limit providing an upper bound failsafe */
+    private readonly maxLimit;
+    private readonly minLimit;
+    private readonly queueSize;
+    private readonly smoothing;
+    private readonly tolerance;
+    private readonly longRttSampleListener;
+    private readonly shortRttSampleListener;
+    private readonly queueSizeSampleListener;
+    constructor(options?: Gradient2LimitOptions);
+    addSample(_startTime: number, rtt: number, inflight: number, _didDrop: boolean): void;
+    get currentLimit(): number;
+    private applyNewLimit;
+    subscribe(consumer: (newLimit: number) => void, options?: {
+        signal?: AbortSignal;
+    }): () => void;
+    private computeNextLimitUnrounded;
+    getLastRtt(): number;
+    getRttNoLoad(): number;
+    toString(): string;
+}
+//# sourceMappingURL=Gradient2Limit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Gradient2Limit.d.ts","sourceRoot":"","sources":["../../src/limit/Gradient2Limit.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAsB,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE/E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAIzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAM,WAAW,qBAAqB;IACpC,qDAAqD;IACrD,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,WAAW,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;IAEvD;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;AAED,qBAAa,cAAe,YAAW,aAAa;IAClD,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAqB;IAEpD,yDAAyD;IACzD,OAAO,CAAC,cAAc,CAAS;IAE/B;;;OAGG;IACH,OAAO,CAAC,OAAO,CAAK;IAEpB;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAE7C,8DAA8D;IAC9D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAElC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkC;IAC5D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IAEnC,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAqB;IAC3D,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAqB;IAC5D,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAqB;gBAEjD,OAAO,GAAE,qBAA0B;IAwB/C,SAAS,CACP,UAAU,EAAE,MAAM,EAClB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,OAAO,GAChB,IAAI;IASP,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,yBAAyB;IAyCjC,UAAU,IAAI,MAAM;IAIpB,YAAY,IAAI,MAAM;IAItB,QAAQ,IAAI,MAAM;CAGnB"}