@tanstack/pacer 0.13.0 → 0.15.0

package/src/async-debouncer.ts

@@ -1,5 +1,6 @@
 import { Store } from '@tanstack/store'
-import { parseFunctionOrValue } from './utils'
+import { createKey, parseFunctionOrValue } from './utils'
+import { emitChange, pacerEventClient } from './event-client'
 import type { AnyAsyncFunction, OptionalKeys } from './types'
 
 export interface AsyncDebouncerState<TFn extends AnyAsyncFunction> {
@@ -27,6 +28,10 @@ export interface AsyncDebouncerState<TFn extends AnyAsyncFunction> {
    * The result from the most recent successful function execution
    */
   lastResult: ReturnType<TFn> | undefined
+  /**
+   * Number of times maybeExecute has been called (for reduction calculations)
+   */
+  maybeExecuteCount: number
   /**
    * Number of function executions that have completed (either successfully or with errors)
    */
@@ -44,17 +49,18 @@ export interface AsyncDebouncerState<TFn extends AnyAsyncFunction> {
 function getDefaultAsyncDebouncerState<
   TFn extends AnyAsyncFunction,
 >(): AsyncDebouncerState<TFn> {
-  return structuredClone({
+  return {
     canLeadingExecute: true,
     errorCount: 0,
     isExecuting: false,
     isPending: false,
     lastArgs: undefined,
     lastResult: undefined,
+    maybeExecuteCount: 0,
     settleCount: 0,
-    successCount: 0,
     status: 'idle',
-  })
+    successCount: 0,
+  }
 }
 
 /**
@@ -71,6 +77,11 @@ export interface AsyncDebouncerOptions<TFn extends AnyAsyncFunction> {
    * Initial state for the async debouncer
    */
   initialState?: Partial<AsyncDebouncerState<TFn>>
+  /**
+   * Optional key to identify this async debouncer instance.
+   * If provided, the async debouncer will be identified by this key in the devtools and PacerProvider if applicable.
+   */
+  key?: string
   /**
    * Whether to execute on the leading edge of the timeout.
    * Defaults to false.
@@ -119,7 +130,7 @@ export interface AsyncDebouncerOptions<TFn extends AnyAsyncFunction> {
 
 type AsyncDebouncerOptionsWithOptionalCallbacks = OptionalKeys<
   AsyncDebouncerOptions<any>,
-  'initialState' | 'onError' | 'onSettled' | 'onSuccess'
+  'initialState' | 'onError' | 'onSettled' | 'onSuccess' | 'key'
 >
 
 const defaultOptions: AsyncDebouncerOptionsWithOptionalCallbacks = {
@@ -178,6 +189,7 @@ export class AsyncDebouncer<TFn extends AnyAsyncFunction> {
   readonly store: Store<Readonly<AsyncDebouncerState<TFn>>> = new Store<
     AsyncDebouncerState<TFn>
   >(getDefaultAsyncDebouncerState<TFn>())
+  key: string
   options: AsyncDebouncerOptions<TFn>
   #abortController: AbortController | null = null
   #timeoutId: NodeJS.Timeout | null = null
@@ -186,15 +198,22 @@ export class AsyncDebouncer<TFn extends AnyAsyncFunction> {
     | null = null
 
   constructor(
-    private fn: TFn,
+    public fn: TFn,
     initialOptions: AsyncDebouncerOptions<TFn>,
   ) {
+    this.key = createKey(initialOptions.key)
     this.options = {
       ...defaultOptions,
       ...initialOptions,
       throwOnError: initialOptions.throwOnError ?? !initialOptions.onError,
     }
     this.#setState(this.options.initialState ?? {})
+
+    pacerEventClient.on('d-AsyncDebouncer', (event) => {
+      if (event.payload.key !== this.key) return
+      this.#setState(event.payload.store.state as AsyncDebouncerState<TFn>)
+      this.setOptions(event.payload.options)
+    })
   }
 
   /**
@@ -229,6 +248,7 @@ export class AsyncDebouncer<TFn extends AnyAsyncFunction> {
                 : 'idle',
       }
     })
+    emitChange('AsyncDebouncer', this)
   }
 
   /**
@@ -264,7 +284,10 @@ export class AsyncDebouncer<TFn extends AnyAsyncFunction> {
   ): Promise<ReturnType<TFn> | undefined> => {
     if (!this.#getEnabled()) return undefined
     this.#cancelPendingExecution()
-    this.#setState({ lastArgs: args })
+    this.#setState({
+      lastArgs: args,
+      maybeExecuteCount: this.store.state.maybeExecuteCount + 1,
+    })
 
     // Handle leading execution
     if (this.options.leading && this.store.state.canLeadingExecute) {

package/src/async-queuer.ts

@@ -1,5 +1,6 @@
 import { Store } from '@tanstack/store'
-import { parseFunctionOrValue } from './utils'
+import { createKey, parseFunctionOrValue } from './utils'
+import { emitChange, pacerEventClient } from './event-client'
 import type { OptionalKeys } from './types'
 import type { QueuePosition } from './queuer'
 
@@ -8,6 +9,10 @@ export interface AsyncQueuerState<TValue> {
    * Items currently being processed by the queuer
    */
   activeItems: Array<TValue>
+  /**
+   * Number of times addItem has been called (for reduction calculations)
+   */
+  addItemCount: number
   /**
    * Number of task executions that have resulted in errors
    */
@@ -71,8 +76,9 @@ export interface AsyncQueuerState<TValue> {
 }
 
 function getDefaultAsyncQueuerState<TValue>(): AsyncQueuerState<TValue> {
-  return structuredClone({
+  return {
     activeItems: [],
+    addItemCount: 0,
     errorCount: 0,
     expirationCount: 0,
     isEmpty: true,
@@ -88,7 +94,7 @@ function getDefaultAsyncQueuerState<TValue>(): AsyncQueuerState<TValue> {
     size: 0,
     status: 'idle',
     successCount: 0,
-  })
+  }
 }
 
 export interface AsyncQueuerOptions<TValue> {
@@ -132,6 +138,11 @@ export interface AsyncQueuerOptions<TValue> {
    * Initial state for the async queuer
    */
   initialState?: Partial<AsyncQueuerState<TValue>>
+  /**
+   * Optional key to identify this async queuer instance.
+   * If provided, the async queuer will be identified by this key in the devtools and PacerProvider if applicable.
+   */
+  key?: string
   /**
    * Maximum number of items allowed in the queuer
    */
@@ -190,6 +201,7 @@ type AsyncQueuerOptionsWithOptionalCallbacks = OptionalKeys<
   | 'onItemsChange'
   | 'onExpire'
   | 'onError'
+  | 'key'
 >
 
 const defaultOptions: AsyncQueuerOptionsWithOptionalCallbacks = {
@@ -260,13 +272,15 @@ export class AsyncQueuer<TValue> {
   readonly store: Store<Readonly<AsyncQueuerState<TValue>>> = new Store<
     AsyncQueuerState<TValue>
   >(getDefaultAsyncQueuerState<TValue>())
+  key: string
   options: AsyncQueuerOptions<TValue>
   #timeoutIds: Set<NodeJS.Timeout> = new Set()
 
   constructor(
-    private fn: (item: TValue) => Promise<any>,
+    public fn: (item: TValue) => Promise<any>,
     initialOptions: AsyncQueuerOptions<TValue> = {},
   ) {
+    this.key = createKey(initialOptions.key)
     this.options = {
       ...defaultOptions,
       ...initialOptions,
@@ -290,6 +304,12 @@ export class AsyncQueuer<TValue> {
         this.addItem(item, this.options.addItemsTo ?? 'back', isLast)
       }
     }
+
+    pacerEventClient.on('d-AsyncQueuer', (e) => {
+      if (e.payload.key !== this.key) return
+      this.#setState(e.payload.store.state)
+      this.setOptions(e.payload.options)
+    })
   }
 
   /**
@@ -324,6 +344,7 @@ export class AsyncQueuer<TValue> {
         status,
       }
     })
+    emitChange('AsyncQueuer', this)
   }
 
   /**
@@ -402,6 +423,10 @@ export class AsyncQueuer<TValue> {
     position: QueuePosition = this.options.addItemsTo ?? 'back',
     runOnItemsChange: boolean = true,
   ): boolean => {
+    this.#setState({
+      addItemCount: this.store.state.addItemCount + 1,
+    })
+
     if (this.store.state.items.length >= (this.options.maxSize ?? Infinity)) {
       this.#setState({
         rejectionCount: this.store.state.rejectionCount + 1,

package/src/async-rate-limiter.ts

@@ -1,5 +1,6 @@
 import { Store } from '@tanstack/store'
-import { parseFunctionOrValue } from './utils'
+import { createKey, parseFunctionOrValue } from './utils'
+import { emitChange, pacerEventClient } from './event-client'
 import type { AnyAsyncFunction } from './types'
 
 export interface AsyncRateLimiterState<TFn extends AnyAsyncFunction> {
@@ -39,6 +40,10 @@ export interface AsyncRateLimiterState<TFn extends AnyAsyncFunction> {
    * Number of function executions that have completed successfully
    */
   successCount: number
+  /**
+   * Number of times maybeExecute has been called (for reduction calculations)
+   */
+  maybeExecuteCount: number
 }
 
 function getDefaultAsyncRateLimiterState<
@@ -50,10 +55,11 @@ function getDefaultAsyncRateLimiterState<
     isExceeded: false,
     isExecuting: false,
     lastResult: undefined,
+    maybeExecuteCount: 0,
     rejectionCount: 0,
     settleCount: 0,
-    successCount: 0,
     status: 'idle',
+    successCount: 0,
   }
 }
 
@@ -71,6 +77,11 @@ export interface AsyncRateLimiterOptions<TFn extends AnyAsyncFunction> {
    * Initial state for the rate limiter
    */
   initialState?: Partial<AsyncRateLimiterState<TFn>>
+  /**
+   * Optional key to identify this async rate limiter instance.
+   * If provided, the async rate limiter will be identified by this key in the devtools and PacerProvider if applicable.
+   */
+  key?: string
   /**
    * Maximum number of executions allowed within the time window.
    * Can be a number or a function that returns a number.
@@ -127,7 +138,7 @@ export interface AsyncRateLimiterOptions<TFn extends AnyAsyncFunction> {
 
 const defaultOptions: Omit<
   Required<AsyncRateLimiterOptions<any>>,
-  'initialState' | 'onError' | 'onReject' | 'onSettled' | 'onSuccess'
+  'initialState' | 'onError' | 'onReject' | 'onSettled' | 'onSuccess' | 'key'
 > = {
   enabled: true,
   limit: 1,
@@ -206,13 +217,15 @@ export class AsyncRateLimiter<TFn extends AnyAsyncFunction> {
   readonly store: Store<Readonly<AsyncRateLimiterState<TFn>>> = new Store<
     AsyncRateLimiterState<TFn>
   >(getDefaultAsyncRateLimiterState<TFn>())
+  key: string
   options: AsyncRateLimiterOptions<TFn>
   #timeoutIds: Set<NodeJS.Timeout> = new Set()
 
   constructor(
-    private fn: TFn,
+    public fn: TFn,
     initialOptions: AsyncRateLimiterOptions<TFn>,
   ) {
+    this.key = createKey(initialOptions.key)
     this.options = {
       ...defaultOptions,
       ...initialOptions,
@@ -222,6 +235,12 @@ export class AsyncRateLimiter<TFn extends AnyAsyncFunction> {
     for (const executionTime of this.#getExecutionTimesInWindow()) {
       this.#setCleanupTimeout(executionTime)
     }
+
+    pacerEventClient.on('d-AsyncRateLimiter', (event) => {
+      if (event.payload.key !== this.key) return
+      this.#setState(event.payload.store.state)
+      this.setOptions(event.payload.options)
+    })
   }
 
   /**
@@ -251,6 +270,7 @@ export class AsyncRateLimiter<TFn extends AnyAsyncFunction> {
         status,
       }
     })
+    emitChange('AsyncRateLimiter', this)
   }
 
   /**
@@ -302,6 +322,10 @@ export class AsyncRateLimiter<TFn extends AnyAsyncFunction> {
   maybeExecute = async (
     ...args: Parameters<TFn>
   ): Promise<ReturnType<TFn> | undefined> => {
+    this.#setState({
+      maybeExecuteCount: this.store.state.maybeExecuteCount + 1,
+    })
+
     this.#cleanupOldExecutions()
 
     const relevantExecutionTimes = this.#getExecutionTimesInWindow()

package/src/async-throttler.ts

@@ -1,5 +1,6 @@
 import { Store } from '@tanstack/store'
-import { parseFunctionOrValue } from './utils'
+import { createKey, parseFunctionOrValue } from './utils'
+import { emitChange, pacerEventClient } from './event-client'
 import type { AnyAsyncFunction, OptionalKeys } from './types'
 
 export interface AsyncThrottlerState<TFn extends AnyAsyncFunction> {
@@ -27,6 +28,10 @@ export interface AsyncThrottlerState<TFn extends AnyAsyncFunction> {
    * The result from the most recent successful function execution
    */
   lastResult: ReturnType<TFn> | undefined
+  /**
+   * Number of times maybeExecute has been called (for reduction calculations)
+   */
+  maybeExecuteCount: number
   /**
    * Timestamp when the next execution can occur in milliseconds
    */
@@ -48,18 +53,19 @@ export interface AsyncThrottlerState<TFn extends AnyAsyncFunction> {
 function getDefaultAsyncThrottlerState<
   TFn extends AnyAsyncFunction,
 >(): AsyncThrottlerState<TFn> {
-  return structuredClone({
+  return {
     errorCount: 0,
     isExecuting: false,
     isPending: false,
     lastArgs: undefined,
     lastExecutionTime: 0,
     lastResult: undefined,
+    maybeExecuteCount: 0,
     nextExecutionTime: undefined,
     settleCount: 0,
     status: 'idle',
     successCount: 0,
-  })
+  }
 }
 
 /**
@@ -76,6 +82,11 @@ export interface AsyncThrottlerOptions<TFn extends AnyAsyncFunction> {
    * Initial state for the async throttler
    */
   initialState?: Partial<AsyncThrottlerState<TFn>>
+  /**
+   * Optional key to identify this async throttler instance.
+   * If provided, the async throttler will be identified by this key in the devtools and PacerProvider if applicable.
+   */
+  key?: string
   /**
    * Whether to execute the function immediately when called
    * Defaults to true
@@ -189,6 +200,7 @@ export class AsyncThrottler<TFn extends AnyAsyncFunction> {
   readonly store: Store<Readonly<AsyncThrottlerState<TFn>>> = new Store<
     AsyncThrottlerState<TFn>
   >(getDefaultAsyncThrottlerState<TFn>())
+  key: string
   options: AsyncThrottlerOptions<TFn>
   #abortController: AbortController | null = null
   #timeoutId: NodeJS.Timeout | null = null
@@ -197,15 +209,21 @@ export class AsyncThrottler<TFn extends AnyAsyncFunction> {
     | null = null
 
   constructor(
-    private fn: TFn,
+    public fn: TFn,
     initialOptions: AsyncThrottlerOptions<TFn>,
   ) {
+    this.key = createKey(initialOptions.key)
     this.options = {
       ...defaultOptions,
       ...initialOptions,
       throwOnError: initialOptions.throwOnError ?? !initialOptions.onError,
     }
     this.#setState(this.options.initialState ?? {})
+    pacerEventClient.on('d-AsyncThrottler', (event) => {
+      if (event.payload.key !== this.key) return
+      this.#setState(event.payload.store.state as AsyncThrottlerState<TFn>)
+      this.setOptions(event.payload.options)
+    })
   }
 
   /**
@@ -240,6 +258,7 @@ export class AsyncThrottler<TFn extends AnyAsyncFunction> {
                 : 'idle',
       }
     })
+    emitChange('AsyncThrottler', this)
   }
 
   /**
@@ -286,7 +305,10 @@ export class AsyncThrottler<TFn extends AnyAsyncFunction> {
     const timeSinceLastExecution = now - this.store.state.lastExecutionTime
     const wait = this.#getWait()
     // Store the most recent arguments for potential trailing execution
-    this.#setState({ lastArgs: args })
+    this.#setState({
+      lastArgs: args,
+      maybeExecuteCount: this.store.state.maybeExecuteCount + 1,
+    })
 
     this.#resolvePreviousPromiseInternal()
 

package/src/batcher.ts

@@ -1,5 +1,6 @@
 import { Store } from '@tanstack/store'
-import { parseFunctionOrValue } from './utils'
+import { createKey, parseFunctionOrValue } from './utils'
+import { emitChange, pacerEventClient } from './event-client'
 import type { OptionalKeys } from './types'
 
 export interface BatcherState<TValue> {
@@ -58,6 +59,11 @@ export interface BatcherOptions<TValue> {
    * Initial state for the batcher
    */
   initialState?: Partial<BatcherState<TValue>>
+  /**
+   * Optional key to identify this batcher instance.
+   * If provided, the batcher will be identified by this key in the devtools and PacerProvider if applicable.
+   */
+  key?: string
   /**
    * Maximum number of items in a batch
    * @default Infinity
@@ -87,7 +93,7 @@ export interface BatcherOptions<TValue> {
 
 type BatcherOptionsWithOptionalCallbacks<TValue> = OptionalKeys<
   Required<BatcherOptions<TValue>>,
-  'initialState' | 'onExecute' | 'onItemsChange'
+  'initialState' | 'onExecute' | 'onItemsChange' | 'key'
 >
 
 const defaultOptions: BatcherOptionsWithOptionalCallbacks<any> = {
@@ -139,18 +145,26 @@ export class Batcher<TValue> {
   readonly store: Store<Readonly<BatcherState<TValue>>> = new Store(
     getDefaultBatcherState<TValue>(),
   )
+  key: string
   options: BatcherOptionsWithOptionalCallbacks<TValue>
   #timeoutId: NodeJS.Timeout | null = null
 
   constructor(
-    private fn: (items: Array<TValue>) => void,
+    public fn: (items: Array<TValue>) => void,
     initialOptions: BatcherOptions<TValue>,
   ) {
+    this.key = createKey(initialOptions.key)
     this.options = {
       ...defaultOptions,
       ...initialOptions,
     }
     this.#setState(this.options.initialState ?? {})
+
+    pacerEventClient.on('d-Batcher', (event) => {
+      if (event.payload.key !== this.key) return
+      this.#setState(event.payload.store.state)
+      this.setOptions(event.payload.options)
+    })
   }
 
   /**
@@ -176,6 +190,7 @@ export class Batcher<TValue> {
         status: isPending ? 'pending' : 'idle',
       }
     })
+    emitChange('Batcher', this)
   }
 
   #getWait = (): number => {

package/src/debouncer.ts

@@ -1,5 +1,6 @@
 import { Store } from '@tanstack/store'
-import { parseFunctionOrValue } from './utils'
+import { createKey, parseFunctionOrValue } from './utils'
+import { emitChange, pacerEventClient } from './event-client'
 import type { AnyFunction } from './types'
 
 export interface DebouncerState<TFn extends AnyFunction> {
@@ -19,6 +20,10 @@ export interface DebouncerState<TFn extends AnyFunction> {
    * The arguments from the most recent call to maybeExecute
    */
   lastArgs: Parameters<TFn> | undefined
+  /**
+   * Number of times maybeExecute has been called (for reduction calculations)
+   */
+  maybeExecuteCount: number
   /**
    * Current execution status - 'idle' when not active, 'pending' when waiting for timeout
    */
@@ -28,13 +33,14 @@ export interface DebouncerState<TFn extends AnyFunction> {
 function getDefaultDebouncerState<
   TFn extends AnyFunction,
 >(): DebouncerState<TFn> {
-  return structuredClone({
+  return {
     canLeadingExecute: true,
     executionCount: 0,
     isPending: false,
     lastArgs: undefined,
     status: 'idle',
-  })
+    maybeExecuteCount: 0,
+  }
 }
 
 /**
@@ -51,6 +57,11 @@ export interface DebouncerOptions<TFn extends AnyFunction> {
    * Initial state for the debouncer
    */
   initialState?: Partial<DebouncerState<TFn>>
+  /**
+   * A key to identify the debouncer.
+   * If provided, the debouncer will be identified by this key in the devtools and PacerProvider if applicable.
+   */
+  key?: string
   /**
    * Whether to execute on the leading edge of the timeout.
    * The first call will execute immediately and the rest will wait the delay.
@@ -76,7 +87,7 @@ export interface DebouncerOptions<TFn extends AnyFunction> {
 
 const defaultOptions: Omit<
   Required<DebouncerOptions<any>>,
-  'initialState' | 'onExecute'
+  'initialState' | 'onExecute' | 'key'
 > = {
   enabled: true,
   leading: false,
@@ -119,18 +130,26 @@ export class Debouncer<TFn extends AnyFunction> {
   readonly store: Store<Readonly<DebouncerState<TFn>>> = new Store(
     getDefaultDebouncerState<TFn>(),
   )
+  key: string
   options: DebouncerOptions<TFn>
   #timeoutId: NodeJS.Timeout | undefined
 
   constructor(
-    private fn: TFn,
+    public fn: TFn,
     initialOptions: DebouncerOptions<TFn>,
   ) {
+    this.key = createKey(initialOptions.key)
     this.options = {
       ...defaultOptions,
       ...initialOptions,
     }
     this.#setState(this.options.initialState ?? {})
+
+    pacerEventClient.on('d-Debouncer', (event) => {
+      if (event.payload.key !== this.key) return
+      this.#setState(event.payload.store.state as DebouncerState<TFn>)
+      this.setOptions(event.payload.options)
+    })
   }
 
   /**
@@ -161,6 +180,7 @@ export class Debouncer<TFn extends AnyFunction> {
             : 'idle',
       }
     })
+    emitChange('Debouncer', this)
   }
 
   /**
@@ -183,6 +203,11 @@ export class Debouncer<TFn extends AnyFunction> {
    */
   maybeExecute = (...args: Parameters<TFn>): void => {
     if (!this.#getEnabled()) return undefined
+
+    this.#setState({
+      maybeExecuteCount: this.store.state.maybeExecuteCount + 1,
+    })
+
     let _didLeadingExecute = false
 
     // Handle leading execution

package/src/event-client.ts

@@ -0,0 +1,63 @@
+import { EventClient } from '@tanstack/devtools-event-client'
+import type { AsyncBatcher } from './async-batcher'
+import type { AsyncDebouncer } from './async-debouncer'
+import type { AsyncQueuer } from './async-queuer'
+import type { AsyncRateLimiter } from './async-rate-limiter'
+import type { AsyncThrottler } from './async-throttler'
+import type { Debouncer } from './debouncer'
+import type { Batcher } from './batcher'
+import type { Queuer } from './queuer'
+import type { RateLimiter } from './rate-limiter'
+import type { Throttler } from './throttler'
+
+export interface PacerEventMap {
+  'pacer:d-AsyncBatcher': AsyncBatcher<any>
+  'pacer:d-AsyncDebouncer': AsyncDebouncer<any>
+  'pacer:d-AsyncQueuer': AsyncQueuer<any>
+  'pacer:d-AsyncRateLimiter': AsyncRateLimiter<any>
+  'pacer:d-AsyncThrottler': AsyncThrottler<any>
+  'pacer:d-Batcher': Batcher<any>
+  'pacer:d-Debouncer': Debouncer<any>
+  'pacer:d-Queuer': Queuer<any>
+  'pacer:d-RateLimiter': RateLimiter<any>
+  'pacer:d-Throttler': Throttler<any>
+  'pacer:AsyncBatcher': AsyncBatcher<any>
+  'pacer:AsyncDebouncer': AsyncDebouncer<any>
+  'pacer:AsyncQueuer': AsyncQueuer<any>
+  'pacer:AsyncRateLimiter': AsyncRateLimiter<any>
+  'pacer:AsyncThrottler': AsyncThrottler<any>
+  'pacer:Batcher': Batcher<any>
+  'pacer:Debouncer': Debouncer<any>
+  'pacer:Queuer': Queuer<any>
+  'pacer:RateLimiter': RateLimiter<any>
+  'pacer:Throttler': Throttler<any>
+}
+
+export type PacerEventName = keyof PacerEventMap extends `pacer:${infer T}`
+  ? T
+  : never
+
+class PacerEventClient extends EventClient<PacerEventMap> {
+  constructor(props?: { debug: boolean }) {
+    super({
+      pluginId: 'pacer',
+      debug: props?.debug,
+    })
+  }
+}
+
+export const emitChange = <
+  TSuffix extends Extract<
+    keyof PacerEventMap,
+    `${string}:${string}`
+  > extends `${string}:${infer S}`
+    ? S
+    : never,
+>(
+  event: TSuffix,
+  payload: PacerEventMap[`pacer:${TSuffix}`],
+) => {
+  pacerEventClient.emit(event, payload)
+}
+
+export const pacerEventClient = new PacerEventClient()

package/src/index.ts

@@ -10,3 +10,5 @@ export * from './rate-limiter'
 export * from './throttler'
 export * from './types'
 export * from './utils'
+export { pacerEventClient } from './event-client'
+export type { PacerEventMap, PacerEventName } from './event-client'