actly 1.1.5 → 1.3.0

package/dist/policies/circuitBreaker.js

@@ -0,0 +1,176 @@
+import { REQUIRES_SYNC_STORE } from '../core/executor.js';
+import { CircuitBreakerOpenError } from '../errors.js';
+import { isAbortError } from '../utils/abort.js';
+const NS = 'cb:';
+function getState(store, key, strategy) {
+    const existing = store.get(NS + key);
+    if (existing)
+        return existing;
+    if (strategy === 'count') {
+        return {
+            strategy: 'count',
+            outcomes: [],
+            index: 0,
+            failures: 0,
+            filled: 0,
+            isOpen: false,
+            openedAt: 0,
+            halfOpen: false,
+            lastFailureTime: 0,
+        };
+    }
+    return {
+        strategy: 'consecutive',
+        failures: 0,
+        lastFailureTime: 0,
+        isOpen: false,
+        openedAt: 0,
+        halfOpen: false,
+    };
+}
+function setState(store, key, state) {
+    store.set(NS + key, state);
+}
+function recordCountOutcome(state, success, windowSize) {
+    if (state.outcomes.length < windowSize) {
+        state.outcomes.push(success);
+        state.filled = state.outcomes.length;
+        if (!success)
+            state.failures++;
+        state.index = (state.index + 1) % windowSize;
+        return;
+    }
+    if (state.outcomes[state.index] === false)
+        state.failures--;
+    state.outcomes[state.index] = success;
+    if (!success)
+        state.failures++;
+    state.index = (state.index + 1) % windowSize;
+    state.filled = windowSize;
+}
+function countFailureRate(state) {
+    if (state.filled === 0)
+        return 0;
+    return state.failures / state.filled;
+}
+function resetCountState(state) {
+    state.outcomes = [];
+    state.index = 0;
+    state.failures = 0;
+    state.filled = 0;
+    state.isOpen = false;
+    state.openedAt = 0;
+    state.halfOpen = false;
+    state.lastFailureTime = 0;
+}
+export function circuitBreakerPolicy(opts) {
+    const threshold = Math.max(1, Math.floor(opts.threshold));
+    const cooldownMs = opts.cooldownMs;
+    const resetTimeoutMs = opts.resetTimeoutMs ?? Number.POSITIVE_INFINITY;
+    const strategy = opts.strategy ?? 'consecutive';
+    const countSize = strategy === 'count' ? Math.max(1, Math.floor(opts.countSize ?? 100)) : 0;
+    const countThreshold = strategy === 'count'
+        ? Math.min(1, Math.max(0, opts.countThreshold ?? 0.5))
+        : 0;
+    const countMinimumCalls = strategy === 'count'
+        ? Math.max(1, Math.floor(opts.countMinimumCalls ?? countSize))
+        : 0;
+    const applier = (fn, ctx) => {
+        const syncCtx = ctx;
+        return async (signal) => {
+            const key = syncCtx.key;
+            const now = Date.now();
+            const state = getState(syncCtx.store, key, strategy);
+            if (state.isOpen) {
+                const elapsed = now - state.openedAt;
+                if (elapsed >= cooldownMs) {
+                    state.isOpen = false;
+                    state.halfOpen = true;
+                    setState(syncCtx.store, key, state);
+                }
+                else {
+                    throw new CircuitBreakerOpenError(key, cooldownMs - elapsed);
+                }
+            }
+            else if (state.halfOpen) {
+                throw new CircuitBreakerOpenError(key, 0);
+            }
+            if (now - state.lastFailureTime > resetTimeoutMs && state.lastFailureTime > 0) {
+                if (!state.halfOpen) {
+                    if (state.strategy === 'count') {
+                        resetCountState(state);
+                    }
+                    else {
+                        state.failures = 0;
+                        state.isOpen = false;
+                        state.openedAt = 0;
+                        state.halfOpen = false;
+                    }
+                    setState(syncCtx.store, key, state);
+                }
+            }
+            try {
+                const result = await fn(signal);
+                const updated = getState(syncCtx.store, key, strategy);
+                const wasHalfOpen = updated.halfOpen;
+                if (wasHalfOpen && updated.strategy === 'count') {
+                    resetCountState(updated);
+                }
+                else if (updated.strategy === 'count') {
+                    recordCountOutcome(updated, true, countSize);
+                }
+                else {
+                    updated.failures = 0;
+                }
+                if (wasHalfOpen) {
+                    updated.isOpen = false;
+                    updated.halfOpen = false;
+                }
+                const isIdle = updated.failures === 0 && !updated.isOpen && !updated.halfOpen;
+                if (isIdle) {
+                    syncCtx.store.delete(NS + key);
+                }
+                else {
+                    setState(syncCtx.store, key, updated);
+                }
+                return result;
+            }
+            catch (err) {
+                if (signal.aborted && (isAbortError(err) || err === signal.reason)) {
+                    const updated = getState(syncCtx.store, key, strategy);
+                    if (updated.failures === 0 && !updated.isOpen && !updated.halfOpen) {
+                        syncCtx.store.delete(NS + key);
+                    }
+                    else {
+                        setState(syncCtx.store, key, updated);
+                    }
+                    throw err;
+                }
+                const updated = getState(syncCtx.store, key, strategy);
+                const wasHalfOpen = updated.halfOpen;
+                updated.lastFailureTime = Date.now();
+                updated.halfOpen = false;
+                if (updated.strategy === 'count') {
+                    recordCountOutcome(updated, false, countSize);
+                    const rate = countFailureRate(updated);
+                    const enoughCalls = updated.filled >= countMinimumCalls;
+                    if (wasHalfOpen || (enoughCalls && rate > countThreshold)) {
+                        updated.isOpen = true;
+                        updated.openedAt = Date.now();
+                    }
+                }
+                else {
+                    updated.failures++;
+                    if (updated.failures >= threshold || wasHalfOpen) {
+                        updated.isOpen = true;
+                        updated.openedAt = Date.now();
+                    }
+                }
+                setState(syncCtx.store, key, updated);
+                throw err;
+            }
+        };
+    };
+    applier[REQUIRES_SYNC_STORE] = true;
+    return applier;
+}

package/dist/policies/dedupe.cjs

@@ -3,85 +3,67 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.dedupePolicy = dedupePolicy;
 const executor_js_1 = require("../core/executor.js");
 const abort_js_1 = require("../utils/abort.js");
-// Namespace so dedupe keys never collide with cache keys in the shared store.
+const safeCall_js_1 = require("../utils/safeCall.js");
+const limits_js_1 = require("../utils/limits.js");
 const NS = 'dedupe:';
-/**
- * Collapse concurrent calls that share the same key into one in-flight Promise.
- *
- * # How it works
- *
- * The first caller (originator) starts the work and stores
- * `{ promise, meta }` in the store under `dedupe:<key>`. Every subsequent
- * caller that arrives before the promise settles receives the SAME promise
- * — no duplicate work.
- *
- * # Shared `meta` (fixes v1.0 trade-off)
- *
- * The originator's `ctx.meta` reference is stored alongside the promise.
- * Inner policies (e.g. `retryPolicy`) mutate it as they run. After the
- * promise settles, joiners copy `attempts` and `source` from the shared
- * meta into their own `ctx.meta`. This means a joiner's `ActResult.attempts`
- * reflects the real effort (e.g. `3` if the originator retried twice), not
- * the misleading default of `1`.
- *
- * # Abort safety (fixes hung-fn block)
- *
- * Joiners race the in-flight promise against their own AbortSignal via
- * `raceAbort`. If a joiner's signal aborts (e.g. their `totalTimeout`
- * fires), they reject immediately — they don't have to wait for the
- * originator to finish. The originator's promise continues in the
- * background for any other joiners that haven't aborted.
- *
- * If `inflightTtl` is set, the store entry is also TTL'd: if the
- * originator never settles, new callers can start fresh after the TTL
- * expires (the original promise still leaks unless an outer timeout
- * fires, but new callers aren't blocked).
- *
- * # INVARIANT: requires SyncStateStore
- *
- * The read-then-write that makes deduplication work must happen in a single
- * synchronous frame. An async store would introduce an `await` between
- * `get()` and `set()`, letting two concurrent callers both see a miss and
- * both launch work. The `REQUIRES_SYNC_STORE` symbol on the returned
- * `PolicyApplier` lets `execute()` enforce this at runtime for JS callers
- * that bypass TypeScript.
- */
+let generationCounter = 0;
+function nextGeneration() {
+    generationCounter = (generationCounter + 1) % Number.MAX_SAFE_INTEGER;
+    return generationCounter;
+}
 function dedupePolicy(opts = { enabled: true }) {
-    const inflightTtl = opts.inflightTtl;
+    const inflightTtl = opts.inflightTtl ?? limits_js_1.LIMITS.DEFAULT_INFLIGHT_TTL;
     const applier = (fn, ctx) => {
-        // Cast is safe: execute() verifies isSyncStore(ctx.store) before calling
-        // any policy tagged with REQUIRES_SYNC_STORE.
         const syncCtx = ctx;
         return async (signal) => {
             const key = NS + syncCtx.key;
-            // Fast path: an in-flight promise already exists. Join it.
-            // raceAbort ensures we don't block on a hung originator if our own
-            // signal aborts.
             const existing = syncCtx.store.get(key);
             if (existing) {
+                const obs = syncCtx.observability;
+                if (obs) {
+                    obs.joinerCounter++;
+                    (0, safeCall_js_1.safeCall)(obs.hooks.onDedupeJoin, {
+                        type: 'dedupe-join', key: syncCtx.key, traceId: obs.traceId,
+                        timestamp: Date.now(), joinerPosition: obs.joinerCounter,
+                    });
+                }
                 try {
                     const value = await (0, abort_js_1.raceAbort)(existing.promise, signal);
-                    return value;
-                }
-                finally {
-                    // Copy the originator's final meta into our own, regardless of
-                    // success or failure. By the time `existing.promise` has settled
-                    // (or our signal aborted), the originator's retry loop has set
-                    // the final attempt count.
                     syncCtx.meta.attempts = existing.meta.attempts;
                     syncCtx.meta.source = existing.meta.source;
+                    return value;
+                }
+                catch (err) {
+                    if (signal.aborted) {
+                        syncCtx.meta.attempts = 0;
+                    }
+                    else {
+                        syncCtx.meta.attempts = existing.meta.attempts;
+                        syncCtx.meta.source = existing.meta.source;
+                    }
+                    throw err;
                 }
             }
-            // Originator path: start the work and publish the promise.
-            //
-            // We race fn against `signal` so that if our own signal aborts while
-            // fn is pending, we reject (and the .finally cleans up the store).
-            // The stored promise is the RACED one — joiners see the same
-            // rejection if they join before cleanup.
-            const promise = (0, abort_js_1.raceAbort)(Promise.resolve(fn(signal)), signal).finally(() => syncCtx.store.delete(key));
-            const entry = { promise, meta: syncCtx.meta };
+            const generation = nextGeneration();
+            const rawPromise = Promise.resolve(fn(signal));
+            const entry = {
+                promise: rawPromise,
+                meta: syncCtx.meta,
+                generation,
+            };
             syncCtx.store.set(key, entry, inflightTtl);
-            return promise;
+            const cleanup = () => {
+                try {
+                    const current = syncCtx.store.get(key);
+                    if (current && current.generation === generation) {
+                        syncCtx.store.delete(key);
+                    }
+                }
+                catch {
+                }
+            };
+            rawPromise.then(cleanup, cleanup).catch(() => { });
+            return (0, abort_js_1.raceAbort)(rawPromise, signal);
         };
     };
     applier[executor_js_1.REQUIRES_SYNC_STORE] = true;

package/dist/policies/dedupe.d.ts

@@ -1,44 +1,3 @@
 import type { PolicyApplier, DedupeOptions } from '../types/index.js';
-/**
- * Collapse concurrent calls that share the same key into one in-flight Promise.
- *
- * # How it works
- *
- * The first caller (originator) starts the work and stores
- * `{ promise, meta }` in the store under `dedupe:<key>`. Every subsequent
- * caller that arrives before the promise settles receives the SAME promise
- * — no duplicate work.
- *
- * # Shared `meta` (fixes v1.0 trade-off)
- *
- * The originator's `ctx.meta` reference is stored alongside the promise.
- * Inner policies (e.g. `retryPolicy`) mutate it as they run. After the
- * promise settles, joiners copy `attempts` and `source` from the shared
- * meta into their own `ctx.meta`. This means a joiner's `ActResult.attempts`
- * reflects the real effort (e.g. `3` if the originator retried twice), not
- * the misleading default of `1`.
- *
- * # Abort safety (fixes hung-fn block)
- *
- * Joiners race the in-flight promise against their own AbortSignal via
- * `raceAbort`. If a joiner's signal aborts (e.g. their `totalTimeout`
- * fires), they reject immediately — they don't have to wait for the
- * originator to finish. The originator's promise continues in the
- * background for any other joiners that haven't aborted.
- *
- * If `inflightTtl` is set, the store entry is also TTL'd: if the
- * originator never settles, new callers can start fresh after the TTL
- * expires (the original promise still leaks unless an outer timeout
- * fires, but new callers aren't blocked).
- *
- * # INVARIANT: requires SyncStateStore
- *
- * The read-then-write that makes deduplication work must happen in a single
- * synchronous frame. An async store would introduce an `await` between
- * `get()` and `set()`, letting two concurrent callers both see a miss and
- * both launch work. The `REQUIRES_SYNC_STORE` symbol on the returned
- * `PolicyApplier` lets `execute()` enforce this at runtime for JS callers
- * that bypass TypeScript.
- */
 export declare function dedupePolicy<T>(opts?: DedupeOptions): PolicyApplier<T>;
 //# sourceMappingURL=dedupe.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"dedupe.d.ts","sourceRoot":"","sources":["../../src/policies/dedupe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAS,aAAa,EAAiB,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAqB3F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAE,aAAiC,GAAG,aAAa,CAAC,CAAC,CAAC,CAkDzF"}
+{"version":3,"file":"dedupe.d.ts","sourceRoot":"","sources":["../../src/policies/dedupe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAS,aAAa,EAAiB,aAAa,EAAE,MAAM,mBAAmB,CAAA;AA0D3F,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAE,aAAiC,GAAG,aAAa,CAAC,CAAC,CAAC,CA6FzF"}

package/dist/policies/dedupe.js

@@ -1,87 +1,68 @@
 import { REQUIRES_SYNC_STORE } from '../core/executor.js';
 import { raceAbort } from '../utils/abort.js';
-// Namespace so dedupe keys never collide with cache keys in the shared store.
+import { safeCall } from '../utils/safeCall.js';
+import { LIMITS } from '../utils/limits.js';
 const NS = 'dedupe:';
-/**
- * Collapse concurrent calls that share the same key into one in-flight Promise.
- *
- * # How it works
- *
- * The first caller (originator) starts the work and stores
- * `{ promise, meta }` in the store under `dedupe:<key>`. Every subsequent
- * caller that arrives before the promise settles receives the SAME promise
- * — no duplicate work.
- *
- * # Shared `meta` (fixes v1.0 trade-off)
- *
- * The originator's `ctx.meta` reference is stored alongside the promise.
- * Inner policies (e.g. `retryPolicy`) mutate it as they run. After the
- * promise settles, joiners copy `attempts` and `source` from the shared
- * meta into their own `ctx.meta`. This means a joiner's `ActResult.attempts`
- * reflects the real effort (e.g. `3` if the originator retried twice), not
- * the misleading default of `1`.
- *
- * # Abort safety (fixes hung-fn block)
- *
- * Joiners race the in-flight promise against their own AbortSignal via
- * `raceAbort`. If a joiner's signal aborts (e.g. their `totalTimeout`
- * fires), they reject immediately — they don't have to wait for the
- * originator to finish. The originator's promise continues in the
- * background for any other joiners that haven't aborted.
- *
- * If `inflightTtl` is set, the store entry is also TTL'd: if the
- * originator never settles, new callers can start fresh after the TTL
- * expires (the original promise still leaks unless an outer timeout
- * fires, but new callers aren't blocked).
- *
- * # INVARIANT: requires SyncStateStore
- *
- * The read-then-write that makes deduplication work must happen in a single
- * synchronous frame. An async store would introduce an `await` between
- * `get()` and `set()`, letting two concurrent callers both see a miss and
- * both launch work. The `REQUIRES_SYNC_STORE` symbol on the returned
- * `PolicyApplier` lets `execute()` enforce this at runtime for JS callers
- * that bypass TypeScript.
- */
+let generationCounter = 0;
+function nextGeneration() {
+    generationCounter = (generationCounter + 1) % Number.MAX_SAFE_INTEGER;
+    return generationCounter;
+}
 export function dedupePolicy(opts = { enabled: true }) {
-    const inflightTtl = opts.inflightTtl;
+    const inflightTtl = opts.inflightTtl ?? LIMITS.DEFAULT_INFLIGHT_TTL;
     const applier = (fn, ctx) => {
-        // Cast is safe: execute() verifies isSyncStore(ctx.store) before calling
-        // any policy tagged with REQUIRES_SYNC_STORE.
         const syncCtx = ctx;
         return async (signal) => {
             const key = NS + syncCtx.key;
-            // Fast path: an in-flight promise already exists. Join it.
-            // raceAbort ensures we don't block on a hung originator if our own
-            // signal aborts.
             const existing = syncCtx.store.get(key);
             if (existing) {
+                const obs = syncCtx.observability;
+                if (obs) {
+                    obs.joinerCounter++;
+                    safeCall(obs.hooks.onDedupeJoin, {
+                        type: 'dedupe-join', key: syncCtx.key, traceId: obs.traceId,
+                        timestamp: Date.now(), joinerPosition: obs.joinerCounter,
+                    });
+                }
                 try {
                     const value = await raceAbort(existing.promise, signal);
-                    return value;
-                }
-                finally {
-                    // Copy the originator's final meta into our own, regardless of
-                    // success or failure. By the time `existing.promise` has settled
-                    // (or our signal aborted), the originator's retry loop has set
-                    // the final attempt count.
                     syncCtx.meta.attempts = existing.meta.attempts;
                     syncCtx.meta.source = existing.meta.source;
+                    return value;
+                }
+                catch (err) {
+                    if (signal.aborted) {
+                        syncCtx.meta.attempts = 0;
+                    }
+                    else {
+                        syncCtx.meta.attempts = existing.meta.attempts;
+                        syncCtx.meta.source = existing.meta.source;
+                    }
+                    throw err;
                 }
             }
-            // Originator path: start the work and publish the promise.
-            //
-            // We race fn against `signal` so that if our own signal aborts while
-            // fn is pending, we reject (and the .finally cleans up the store).
-            // The stored promise is the RACED one — joiners see the same
-            // rejection if they join before cleanup.
-            const promise = raceAbort(Promise.resolve(fn(signal)), signal).finally(() => syncCtx.store.delete(key));
-            const entry = { promise, meta: syncCtx.meta };
+            const generation = nextGeneration();
+            const rawPromise = Promise.resolve(fn(signal));
+            const entry = {
+                promise: rawPromise,
+                meta: syncCtx.meta,
+                generation,
+            };
             syncCtx.store.set(key, entry, inflightTtl);
-            return promise;
+            const cleanup = () => {
+                try {
+                    const current = syncCtx.store.get(key);
+                    if (current && current.generation === generation) {
+                        syncCtx.store.delete(key);
+                    }
+                }
+                catch {
+                }
+            };
+            rawPromise.then(cleanup, cleanup).catch(() => { });
+            return raceAbort(rawPromise, signal);
         };
     };
     applier[REQUIRES_SYNC_STORE] = true;
     return applier;
 }
-//# sourceMappingURL=dedupe.js.map

package/dist/policies/noop.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noopPolicy = noopPolicy;
+function noopPolicy() {
+    return (fn, _ctx) => fn;
+}

package/dist/policies/noop.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"noop.d.ts","sourceRoot":"","sources":["../../src/policies/noop.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAS,aAAa,EAAiB,MAAM,mBAAmB,CAAA;AAoB5E,wBAAgB,UAAU,CAAC,CAAC,KAAK,aAAa,CAAC,CAAC,CAAC,CAEhD"}

package/dist/policies/noop.js

@@ -0,0 +1,3 @@
+export function noopPolicy() {
+    return (fn, _ctx) => fn;
+}

package/dist/policies/rateLimit.cjs

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rateLimitPolicy = rateLimitPolicy;
+const executor_js_1 = require("../core/executor.js");
+const errors_js_1 = require("../errors.js");
+const NS = 'rl:';
+function getState(store, key) {
+    return store.get(NS + key) ?? { timestamps: [] };
+}
+function setState(store, key, state, ttlMs) {
+    store.set(NS + key, state, ttlMs);
+}
+function rateLimitPolicy(opts) {
+    const maxCalls = Math.max(1, Math.floor(opts.maxCalls));
+    const windowMs = opts.windowMs;
+    const applier = (fn, ctx) => {
+        const syncCtx = ctx;
+        return async (signal) => {
+            if (signal.aborted)
+                return Promise.reject(signal.reason);
+            const key = syncCtx.key;
+            const now = Date.now();
+            const state = getState(syncCtx.store, key);
+            const cutoff = now - windowMs;
+            const ts = state.timestamps;
+            if (ts.length > 0 && ts[0] <= cutoff) {
+                let i = 0;
+                while (i < ts.length && ts[i] <= cutoff)
+                    i++;
+                if (i > 0) {
+                    state.timestamps = i === ts.length ? [] : ts.slice(i);
+                }
+            }
+            if (state.timestamps.length >= maxCalls) {
+                setState(syncCtx.store, key, state, windowMs);
+                throw new errors_js_1.RateLimitError(key, maxCalls, windowMs);
+            }
+            state.timestamps.push(now);
+            setState(syncCtx.store, key, state, windowMs);
+            return fn(signal);
+        };
+    };
+    applier[executor_js_1.REQUIRES_SYNC_STORE] = true;
+    return applier;
+}

package/dist/policies/rateLimit.d.ts

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

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

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

package/dist/policies/rateLimit.js

@@ -0,0 +1,42 @@
+import { REQUIRES_SYNC_STORE } from '../core/executor.js';
+import { RateLimitError } from '../errors.js';
+const NS = 'rl:';
+function getState(store, key) {
+    return store.get(NS + key) ?? { timestamps: [] };
+}
+function setState(store, key, state, ttlMs) {
+    store.set(NS + key, state, ttlMs);
+}
+export function rateLimitPolicy(opts) {
+    const maxCalls = Math.max(1, Math.floor(opts.maxCalls));
+    const windowMs = opts.windowMs;
+    const applier = (fn, ctx) => {
+        const syncCtx = ctx;
+        return async (signal) => {
+            if (signal.aborted)
+                return Promise.reject(signal.reason);
+            const key = syncCtx.key;
+            const now = Date.now();
+            const state = getState(syncCtx.store, key);
+            const cutoff = now - windowMs;
+            const ts = state.timestamps;
+            if (ts.length > 0 && ts[0] <= cutoff) {
+                let i = 0;
+                while (i < ts.length && ts[i] <= cutoff)
+                    i++;
+                if (i > 0) {
+                    state.timestamps = i === ts.length ? [] : ts.slice(i);
+                }
+            }
+            if (state.timestamps.length >= maxCalls) {
+                setState(syncCtx.store, key, state, windowMs);
+                throw new RateLimitError(key, maxCalls, windowMs);
+            }
+            state.timestamps.push(now);
+            setState(syncCtx.store, key, state, windowMs);
+            return fn(signal);
+        };
+    };
+    applier[REQUIRES_SYNC_STORE] = true;
+    return applier;
+}