@stimulcross/rate-limiter 0.0.1 → 0.0.3

package/lib/limiters/leaky-bucket/leaky-bucket.status.d.ts

@@ -0,0 +1,31 @@
+import { type RateLimiterStatus } from '../../core/rate-limiter-status.js';
+/**
+ * The status of the Leaky Bucket rate limiter.
+ */
+export interface LeakyBucketStatus extends RateLimiterStatus {
+    /**
+     * The maximum capacity of the bucket (maximum number of requests that can be queued).
+     */
+    capacity: number;
+    /**
+     * The rate at which requests leak from the bucket (requests per second).
+     */
+    leakRate: number;
+    /**
+     * The current number of requests in the bucket waiting to be processed.
+     */
+    level: number;
+    /**
+     * The number of requests that can still be added to the bucket before reaching capacity.
+     */
+    remaining: number;
+    /**
+     * Timestamp (in milliseconds) when the next request slot will become available.
+     */
+    nextAvailableAt: number;
+    /**
+     * Timestamp (in milliseconds) when all queued requests will have leaked (bucket becomes empty).
+     */
+    resetAt: number;
+}
+//# sourceMappingURL=leaky-bucket.status.d.ts.map

package/lib/limiters/leaky-bucket/leaky-bucket.status.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=leaky-bucket.status.js.map

package/{src/limiters/sliding-window-counter/index.ts → lib/limiters/sliding-window-counter/index.d.ts}

@@ -1,7 +1,5 @@
 export type { SlidingWindowCounterState } from './sliding-window-counter.state.js';
 export type { SlidingWindowCounterStatus } from './sliding-window-counter.status.js';
 export type { SlidingWindowCounterOptions } from './sliding-window-counter.options.js';
-export {
-	type SlidingWindowCounterLimiterRunOptions,
-	SlidingWindowCounterLimiter,
-} from './sliding-window-counter.limiter.js';
+export { type SlidingWindowCounterLimiterRunOptions, SlidingWindowCounterLimiter, } from './sliding-window-counter.limiter.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/limiters/sliding-window-counter/index.js

@@ -0,0 +1,2 @@
+export { SlidingWindowCounterLimiter, } from './sliding-window-counter.limiter.js';
+//# sourceMappingURL=index.js.map

package/lib/limiters/sliding-window-counter/sliding-window-counter.limiter.d.ts

@@ -0,0 +1,28 @@
+import { type SlidingWindowCounterOptions } from './sliding-window-counter.options.js';
+import { SlidingWindowCounterPolicy } from './sliding-window-counter.policy.js';
+import { type SlidingWindowCounterState } from './sliding-window-counter.state.js';
+import { type SlidingWindowCounterStatus } from './sliding-window-counter.status.js';
+import { type RateLimiterRunOptions } from '../../interfaces/rate-limiter-run-options.js';
+import { AbstractRateLimiter, type ExecutionContext } from '../abstract-rate-limiter.js';
+/**
+ * The options for running a task in the Sliding Window Counter rate limiter.
+ */
+export type SlidingWindowCounterLimiterRunOptions = Omit<RateLimiterRunOptions, 'limitBehavior' | 'priority' | 'maxWaitMs'>;
+/**
+ * Sliding Window Counter rate limiter.
+ *
+ * Designed primarily for client-side use to respect third-party limits or protect resources.
+ * While this can be used as a server-side limiter with custom distributed storage
+ * (e.g., Redis), it is best-effort and not recommended due to high network round-trip latency.
+ *
+ * Note: Unlike queue-based limiters, this implementation operates in strict immediate mode.
+ * It does not support request queueing, delays, priorities, or task cancellation.
+ */
+export declare class SlidingWindowCounterLimiter extends AbstractRateLimiter<SlidingWindowCounterState, SlidingWindowCounterStatus> {
+    protected readonly _policy: SlidingWindowCounterPolicy;
+    private readonly _storeTtl;
+    constructor(options: SlidingWindowCounterOptions);
+    protected _runInternal<T>(fn: () => T | Promise<T>, ctx: ExecutionContext): Promise<T>;
+    protected _getDebugStateString(state: SlidingWindowCounterState): string;
+}
+//# sourceMappingURL=sliding-window-counter.limiter.d.ts.map

package/lib/limiters/sliding-window-counter/sliding-window-counter.limiter.js

@@ -0,0 +1,47 @@
+import { SlidingWindowCounterPolicy } from './sliding-window-counter.policy.js';
+import { RateLimitErrorCode } from '../../enums/rate-limit-error-code.js';
+import { RateLimitError } from '../../errors/rate-limit.error.js';
+import { AbstractRateLimiter } from '../abstract-rate-limiter.js';
+/**
+ * Sliding Window Counter rate limiter.
+ *
+ * Designed primarily for client-side use to respect third-party limits or protect resources.
+ * While this can be used as a server-side limiter with custom distributed storage
+ * (e.g., Redis), it is best-effort and not recommended due to high network round-trip latency.
+ *
+ * Note: Unlike queue-based limiters, this implementation operates in strict immediate mode.
+ * It does not support request queueing, delays, priorities, or task cancellation.
+ */
+export class SlidingWindowCounterLimiter extends AbstractRateLimiter {
+    _policy;
+    _storeTtl;
+    constructor(options) {
+        super(options);
+        this._policy = new SlidingWindowCounterPolicy(options.limit, options.windowMs);
+        this._storeTtl = options.windowMs * 2;
+    }
+    async _runInternal(fn, ctx) {
+        const now = this._clock.now();
+        await this._store.acquireLock?.(ctx.key);
+        try {
+            const state = (await this._store.get(ctx.key)) ?? this._policy.getInitialState();
+            const { decision, nextState } = this._policy.evaluate(state, now, ctx.cost);
+            if (decision.kind === 'deny') {
+                this._shouldPrintDebug &&
+                    this._logger.debug(`[DENY] [id: ${ctx.id}, key: ${ctx.key}] - Retry: +${decision.retryAt - now}ms`);
+                throw new RateLimitError(RateLimitErrorCode.LimitExceeded, decision.retryAt);
+            }
+            await this._store.set(ctx.key, nextState, this._storeTtl);
+            this._shouldPrintDebug &&
+                this._logger.debug(`[ALLOW] [id: ${ctx.id}, key: ${ctx.key}] - ${this._getDebugStateString(nextState)}`);
+        }
+        finally {
+            await this._store.releaseLock?.(ctx.key);
+        }
+        return await this._execute(fn, now, this._storeTtl, ctx);
+    }
+    _getDebugStateString(state) {
+        return `lim: ${this._policy.limit}; c/p: ${state.currentCount}/${state.previousCount}`;
+    }
+}
+//# sourceMappingURL=sliding-window-counter.limiter.js.map

package/lib/limiters/sliding-window-counter/sliding-window-counter.options.d.ts

@@ -0,0 +1,16 @@
+import { type SlidingWindowCounterState } from './sliding-window-counter.state.js';
+import { type RateLimiterOptions } from '../../interfaces/rate-limiter-options.js';
+/**
+ * Options for the Sliding Window Counter rate limiter.
+ */
+export interface SlidingWindowCounterOptions extends Omit<RateLimiterOptions<SlidingWindowCounterState>, 'queue' | 'limitBehavior'> {
+    /**
+     * Maximum number of requests allowed within the time window.
+     */
+    limit: number;
+    /**
+     * Duration of the time window in milliseconds.
+     */
+    windowMs: number;
+}
+//# sourceMappingURL=sliding-window-counter.options.d.ts.map

package/lib/limiters/sliding-window-counter/sliding-window-counter.options.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sliding-window-counter.options.js.map

package/lib/limiters/sliding-window-counter/sliding-window-counter.policy.d.ts

@@ -0,0 +1,18 @@
+import { type SlidingWindowCounterState } from './sliding-window-counter.state.js';
+import { type SlidingWindowCounterStatus } from './sliding-window-counter.status.js';
+import { type RateLimitPolicy, type RateLimitPolicyResult } from '../../core/rate-limit-policy.js';
+/** @internal */
+export declare class SlidingWindowCounterPolicy implements RateLimitPolicy<SlidingWindowCounterState, SlidingWindowCounterStatus> {
+    private readonly _limit;
+    private readonly _windowMs;
+    constructor(_limit: number, _windowMs: number);
+    get limit(): number;
+    get windowMs(): number;
+    getInitialState(): SlidingWindowCounterState;
+    getStatus(state: SlidingWindowCounterState, now: number): SlidingWindowCounterStatus;
+    evaluate(state: SlidingWindowCounterState, now: number, cost: number): RateLimitPolicyResult<SlidingWindowCounterState>;
+    revert(state: SlidingWindowCounterState, cost: number, now: number): SlidingWindowCounterState;
+    private _syncState;
+    private _calculateAvailableAt;
+}
+//# sourceMappingURL=sliding-window-counter.policy.d.ts.map

package/lib/limiters/sliding-window-counter/sliding-window-counter.policy.js

@@ -0,0 +1,128 @@
+import { validateCost } from '../../utils/validate-cost.js';
+/** @internal */
+export class SlidingWindowCounterPolicy {
+    _limit;
+    _windowMs;
+    constructor(_limit, _windowMs) {
+        this._limit = _limit;
+        this._windowMs = _windowMs;
+        if (!Number.isFinite(_limit) || !Number.isInteger(_limit) || _limit < 0) {
+            throw new Error(`Invalid limit: ${_limit}. Must be a positive integer.`);
+        }
+        if (!Number.isFinite(_windowMs) || !Number.isInteger(_windowMs) || _windowMs <= 0) {
+            throw new Error(`Invalid windowMs: ${_windowMs}. Must be a positive integer.`);
+        }
+    }
+    get limit() {
+        return this._limit;
+    }
+    get windowMs() {
+        return this._windowMs;
+    }
+    getInitialState() {
+        return {
+            windowStart: 0,
+            currentCount: 0,
+            previousCount: 0,
+        };
+    }
+    getStatus(state, now) {
+        const syncedState = this._syncState(state, now);
+        const { windowStart, previousCount, currentCount } = syncedState;
+        const timeIntoCurrentWindow = now - windowStart;
+        const weight = (this._windowMs - timeIntoCurrentWindow) / this._windowMs;
+        const estimatedCount = Math.floor(previousCount * weight + currentCount);
+        const remaining = Math.max(0, this._limit - estimatedCount);
+        const nextAvailableAt = this._calculateAvailableAt(windowStart, previousCount, currentCount, 1, now);
+        let resetAt;
+        if (currentCount > 0) {
+            resetAt = windowStart + 2 * this._windowMs;
+        }
+        else if (previousCount > 0) {
+            resetAt = windowStart + this._windowMs;
+        }
+        else {
+            resetAt = now;
+        }
+        return {
+            limit: this._limit,
+            windowMs: this._windowMs,
+            windowStart,
+            currentCount,
+            previousCount,
+            estimatedCount,
+            remaining,
+            nextAvailableAt,
+            resetAt,
+        };
+    }
+    evaluate(state, now, cost) {
+        validateCost(cost, this._limit);
+        const syncedState = this._syncState(state, now);
+        const { windowStart, previousCount, currentCount } = syncedState;
+        const timeIntoCurrentWindow = now - windowStart;
+        const weight = (this._windowMs - timeIntoCurrentWindow) / this._windowMs;
+        const estimatedCount = Math.floor(previousCount * weight + currentCount);
+        if (estimatedCount + cost <= this._limit) {
+            return {
+                decision: { kind: 'allow' },
+                nextState: {
+                    windowStart,
+                    previousCount,
+                    currentCount: currentCount + cost,
+                },
+            };
+        }
+        const availableAt = this._calculateAvailableAt(windowStart, previousCount, currentCount, cost, now);
+        return {
+            decision: { kind: 'deny', retryAt: availableAt },
+            nextState: syncedState,
+        };
+    }
+    revert(state, cost, now) {
+        if (cost <= 0) {
+            return state;
+        }
+        const syncedState = this._syncState(state, now);
+        return {
+            ...syncedState,
+            currentCount: Math.max(0, syncedState.currentCount - cost),
+        };
+    }
+    _syncState(state, now) {
+        const currentWindowStart = Math.floor(now / this._windowMs) * this._windowMs;
+        if (currentWindowStart <= state.windowStart) {
+            return state;
+        }
+        const windowsPassed = Math.floor((currentWindowStart - state.windowStart) / this._windowMs);
+        if (windowsPassed > 1) {
+            return { windowStart: currentWindowStart, previousCount: 0, currentCount: 0 };
+        }
+        return {
+            windowStart: currentWindowStart,
+            previousCount: state.currentCount,
+            currentCount: 0,
+        };
+    }
+    _calculateAvailableAt(windowStart, prev, curr, cost, now) {
+        if (curr + cost <= this._limit) {
+            if (prev === 0) {
+                return now;
+            }
+            const numerator = this._windowMs * (prev + curr + cost - this._limit - 1);
+            const t = Math.max(0, Math.floor(numerator / prev) + 1);
+            const absoluteTime = windowStart + t;
+            return Math.max(now, absoluteTime);
+        }
+        const newPrev = curr;
+        const newWindowStart = windowStart + this._windowMs;
+        if (newPrev === 0) {
+            return Math.max(now, newWindowStart);
+        }
+        const numerator = this._windowMs * (newPrev + cost - this._limit - 1);
+        const t = Math.max(0, Math.floor(numerator / newPrev) + 1);
+        const absoluteTime = newWindowStart + t;
+        return Math.max(now, absoluteTime);
+    }
+}
+//# sourceMappingURL=sliding-window-counter.policy.js.map

package/{src/limiters/sliding-window-counter/sliding-window-counter.state.ts → lib/limiters/sliding-window-counter/sliding-window-counter.state.d.ts}

@@ -4,7 +4,8 @@
  * When using a distributed state store, make sure it properly serializes and deserializes the state.
  */
 export interface SlidingWindowCounterState {
-	windowStart: number;
-	currentCount: number;
-	previousCount: number;
+    windowStart: number;
+    currentCount: number;
+    previousCount: number;
 }
+//# sourceMappingURL=sliding-window-counter.state.d.ts.map

package/lib/limiters/sliding-window-counter/sliding-window-counter.state.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sliding-window-counter.state.js.map

package/lib/limiters/sliding-window-counter/sliding-window-counter.status.d.ts

@@ -0,0 +1,45 @@
+import { type RateLimiterStatus } from '../../core/rate-limiter-status.js';
+/**
+ * The status of the Sliding Window Counter rate limiter.
+ */
+export interface SlidingWindowCounterStatus extends RateLimiterStatus {
+    /**
+     * Maximum number of requests allowed within the time window.
+     */
+    limit: number;
+    /**
+     * Duration of the time window in milliseconds.
+     */
+    windowMs: number;
+    /**
+     * Timestamp (in milliseconds) when the current window started.
+     */
+    windowStart: number;
+    /**
+     * Number of requests made in the current window.
+     */
+    currentCount: number;
+    /**
+     * Number of requests made in the previous window.
+     */
+    previousCount: number;
+    /**
+     * Estimated request count based on the sliding window algorithm.
+     *
+     * Calculated by combining current and previous window counts proportionally.
+     */
+    estimatedCount: number;
+    /**
+     * Number of requests remaining before hitting the limit.
+     */
+    remaining: number;
+    /**
+     * Timestamp (in milliseconds) when the next request slot becomes available.
+     */
+    nextAvailableAt: number;
+    /**
+     * Timestamp (in milliseconds) when the current window resets.
+     */
+    resetAt: number;
+}
+//# sourceMappingURL=sliding-window-counter.status.d.ts.map

package/lib/limiters/sliding-window-counter/sliding-window-counter.status.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sliding-window-counter.status.js.map

package/{src/limiters/sliding-window-log/index.ts → lib/limiters/sliding-window-log/index.d.ts}

@@ -2,3 +2,4 @@ export type { SlidingWindowLogEntry, SlidingWindowLogState } from './sliding-win
 export type { SlidingWindowLogStatus } from './sliding-window-log.status.js';
 export type { SlidingWindowLogOptions } from './sliding-window-log.options.js';
 export { type SlidingWindowLogLimiterRunOptions, SlidingWindowLogLimiter } from './sliding-window-log.limiter.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/limiters/sliding-window-log/index.js

@@ -0,0 +1,2 @@
+export { SlidingWindowLogLimiter } from './sliding-window-log.limiter.js';
+//# sourceMappingURL=index.js.map

package/lib/limiters/sliding-window-log/sliding-window-log.limiter.d.ts

@@ -0,0 +1,27 @@
+import { type SlidingWindowLogOptions } from './sliding-window-log.options.js';
+import { SlidingWindowLogPolicy } from './sliding-window-log.policy.js';
+import { type SlidingWindowLogState } from './sliding-window-log.state.js';
+import { type SlidingWindowLogStatus } from './sliding-window-log.status.js';
+import { type RateLimiterRunOptions } from '../../interfaces/rate-limiter-run-options.js';
+import { AbstractRateLimiter, type ExecutionContext } from '../abstract-rate-limiter.js';
+/**
+ * The options for running a task in the Sliding Window Log rate limiter.
+ */
+export type SlidingWindowLogLimiterRunOptions = Omit<RateLimiterRunOptions, 'limitBehavior' | 'priority'>;
+/**
+ * Sliding Window Log rate limiter.
+ *
+ * Designed primarily for client-side use to respect third-party limits or protect resources.
+ * While this can be used as a server-side limiter with custom distributed storage
+ * (e.g., Redis), it is best-effort and not recommended due to high network round-trip latency.
+ *
+ * Note: Unlike queue-based limiters, this implementation operates in strict immediate mode.
+ * It does not support request queueing, delays, priorities, or task cancellation.
+ */
+export declare class SlidingWindowLogLimiter extends AbstractRateLimiter<SlidingWindowLogState, SlidingWindowLogStatus> {
+    protected readonly _policy: SlidingWindowLogPolicy;
+    constructor(options: SlidingWindowLogOptions);
+    protected _runInternal<T>(fn: () => T | Promise<T>, ctx: ExecutionContext): Promise<T>;
+    protected _getDebugStateString(state: SlidingWindowLogState): string;
+}
+//# sourceMappingURL=sliding-window-log.limiter.d.ts.map

package/lib/limiters/sliding-window-log/sliding-window-log.limiter.js

@@ -0,0 +1,44 @@
+import { SlidingWindowLogPolicy } from './sliding-window-log.policy.js';
+import { RateLimitErrorCode } from '../../enums/rate-limit-error-code.js';
+import { RateLimitError } from '../../errors/rate-limit.error.js';
+import { AbstractRateLimiter } from '../abstract-rate-limiter.js';
+/**
+ * Sliding Window Log rate limiter.
+ *
+ * Designed primarily for client-side use to respect third-party limits or protect resources.
+ * While this can be used as a server-side limiter with custom distributed storage
+ * (e.g., Redis), it is best-effort and not recommended due to high network round-trip latency.
+ *
+ * Note: Unlike queue-based limiters, this implementation operates in strict immediate mode.
+ * It does not support request queueing, delays, priorities, or task cancellation.
+ */
+export class SlidingWindowLogLimiter extends AbstractRateLimiter {
+    _policy;
+    constructor(options) {
+        super(options);
+        this._policy = new SlidingWindowLogPolicy(options.limit, options.windowMs);
+    }
+    async _runInternal(fn, ctx) {
+        const now = this._clock.now();
+        const storeTtlMs = this._policy.windowMs;
+        await this._store.acquireLock?.(ctx.key);
+        try {
+            const state = (await this._store.get(ctx.key)) ?? this._policy.getInitialState();
+            const { decision, nextState } = this._policy.evaluate(state, now, ctx.cost);
+            if (decision.kind === 'deny') {
+                this._logger.debug(`[DENY] [id: ${ctx.id}, key: ${ctx.key}] - Retry: +${decision.retryAt - now}ms`);
+                throw new RateLimitError(RateLimitErrorCode.LimitExceeded, decision.retryAt);
+            }
+            await this._store.set(ctx.key, nextState, storeTtlMs);
+            this._logger.debug(`[ALLOW] [id: ${ctx.id}, key: ${ctx.key}] - used/lim: ${nextState.totalUsed}/${this._policy.limit} logs: ${nextState.logs.size}`);
+        }
+        finally {
+            await this._store.releaseLock?.(ctx.key);
+        }
+        return await this._execute(fn, now, storeTtlMs, ctx);
+    }
+    _getDebugStateString(state) {
+        return `used/lim: ${state.totalUsed}/${this._policy.limit} logs: ${state.logs.size}`;
+    }
+}
+//# sourceMappingURL=sliding-window-log.limiter.js.map

package/lib/limiters/sliding-window-log/sliding-window-log.options.d.ts

@@ -0,0 +1,16 @@
+import { type SlidingWindowLogState } from './sliding-window-log.state.js';
+import { type RateLimiterOptions } from '../../interfaces/rate-limiter-options.js';
+/**
+ * Options for the Sliding Window Log rate limiter.
+ */
+export interface SlidingWindowLogOptions extends Omit<RateLimiterOptions<SlidingWindowLogState>, 'queue' | 'limitBehavior'> {
+    /**
+     * Maximum number of requests allowed within the time window.
+     */
+    limit: number;
+    /**
+     * Duration of the time window in milliseconds.
+     */
+    windowMs: number;
+}
+//# sourceMappingURL=sliding-window-log.options.d.ts.map

package/lib/limiters/sliding-window-log/sliding-window-log.options.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sliding-window-log.options.js.map

package/lib/limiters/sliding-window-log/sliding-window-log.policy.d.ts

@@ -0,0 +1,18 @@
+import { type SlidingWindowLogState } from './sliding-window-log.state.js';
+import { type SlidingWindowLogStatus } from './sliding-window-log.status.js';
+import { type RateLimitPolicy, type RateLimitPolicyResult } from '../../core/rate-limit-policy.js';
+/** @internal */
+export declare class SlidingWindowLogPolicy implements RateLimitPolicy<SlidingWindowLogState, SlidingWindowLogStatus> {
+    private readonly _limit;
+    private readonly _windowMs;
+    constructor(_limit: number, _windowMs: number);
+    get limit(): number;
+    get windowMs(): number;
+    getInitialState(): SlidingWindowLogState;
+    getStatus(state: SlidingWindowLogState, now: number): SlidingWindowLogStatus;
+    evaluate(state: SlidingWindowLogState, now: number, cost: number): RateLimitPolicyResult<SlidingWindowLogState>;
+    revert(state: SlidingWindowLogState, cost: number, now: number): SlidingWindowLogState;
+    private _syncState;
+    private _calculateAvailableAt;
+}
+//# sourceMappingURL=sliding-window-log.policy.d.ts.map

package/lib/limiters/sliding-window-log/sliding-window-log.policy.js

@@ -0,0 +1,124 @@
+import { Deque } from '@stimulcross/ds-deque';
+import { validateCost } from '../../utils/validate-cost.js';
+/** @internal */
+export class SlidingWindowLogPolicy {
+    _limit;
+    _windowMs;
+    constructor(_limit, _windowMs) {
+        this._limit = _limit;
+        this._windowMs = _windowMs;
+        if (!Number.isFinite(_limit) || !Number.isInteger(_limit) || _limit <= 0) {
+            throw new Error(`Invalid limit: ${_limit}. Must be a positive integer.`);
+        }
+        if (!Number.isFinite(_windowMs) || !Number.isInteger(_windowMs) || _windowMs <= 0) {
+            throw new Error(`Invalid windowMs: ${_windowMs}. Must be a positive integer.`);
+        }
+    }
+    get limit() {
+        return this._limit;
+    }
+    get windowMs() {
+        return this._windowMs;
+    }
+    getInitialState() {
+        return {
+            logs: new Deque(),
+            totalUsed: 0,
+        };
+    }
+    getStatus(state, now) {
+        const syncedState = this._syncState(state, now);
+        const { logs, totalUsed } = syncedState;
+        const remaining = Math.max(0, this._limit - totalUsed);
+        const nextAvailableAt = this._calculateAvailableAt(logs, totalUsed, 1, now);
+        const tail = logs.peekTail();
+        const resetAt = tail ? tail.ts + this._windowMs : now;
+        return {
+            limit: this._limit,
+            windowMs: this._windowMs,
+            totalUsed,
+            remaining,
+            nextAvailableAt,
+            resetAt,
+        };
+    }
+    evaluate(state, now, cost) {
+        validateCost(cost, this._limit);
+        const syncedState = this._syncState(state, now);
+        const { logs, totalUsed } = syncedState;
+        if (totalUsed + cost <= this._limit) {
+            const tail = logs.peekTail();
+            if (tail?.ts === now) {
+                tail.count += cost;
+            }
+            else {
+                logs.push({ ts: now, count: cost });
+            }
+            return {
+                decision: { kind: 'allow' },
+                nextState: { logs, totalUsed: totalUsed + cost },
+            };
+        }
+        const retryAt = this._calculateAvailableAt(logs, totalUsed, cost, now);
+        return {
+            decision: { kind: 'deny', retryAt },
+            nextState: syncedState,
+        };
+    }
+    revert(state, cost, now) {
+        if (cost <= 0 || state.totalUsed === 0) {
+            return state;
+        }
+        const syncedState = this._syncState(state, now);
+        const { logs } = syncedState;
+        let { totalUsed } = syncedState;
+        let remainingToRemove = cost;
+        while (remainingToRemove > 0 && !logs.isEmpty) {
+            const tail = logs.peekTail();
+            if (tail.count <= remainingToRemove) {
+                remainingToRemove -= tail.count;
+                totalUsed -= tail.count;
+                logs.pop();
+            }
+            else {
+                tail.count -= remainingToRemove;
+                totalUsed -= remainingToRemove;
+                remainingToRemove = 0;
+            }
+        }
+        return { logs, totalUsed: Math.max(0, totalUsed) };
+    }
+    _syncState(state, now) {
+        const { logs } = state;
+        let { totalUsed } = state;
+        const windowStart = now - this._windowMs;
+        while (!logs.isEmpty) {
+            const head = logs.peekHead();
+            if (head.ts > windowStart) {
+                break;
+            }
+            const removed = logs.shift();
+            if (removed) {
+                totalUsed -= removed.count;
+            }
+        }
+        return { logs, totalUsed: Math.max(0, totalUsed) };
+    }
+    _calculateAvailableAt(logs, totalUsed, cost, now) {
+        if (totalUsed + cost <= this._limit) {
+            return now;
+        }
+        const targetToFree = totalUsed + cost - this._limit;
+        let freed = 0;
+        let availableAt = now;
+        for (const entry of logs) {
+            freed += entry.count;
+            if (freed >= targetToFree) {
+                availableAt = entry.ts + this._windowMs;
+                break;
+            }
+        }
+        return Math.max(now, availableAt);
+    }
+}
+//# sourceMappingURL=sliding-window-log.policy.js.map

package/{src/limiters/sliding-window-log/sliding-window-log.state.ts → lib/limiters/sliding-window-log/sliding-window-log.state.d.ts}

@@ -1,19 +1,18 @@
 import { type Deque } from '@stimulcross/ds-deque';
-
 /**
  * A log entry in the sliding window log rate limiter.
  */
 export interface SlidingWindowLogEntry {
-	ts: number;
-	count: number;
+    ts: number;
+    count: number;
 }
-
 /**
  * The state of the sliding window log rate limiter.
  *
  * When using a distributed state store, make sure it properly serializes and deserializes the state.
  */
 export interface SlidingWindowLogState {
-	logs: Deque<SlidingWindowLogEntry>;
-	totalUsed: number;
+    logs: Deque<SlidingWindowLogEntry>;
+    totalUsed: number;
 }
+//# sourceMappingURL=sliding-window-log.state.d.ts.map

package/lib/limiters/sliding-window-log/sliding-window-log.state.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sliding-window-log.state.js.map