@asaidimu/utils-store 10.2.3 → 10.2.5

package/index.d.cts

@@ -0,0 +1,1269 @@
+//#region src/persistence/types.d.ts
+interface SimplePersistence<T> {
+  /**
+   * Persists data to storage.
+   *
+   * @param id The **unique identifier of the *consumer instance*** making the change. This is NOT the ID of the data (`T`) itself.
+   * Think of it as the ID of the specific browser tab, component, or module that's currently interacting with the persistence layer.
+   * It should typically be a **UUID** generated once at the consumer instance's instantiation.
+   * This `id` is crucial for the `subscribe` method, helping to differentiate updates originating from the current instance versus other instances/tabs, thereby preventing self-triggered notification loops.
+   * @param state The state (of type T) to persist. This state is generally considered the **global or shared state** that all instances interact with.
+   * @returns `true` if the operation was successful, `false` if an error occurred. For asynchronous implementations (like `IndexedDBPersistence`), this returns a `Promise<boolean>`.
+   */
+  set(id: string, state: T): boolean | Promise<boolean>;
+  /**
+   * Retrieves the global persisted data from storage.
+   *
+   * @returns The retrieved state of type `T`, or `null` if no data is found or if an error occurs during retrieval/parsing.
+   * For asynchronous implementations, this returns a `Promise<T | null>`.
+   */
+  get(): (T | null) | Promise<T | null>;
+  /**
+   * Subscribes to changes in the global persisted data that originate from *other* instances of your application (e.g., other tabs or independent components using the same persistence layer).
+   *
+   * @param id The **unique identifier of the *consumer instance* subscribing**. This allows the persistence implementation to filter out notifications that were initiated by the subscribing instance itself.
+   * @param callback The function to call when the global persisted data changes from *another* source. The new state (`T`) is passed as an argument to this callback.
+   * @returns A function that, when called, will unsubscribe the provided callback from future updates. Call this when your component or instance is no longer active to prevent memory leaks.
+   */
+  subscribe(id: string, callback: (state: T) => void): () => void;
+  /**
+   * Clears (removes) the entire global persisted data from storage.
+   *
+   * @returns `true` if the operation was successful, `false` if an error occurred. For asynchronous implementations, this returns a `Promise<boolean>`.
+   */
+  clear(): boolean | Promise<boolean>;
+  /**
+   * Returns metadata about the persistence layer.
+   *
+   * This is useful for distinguishing between multiple apps running on the same host
+   * (e.g., several apps served at `localhost:3000` that share the same storage key).
+   *
+   * @returns An object containing:
+   * - `version`: The semantic version string of the persistence schema or application.
+   * - `id`: A unique identifier for the application using this persistence instance.
+   */
+  stats(): {
+    version: string;
+    id: string;
+  };
+}
+//#endregion
+//#region src/events/types.d.ts
+/**
+ * Interface defining the shape of the EventBus.
+ * @template TEventMap - A record mapping event names to their respective payload types.
+ */
+interface EventBus<TEventMap extends Record<string, any>> {
+  /**
+   * Subscribes to a specific event by name.
+   * @param eventName - The name of the event to subscribe to.
+   * @param callback - The function to call when the event is emitted.
+   * @param options -  Extra options to determine the behaviour of the
+   * subscription
+   * @returns A function to unsubscribe from the event.
+   */
+  subscribe<TEventName extends keyof TEventMap | "*">(eventName: TEventName, callback: TEventName extends "*" ? (payload: TEventMap[keyof TEventMap], event: keyof TEventMap) => void : (payload: TEventMap[TEventName]) => void, options?: SubscribeOptions): () => void;
+  /**
+   * Subscribes to an event and automatically unsubscribes after it fires once.
+   * @param eventName - The name of the event to subscribe to.
+   * @param callback - The function to call when the event is emitted.
+   * @returns A function to cancel the one-shot subscription before it fires.
+   */
+  once<TEventName extends keyof TEventMap | "*">(eventName: TEventName, callback: TEventName extends "*" ? (payload: TEventMap[keyof TEventMap], event: keyof TEventMap) => void : (payload: TEventMap[TEventName]) => void, options?: SubscribeOptions): () => void;
+  /**
+   * Emits an event with a payload to all subscribed listeners.
+   * @param event - An object containing the event name and payload.
+   */
+  emit: <TEventName extends keyof TEventMap>(event: {
+    name: TEventName;
+    payload: TEventMap[TEventName];
+  }) => void;
+  /**
+   * Retrieves metrics about event bus usage.
+   * @returns An object containing various metrics.
+   */
+  metrics: () => EventMetrics;
+  /**
+   * Clears all subscriptions and resets metrics.
+   *
+   * After calling `clear()`, the bus is fully reset and can be reused
+   * cross-tab communication is re-established if it was previously enabled.
+   *
+   * @param options - Optional configuration object.
+   * @param options.permanent - If `true`, the bus becomes permanently unusable after clearing.
+   *                            Defaults to `false`.
+   * @returns {void}
+   */
+  clear: (options?: {
+    permanent?: boolean;
+  }) => void;
+}
+/**
+ * Interface defining the metrics tracked by the EventBus.
+ */
+interface EventMetrics {
+  /** Total number of events emitted (both sync and deferred paths). */
+  totalEvents: number;
+  /** Number of active subscriptions across all event names. */
+  activeSubscriptions: number;
+  /** Map of event names to their emission counts. */
+  eventCounts: Map<string, number>;
+  /** Average duration of event dispatch in milliseconds. */
+  averageEmitDuration: number;
+}
+interface SubscribeOptions {
+  /**
+   * Debounce delay in milliseconds. When multiple events arrive in quick
+   * succession, the callback runs only after the quiet period ends, using the
+   * latest payload. Default = no debouncing.
+   */
+  debounce?: number;
+}
+//#endregion
+//#region src/store/types.d.ts
+/**
+ * Utility type for representing partial updates to the state, allowing deep nesting.
+ * It makes all properties optional and applies the same transformation recursively
+ * to nested objects, allowing for selective updates while
+ * preserving the original structure. It also includes the original type T and
+ * undefined as possibilities for the top level and nested values.
+ */
+type DeepPartial<T> = T extends object ? T extends readonly (infer U)[] ? readonly (DeepPartial<U> | undefined)[] | undefined | T : T extends (infer U)[] ? (DeepPartial<U> | undefined)[] | undefined | T : { [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> | undefined : T[K] | undefined } | undefined | T : T | undefined | symbol;
+/**
+ * Interface for performance and execution metrics of the state store.
+ */
+interface StoreMetrics {
+  /** The number of times the state has been successfully updated. */
+  updateCount: number;
+  /** The total number of listener functions executed in response to state changes. */
+  listenerExecutions: number;
+  /** The average time taken for a state update process to complete (in milliseconds). */
+  averageUpdateTime: number;
+  /** The size (e.g., number of paths changed) of the largest single state update. */
+  largestUpdateSize: number;
+  /** List of state paths that trigger the most listener executions. */
+  mostActiveListenerPaths: string[];
+  /** The total number of update attempts (including blocked ones). */
+  totalUpdates: number;
+  /** The number of updates that were blocked by blocking middleware. */
+  blockedUpdates: number;
+  /** The average duration of a state update cycle (in milliseconds). */
+  averageUpdateDuration: number;
+  /** The total number of middleware functions executed. */
+  middlewareExecutions: number;
+  /** The total number of transactions initiated. */
+  transactionCount: number;
+  /** The total number of store events fired. */
+  totalEventsFired: number;
+  /** The total number of actions dispatched. */
+  totalActionsDispatched: number;
+  /** The total number of actions that completed successfully. */
+  totalActionsSucceeded: number;
+  /** The total number of actions that failed with an error. */
+  totalActionsFailed: number;
+  /** The average duration of an action execution (in milliseconds). */
+  averageActionDuration: number;
+}
+/**
+ * Extended store state for monitoring the current execution status (e.g., if an update is in progress).
+ */
+interface StoreExecutionState<T> {
+  /** Indicates if a state update process is currently executing. */
+  executing: boolean;
+  /** The changes (DeepPartial) currently being processed in the execution cycle. Null if none. */
+  changes: DeepPartial<T> | null;
+  /** A queue of pending state update functions/objects to be applied sequentially. */
+  pendingChanges: Array<StateUpdater<T>>;
+  /** Names of all currently registered middlewares. */
+  middlewares: string[];
+  /** Details of the middleware currently running. Null if none. */
+  runningMiddleware: {
+    id: string;
+    name: string;
+    startTime: number;
+  } | null;
+  /** Indicates if the store is currently within an active transaction block. */
+  transactionActive: boolean;
+}
+/**
+ * Event types emitted by the state store for observability and debugging.
+ */
+type StoreEvent = "update:start" | "update:complete" | "middleware:start" | "middleware:complete" | "middleware:error" | "middleware:blocked" | "middleware:executed" | "transaction:start" | "transaction:complete" | "transaction:error" | "persistence:ready" | "persistence:queued" | "persistence:success" | "persistence:retry" | "persistence:failed" | "persistence:queue_cleared" | "persistence:init_error" | "action:start" | "action:complete" | "action:error" | "selector:accessed" | "selector:changed";
+/**
+ * Payload for the 'selector:changed' event.
+ */
+interface SelectorChangedPayload<S> {
+  /** Unique identifier of the selector. */
+  selectorId: string;
+  /** The new computed result of the selector. */
+  newResult: S;
+  /** Timestamp of when the change occurred. */
+  timestamp: number;
+}
+/**
+ * Maps each `StoreEvent` type to its corresponding event payload interface.
+ * Uses conditional types to ensure type safety for event listeners.
+ */
+type StoreEvents = { [K in StoreEvent]: K extends "update:complete" ? {
+  /** List of state changes (deltas) applied in the update. */deltas: StateDelta[]; /** Total duration of the update process (in milliseconds). */
+  duration: number; /** Timestamp of the update completion. */
+  timestamp: number; /** Optional ID of the action that triggered the update. */
+  actionId?: string; /** The resulting new state after the update (may be a partial/transformed state). */
+  newState: any; /** True if the update was blocked by a middleware. */
+  blocked?: boolean; /** Any error that occurred during the update. */
+  error?: any;
+} : K extends "selector:accessed" ? SelectorAccessedPayload : K extends "selector:changed" ? SelectorChangedPayload<any> : K extends "action:start" ? ActionStartPayload : K extends "action:complete" ? ActionCompletePayload : K extends "action:error" ? ActionErrorPayload : K extends "middleware:start" | "middleware:complete" | "middleware:error" | "middleware:blocked" | "middleware:executed" ? MiddlewareExecution : K extends "transaction:start" | "transaction:complete" | "transaction:error" ? {
+  transactionId: string;
+  timestamp: number;
+} : K extends "persistence:queued" ? PersistenceQueuedPayload : K extends "persistence:success" ? PersistenceSuccessPayload : K extends "persistence:retry" ? PersistenceRetryPayload : K extends "persistence:failed" ? PersistenceFailedPayload : K extends "persistence:queue_cleared" ? PersistenceQueueClearedPayload : K extends "persistence:init_error" ? PersistenceInitErrorPayload : any };
+/**
+ * Payload for the 'selector:accessed' event.
+ */
+interface SelectorAccessedPayload {
+  /** Unique identifier of the selector. */
+  selectorId: string;
+  /** List of state paths accessed during the selector computation. */
+  accessedPaths: string[];
+  /** Duration of the selector computation (in milliseconds). */
+  duration: number;
+  /** Timestamp of the access. */
+  timestamp: number;
+}
+/**
+ * Payload for the 'action:start' event.
+ */
+interface ActionStartPayload {
+  /** Unique identifier for the action execution. */
+  actionId: string;
+  /** Name of the action function. */
+  name: string;
+  /** The parameters passed to the action function. */
+  params: any[];
+  /** Timestamp of when the action execution started. */
+  timestamp: number;
+}
+/**
+ * Payload for the 'action:complete' event (successful action execution).
+ */
+interface ActionCompletePayload {
+  /** Unique identifier for the action execution. */
+  actionId: string;
+  /** Name of the action function. */
+  name: string;
+  /** The parameters passed to the action function. */
+  params: any[];
+  /** Timestamp of when the action execution started. */
+  startTime: number;
+  /** Timestamp of when the action execution completed. */
+  endTime: number;
+  /** Total duration of the action execution (in milliseconds). */
+  duration: number;
+  /** The result returned by the action function. */
+  result: any;
+}
+/**
+ * Payload for the 'action:error' event (failed action execution).
+ */
+interface ActionErrorPayload {
+  /** Unique identifier for the action execution. */
+  actionId: string;
+  /** Name of the action function. */
+  name: string;
+  /** The parameters passed to the action function. */
+  params: any[];
+  /** Timestamp of when the action execution started. */
+  startTime: number;
+  /** Timestamp of when the action execution ended (with error). */
+  endTime: number;
+  /** Total duration of the action execution (in milliseconds). */
+  duration: number;
+  /** The error object. */
+  error: any;
+}
+/**
+ * Type for a generic middleware function.
+ * It receives the current state and the incoming update, and can return
+ * a modified `DeepPartial<T>` (transforming the update) or `void`.
+ */
+type Middleware<T> = (state: T, update: DeepPartial<T>) => Promise<DeepPartial<T>> | Promise<void> | DeepPartial<T> | void;
+/**
+ * Middleware execution information for event emissions and tracking.
+ */
+interface MiddlewareExecution {
+  /** Unique identifier for the middleware instance. */
+  id: string;
+  /** Name of the middleware. */
+  name: string;
+  /** Timestamp of when the middleware execution started. */
+  startTime: number;
+  /** Timestamp of when the middleware execution completed. */
+  endTime: number;
+  /** Total duration of the middleware execution (in milliseconds). */
+  duration: number;
+  /** True if the middleware blocked the update. */
+  blocked: boolean;
+  /** Error object if the middleware failed. */
+  error?: Error;
+  /** List of state changes (deltas) that resulted from this middleware's transformation. */
+  deltas: StateDelta[];
+}
+/**
+ * Represents a single change to the state, detailing the path, old value, and new value.
+ */
+interface StateDelta {
+  /** Dot-separated path to the changed property (e.g., "user.profile.name"). */
+  path: string;
+  /** The value of the property *before* the update. */
+  oldValue: any;
+  /** The value of the property *after* the update. */
+  newValue: any;
+}
+/**
+ * Represents a state update, which can be:
+ * 1. The full new state (`T`).
+ * 2. A partial update object (`DeepPartial<T>`).
+ * 3. A function that receives the current state and returns a partial update (sync or async).
+ */
+type StateUpdater<T> = T | DeepPartial<T> | ((state: T) => DeepPartial<T> | Promise<DeepPartial<T>>);
+/**
+ * A unique symbol used within DeepPartial objects to explicitly signal that a property
+ * should be deleted from the state object.
+ */
+declare const DELETE_SYMBOL: any;
+/**
+ * Core types for the reactive data store
+ */
+/**
+ * Type for a Transform Middleware function.
+ * It modifies (transforms) the incoming changes and must return a `DeepPartial<T>`.
+ */
+type TransformMiddleware<T> = (state: T, changes: DeepPartial<T>) => Promise<DeepPartial<T>> | DeepPartial<T>;
+/**
+ * Type for a Blocking Middleware function.
+ * It determines whether the state update should proceed or be blocked.
+ * It returns a boolean or an object containing a `block` boolean and an optional `error`.
+ */
+type BlockingMiddleware<T> = (state: T, changes: DeepPartial<T>) => Promise<boolean | {
+  block: boolean;
+  error?: Error;
+}> | boolean | {
+  block: boolean;
+  error?: Error;
+};
+/**
+ * Type representing the configuration object passed to the `use` method to register a middleware.
+ */
+interface MiddlewareConfig<T> {
+  /** The middleware function (can be a transform or blocking middleware). */
+  action: TransformMiddleware<T> | BlockingMiddleware<T>;
+  /** An optional, human-readable name for the middleware. */
+  name?: string;
+  /** If true, the middleware is treated as a blocking middleware (must return a boolean or `{ block: boolean }`). */
+  block?: boolean;
+}
+/**
+ * Interface for a reactive selector result, providing access to the value and subscription capabilities.
+ */
+interface ReactiveSelector<S> {
+  /** Unique identifier for the selector. */
+  id: string;
+  /** Function to get the current computed value of the selector. */
+  get: () => S;
+  /**
+   * Subscribes a callback function to run whenever the selector's result changes.
+   * Returns an unsubscribe function.
+   */
+  subscribe: (callback: (state: S) => void) => () => void;
+}
+interface ActionWatcher {
+  /** Unique identifier for the action */
+  name: string;
+  /** Function to get the current computed value of the action. */
+  status: () => boolean;
+  /**
+   * Subscribes a callback function to run whenever the action's status changes.
+   * Returns an unsubscribe function.
+   */
+  subscribe: (callback: () => void) => () => void;
+}
+interface TransactionOptions {
+  /** If true, blocks resolution until changes are fully committed to the database row */
+  flush?: boolean;
+}
+/**
+ * Interface defining the contract for the core data state store.
+ * T must be an object type.
+ */
+interface DataStore<T extends object> {
+  /**
+   * Gets the current state of the store.
+   * @param clone If true, returns a deep clone of the state; otherwise, returns the internal state reference.
+   * @returns The current state T.
+   */
+  get(clone?: boolean): T;
+  /**
+   * Gets a subset of the store.
+   * @param paths The paths which to include in the returned object.
+   * @param separator Optional separator for paths. Defaults to `.` .
+   * @returns An object of the shape K mapping paths to their current values.
+   */
+  subset<K extends Record<string, any> = Record<string, any>>(paths: Array<string>, separator?: string): K;
+  /**
+   * Registers a named action function that can modify the state.
+   * @param action The action configuration object.
+   * @returns A function to unregister the action.
+   */
+  register<R extends any[]>(action: {
+    name: string;
+    fn: (state: T, ...args: R) => DeepPartial<T> | Promise<DeepPartial<T>>;
+    debounce?: {
+      delay: number;
+      condition?: (previous: R, current: R) => boolean;
+    };
+  }): () => void;
+  /**
+   * Executes (dispatches) a previously registered action by its name.
+   * @param name The name of the action.
+   * @param args The parameters to pass to the action function.
+   * @returns A promise that resolves to the final state after the action and subsequent updates are complete.
+   */
+  dispatch<R extends any[]>(name: string, ...args: R): Promise<T>;
+  /**
+   * Sets or updates the state using a StateUpdater.
+   * @param update The new state, partial state, or a function returning a partial state.
+   * @param options Configuration options for the set operation.
+   * @returns A promise that resolves to the current state when the update is complete.
+   */
+  set(update: StateUpdater<T>, options?: {
+    force?: boolean;
+    actionId?: string;
+  }): Promise<T>;
+  /**
+   * Creates a reactive selector that computes a derived value and tracks dependencies.
+   * @param selector A function to compute the derived state value S from the full state T.
+   * @returns A `ReactiveSelector<S>` object.
+   */
+  select<S>(selector: (state: T) => S): ReactiveSelector<S>;
+  /**
+   * Subscribes a callback to run when the data at the specified path(s) changes.
+   * @param path A single path string or an array of path strings to watch.
+   * @param callback The function to execute when a change occurs in the watched path(s).
+   * @param options Extra options to pass to the event bus
+   * @returns An unsubscribe function.
+   */
+  watch(path: string | Array<string>, callback: (state: T) => void, options?: SubscribeOptions): () => void;
+  /**
+   * Subscribes to execution‑status changes of a registered action.
+   *
+   * The provided callback is called **every time** the action transitions
+   * between idle and running (i.e. on `action:start`, `action:complete`, or
+   * `action:error` for the given name). The current status can also be read
+   * synchronously with `isActionRunning(name)`.
+   *
+   * **Deferred listener teardown**
+   * To avoid unnecessary churn when subscriptions are rapidly created and
+   * destroyed, the underlying event listeners are not removed immediately
+   * on unsubscribe. Instead, a *pending reset* is queued via `queueMicrotask`.
+   * If a new subscription for the same action arrives before that microtask
+   * executes, the reset is silently cancelled and the already‑established
+   * listeners are reused. This keeps the subscription infrastructure stable
+   * and prevents cascading notifications that could otherwise arise from
+   * repeated subscribe‑unsubscribe‑subscribe cycles.
+   *
+   * @param name - The name of the action to watch.
+   * @returns An ActionWatcher
+   */
+  watchAction(name: string): ActionWatcher;
+  /**
+   * Executes an operation function within a transaction block.
+   * All state updates (`set` or actions) within the transaction are batched and applied atomically (all or nothing).
+   * @param operation The function containing the state updates.
+   * @returns A promise that resolves to the return value of the operation function.
+   */
+  transaction<R>(operation: () => R | Promise<R>, options?: TransactionOptions): Promise<R>;
+  /**
+   * Registers a middleware function to intercept state updates.
+   * @param props The middleware configuration.
+   * @returns A function to unregister the middleware.
+   */
+  use(props: MiddlewareConfig<T>): () => boolean;
+  /**
+   * Subscribes a listener to a specific store event type.
+   * @param event The type of store event to listen for.
+   * @param listener The callback function to execute when the event fires.
+   * @returns An unsubscribe function.
+   */
+  on(event: StoreEvent, listener: (data: any) => void): () => void;
+  /**
+   * Returns the unique identifier of the store instance.
+   */
+  id(): string;
+  /**
+   * Checks whether the store is fully initialized and ready for use.
+   */
+  isReady(): boolean;
+  /**
+   * Returns a promise that resolves once the store is fully initialised.
+   * Safe to call multiple times — all callers share the same latch.
+   *
+   * @param timeout - Optional maximum wait time in milliseconds.
+   * @throws {TimeoutError} If the store does not become ready within the timeout.
+   *
+   * @example
+   * await store.ready();
+   * const state = store.get();
+   */
+  ready(timeout?: number): Promise<void>;
+  /**
+   * Returns a readonly snapshot of the current execution state of the store.
+   */
+  state(): Readonly<StoreExecutionState<T>>;
+  /**
+   * Releases all resources held by the store and renders it unusable
+   */
+  dispose(): Promise<void>;
+}
+/** Payload for the 'persistence:queued' event. */
+interface PersistenceQueuedPayload {
+  /** Unique ID for the persistence task. */
+  taskId: string;
+  /** Paths that were changed and triggered persistence. */
+  changedPaths: string[];
+  /** The current number of tasks waiting in the persistence queue. */
+  queueSize: number;
+  /** Timestamp of when the task was queued. */
+  timestamp: number;
+}
+/** Payload for the 'persistence:success' event. */
+interface PersistenceSuccessPayload {
+  /** Unique ID for the persistence task. */
+  taskId: string;
+  /** Paths that were successfully persisted. */
+  changedPaths: string[];
+  /** Duration of the persistence operation (in milliseconds). */
+  duration: number;
+  /** Timestamp of the success. */
+  timestamp: number;
+}
+/** Payload for the 'persistence:retry' event. */
+interface PersistenceRetryPayload {
+  /** Unique ID for the persistence task. */
+  taskId: string;
+  /** Current retry attempt number. */
+  attempt: number;
+  /** Maximum allowed retries. */
+  maxRetries: number;
+  /** Time until the next retry attempt (in milliseconds). */
+  nextRetryIn: number;
+  /** The error that triggered the retry. */
+  error: any;
+  /** Timestamp of the retry event. */
+  timestamp: number;
+}
+/** Payload for the 'persistence:failed' event. */
+interface PersistenceFailedPayload {
+  /** Unique ID for the persistence task. */
+  taskId: string;
+  /** Paths that failed to persist. */
+  changedPaths: string[];
+  /** Total number of attempts made. */
+  attempts: number;
+  /** The final error object. */
+  error: any;
+  /** Timestamp of the final failure. */
+  timestamp: number;
+}
+/** Payload for the 'persistence:queue_cleared' event. */
+interface PersistenceQueueClearedPayload {
+  /** The number of persistence tasks that were cleared from the queue. */
+  clearedTasks: number;
+  /** Timestamp of when the queue was cleared. */
+  timestamp: number;
+}
+/** Payload for the 'persistence:init_error' event. */
+interface PersistenceInitErrorPayload {
+  /** The error that occurred during persistence initialization. */
+  error: any;
+  /** Timestamp of the error. */
+  timestamp: number;
+}
+/**
+ * Interface describing a registered state action, including its metadata and debounce configuration.
+ */
+type StoreAction<T, R extends any[] = any[]> = {
+  /** Unique identifier for the action definition. */id: string; /** Name of the action, used for dispatching. */
+  name: string; /** The actual function that takes state and arguments, and returns a state update. */
+  action: (state: T, ...args: R) => DeepPartial<T> | Promise<DeepPartial<T>>; /** Optional configuration for debouncing action execution. */
+  debounce?: {
+    /** Active timer reference, if debouncing */timer?: ReturnType<typeof setTimeout>; /** Debounce delay in milliseconds */
+    delay: number; /** Optional condition to decide whether to debounce based on previous vs current args */
+    condition?: (previous: R | undefined, current: R) => boolean; /** Last call’s arguments, used for condition checks */
+    args?: R; /** Internal promise resolvers to prevent memory leaks */
+    resolve?: (value: any) => void;
+    reject?: (reason?: any) => void;
+  };
+};
+//#endregion
+//#region src/logger/logger.d.ts
+/**
+ * Represents the severity level of a system log entry.
+ * Levels are ordered by increasing severity: trace, debug, info, warn, error.
+ */
+type LogLevel = "trace" | "debug" | "info" | "warn" | "error";
+/**
+ * Structure representing a fully contextualized system log entry ready for sinking.
+ */
+interface SystemLog {
+  /** The severity level of the log. */
+  level: LogLevel;
+  /** A clear, human-readable string identifying the distinct event (e.g., "user_login_failed"). */
+  event: string;
+  /** Additional structured data specific to this log instantiation. */
+  data?: object;
+  /** Contextual data shared across the logger instance (e.g., traceIds, environment). */
+  context?: object;
+  /** Epoch timestamp in milliseconds denoting when the log event occurred. */
+  timestamp: number;
+}
+/**
+ * Primary logger interface providing level-specific log dispatching and context-chaining.
+ */
+interface SystemLogger {
+  /** Logs high-volume, extremely fine-grained diagnostic details. */
+  trace(event: string, data?: object): void;
+  /** Logs diagnostic information useful during local development or debugging. */
+  debug(event: string, data?: object): void;
+  /** Logs standard operational events that track the healthy flow of the system. */
+  info(event: string, data?: object): void;
+  /** Alias for the `info` logging method. */
+  log(event: string, data?: object): void;
+  /** Logs non-fatal operational anomalies or conditions that deserve attention. */
+  warn(event: string, data?: object): void;
+  /** Logs critical errors, failures, or exceptions preventing a transaction/process. */
+  error(event: string, data?: unknown): void;
+  /**
+   * Directly forwards a pre-constructed `SystemLog` record through the logger's pipeline.
+   * Combines instance context before outputting.
+   */
+  write(record: SystemLog): void;
+  /**
+   * Generates a new `SystemLogger` instance that shares the existing sinks and parent
+   * context, deeply merging the newly provided context on top.
+   *
+   * @param context - The metadata to append to all subsequent logs emitted by the child logger.
+   */
+  child(context: object): SystemLogger;
+}
+//#endregion
+//#region src/store/logger.d.ts
+type StoreLogger = SystemLogger;
+declare function createStoreLogger(logger?: StoreLogger): StoreLogger;
+//#endregion
+//#region src/store/store.d.ts
+type ReactiveDataStoreOptions<T> = {
+  timeout?: number;
+  state?: T;
+  persistence?: SimplePersistence<T>;
+  deleteMarker?: symbol;
+  logger?: StoreLogger;
+  options?: {
+    persistenceMaxRetries?: number;
+    persistenceRetryDelay?: number;
+  };
+};
+/**
+ * Main ReactiveDataStore - a robust, type-safe state management solution.
+ * It features optimistic updates, a Serializer-based update queue for safe serial
+ * execution with backpressure, a Latch for async readiness gating, and decoupled
+ * persistence.
+ *
+ * @template T The type of the data object managed by the store.
+ */
+declare class ReactiveDataStore<T extends object> implements DataStore<T> {
+  /** Manages the core application state. */
+  private coreState;
+  /** Orchestrates and executes middleware for state changes. */
+  private middlewareEngine;
+  /** Manages saving state changes to a persistence layer. */
+  private persistenceHandler;
+  /** Manages atomic state updates via transactions. */
+  private transactionManager;
+  /** Collects and provides performance metrics for the store. */
+  private metricsCollector;
+  private selectorManager;
+  private actions;
+  /**
+   * Serializer enforces FIFO serial execution of all state updates.
+   *
+   * Replaces the bare `Promise<T | void>` chain. Benefits over the old pattern:
+   * - Backpressure: rejects when the queue exceeds capacity rather than growing
+   *   unboundedly under write pressure.
+   * - Clean shutdown: `close()` in dispose() immediately rejects any subsequent
+   *   `set()` calls with a clear error instead of silently enqueuing them.
+   * - Observability: `updateSerializer.running()` and `updateSerializer.pending()`
+   *   replace the manually-managed `executionState.executing` flag.
+   * - Error isolation: errors in one update do not corrupt the queue — the
+   *   Serializer's mutex is always released in its own `finally` block.
+   */
+  private updateSerializer;
+  /**
+   * Latch that opens once the store is fully initialised (persistence loaded).
+   *
+   * Replaces the poll-only `isReady(): boolean` pattern. Callers can now
+   * `await store.ready()` with an optional timeout rather than polling or
+   * subscribing to an internal event. `isReady()` is preserved as `latch.isOpen()`
+   * for synchronous checks and backwards compatibility.
+   */
+  private readyLatch;
+  private disposeOnce;
+  private updateBus;
+  private eventBus;
+  private executionState;
+  private instanceID;
+  private merge;
+  private diff;
+  private logger;
+  /**
+   * Creates a new ReactiveDataStore instance.
+   */
+  constructor(initialData: T, persistence?: SimplePersistence<T>, deleteMarker?: symbol, options?: {
+    persistenceMaxRetries?: number;
+    persistenceRetryDelay?: number;
+    broadcastChannel?: string;
+    logger?: StoreLogger;
+  });
+  /**
+   * Returns true if the store has finished initialising (persistence loaded).
+   * For async flows, prefer `await store.ready()` over polling this.
+   */
+  isReady(): boolean;
+  /**
+   * Returns a promise that resolves once the store is fully initialised.
+   * Safe to call multiple times — all callers share the same latch.
+   *
+   * @param timeout - Optional maximum wait time in milliseconds.
+   * @throws {TimeoutError} If the store does not become ready within the timeout.
+   *
+   * @example
+   * await store.ready();
+   * const state = store.get();
+   */
+  ready(timeout?: number): Promise<void>;
+  state(): Readonly<StoreExecutionState<T>>;
+  /**
+   * Gets the current state. Optimized default to return reference (false) for performance.
+   * @param clone If `true`, returns a deep clone (use sparingly).
+   * @returns The current state object.
+   */
+  get(clone?: boolean): T;
+  subset<K extends Record<string, any>>(paths: Array<string>, separator?: string): K;
+  select<S>(selector: (state: T) => S): ReactiveSelector<S>;
+  register<R extends any[]>(action: {
+    name: string;
+    fn: (state: T, ...args: R) => DeepPartial<T> | Promise<DeepPartial<T>>;
+    debounce?: {
+      delay: number;
+      condition?: (previous: R | undefined, current: R) => boolean;
+    };
+  }): () => void;
+  dispatch<R extends any[]>(name: string, ...params: R): Promise<T>;
+  /**
+   * Enqueues a state update for serial execution.
+   *
+   * Uses a `Serializer` internally, which guarantees:
+   * - FIFO ordering of all updates.
+   * - No concurrent execution — each update waits for the previous to complete.
+   * - Backpressure: throws if the queue exceeds capacity.
+   * - Clean rejection after `dispose()`.
+   *
+   * @returns A Promise that resolves with the new state T.
+   */
+  set(update: StateUpdater<T>, options?: {
+    force?: boolean;
+    actionId?: string;
+  }): Promise<T>;
+  /**
+   * Internal logic for performing a single, sequential state update.
+   * Always called inside the Serializer — never call directly.
+   */
+  private _performUpdate;
+  /**
+   * Opens the readyLatch once the persistence layer signals it is ready.
+   * The latch can only open once — subsequent `persistence:ready` events are no-ops.
+   */
+  private setupReadyLatch;
+  private setupPersistenceListener;
+  watch(path: string | Array<string>, callback: (state: T) => void, options?: SubscribeOptions): () => void;
+  /**
+   * Subscribes to execution‑status changes of a registered action.
+   *
+   * The provided callback is called **every time** the action transitions
+   * between idle and running (i.e. on `action:start`, `action:complete`, or
+   * `action:error` for the given name). The current status can also be read
+   * synchronously with `isActionRunning(name)`.
+   *
+   * **Deferred listener teardown**
+   * To avoid unnecessary churn when subscriptions are rapidly created and
+   * destroyed, the underlying event listeners are not removed immediately
+   * on unsubscribe. Instead, a *pending reset* is queued via `queueMicrotask`.
+   * If a new subscription for the same action arrives before that microtask
+   * executes, the reset is silently cancelled and the already‑established
+   * listeners are reused. This keeps the subscription infrastructure stable
+   * and prevents cascading notifications that could otherwise arise from
+   * repeated subscribe‑unsubscribe‑subscribe cycles.
+   *
+   * @param name - The name of the action to watch.
+   * @returns ActionWatcher
+   */
+  watchAction(name: string): {
+    name: string;
+    status: () => boolean;
+    subscribe: (_: () => void) => () => void;
+  };
+  /**
+   * Creates a debounced version of `set()` using a `Debouncer`.
+   *
+   * Useful for high-frequency write sources (e.g. text input, scroll position)
+   * where you want to collapse rapid updates into a single state write after a
+   * quiet period.
+   *
+   * @param delay - Quiet period in milliseconds before the update is applied.
+   * @param leading - If true, also applies the first update immediately.
+   * @returns A debounced setter function with the same signature as `set()`.
+   *
+   * @example
+   * const debouncedSet = store.debouncedSetter({ delay: 200 });
+   * inputEl.addEventListener("input", (e) => {
+   *   debouncedSet((s) => ({ ...s, query: e.target.value }));
+   * });
+   */
+  debouncedSetter(options: {
+    delay: number;
+    leading?: boolean;
+  }): (update: StateUpdater<T>, setOptions?: {
+    force?: boolean;
+    actionId?: string;
+  }) => void;
+  id(): string;
+  transaction<R>(operation: () => R | Promise<R>, options?: TransactionOptions): Promise<R>;
+  use(props: MiddlewareConfig<T>): () => boolean;
+  metrics(): StoreMetrics;
+  on(event: StoreEvent, listener: (data: any) => void): () => void;
+  getPersistenceStatus(): {
+    queueSize: number;
+    isProcessing: boolean;
+    pendingRetries: number;
+    oldestTask?: number;
+  };
+  flush(): Promise<void>;
+  /**
+   * Discards all pending persistence tasks.
+   * WARNING: Any queued writes not yet persisted will be lost.
+   * Call flushPersistence() first if writes must not be lost.
+   */
+  discardPersistenceQueue(): void;
+  /**
+   * Disposes the store and all owned resources.
+   *
+   * Closes the update Serializer — any `set()` calls after dispose() will
+   * reject immediately with `SerializerExecutionDone` rather than silently
+   * enqueuing work against a dead store.
+   */
+  dispose(): Promise<void>;
+  private checkDisposed;
+  disposed(): boolean;
+  private emit;
+}
+//#endregion
+//#region src/store/registry.d.ts
+/**
+ * Configuration options for the StoreRegistry.
+ */
+interface StoreRegistryOptions {
+  /**
+   * Optional callback fired when a store is actively garbage collected.
+   * Highly recommended for production telemetry and memory leak debugging.
+   */
+  onEvict?: (storeId: string) => void;
+  /** Optional logger instance. Defaults to no-op. */
+  logger?: StoreLogger;
+}
+/**
+ * A memory-safe, single-flight registry for ReactiveDataStores.
+ * Uses WeakRefs and FinalizationRegistry to allow stores to be garbage collected
+ * when no longer in use, automatically cleaning up internal references.
+ */
+declare class StoreRegistry<S extends object> {
+  private readonly stores;
+  private readonly storeToOnce;
+  private readonly finalizer;
+  private readonly onEvict?;
+  private readonly logger;
+  constructor(options?: StoreRegistryOptions);
+  /**
+   * Get an existing store for storeId, or create a new one via an always-cached Once primitive.
+   * Ensures only one instantiation occurs even under concurrent calls.
+   * * @param storeId - Unique identifier for the store.
+   * @param initialState - The initial state to seed the store if it is created.
+   * @param timeout - Optional timeout (ms) for store initialization.
+   */
+  get(storeId: string, options?: ReactiveDataStoreOptions<S>): Promise<ReactiveDataStore<S>>;
+  getSync(storeId: string, options?: ReactiveDataStoreOptions<S>): ReactiveDataStore<S>;
+  /**
+   * Manually remove a store registry entry, unregistering its finalizer and disposing it.
+   * @param storeId - Unique identifier for the store.
+   * @returns True if a store was actively removed, false otherwise.
+   */
+  release(storeId: string): Promise<boolean>;
+  /**
+   * Clears all stores from the registry, disposes them, and unregisters all finalizers.
+   */
+  clear(): Promise<void>;
+  /**
+   * Get the store if it exists and has successfully finished initialization.
+   * Does not trigger initialization if the store is missing or pending.
+   */
+  has(storeId: string): boolean;
+  /**
+   * Returns the current number of tracked stores.
+   * Note: This includes entries that may have lost external references but haven't been GC'd yet.
+   */
+  get size(): number;
+}
+//#endregion
+//#region src/store/observer.d.ts
+/**
+ * @interface DebugEvent
+ * @description Interface for the structure of a recorded debug event.
+ */
+interface DebugEvent {
+  /** The type of store event (e.g., 'update:start', 'action:complete'). */
+  type: string;
+  /** The timestamp when the event occurred. */
+  timestamp: number;
+  /** The raw data payload associated with the event, including actionId where applicable. */
+  data: any;
+}
+/**
+ * @interface Snapshot
+ * @description Represents a rich snapshot of the state at a point in time for history tracking.
+ */
+interface Snapshot<T> {
+  /** The complete state object at the time of the snapshot. */
+  state: T;
+  /** The timestamp of the state change. */
+  timestamp: number;
+  /** The list of changes (deltas) that resulted in this state. */
+  deltas: StateDelta[];
+}
+/**
+ * @interface ObserverSessionData
+ * @description Defines the data structure for a saved observer session.
+ */
+interface ObserverSessionData<T extends object> {
+  /** The chronological history of debug events. */
+  eventHistory: DebugEvent[];
+  /** The chronological history of state snapshots. */
+  stateHistory: Snapshot<T>[];
+}
+/**
+ * @interface ObserverOptions
+ * @description Configuration options for the observer module.
+ */
+interface ObserverOptions {
+  /** Maximum number of events to retain in memory. Defaults to 500. */
+  maxEvents?: number;
+  /** Enables or disables console logging for all events (overridden by 'silent'). Defaults to false. */
+  enableConsoleLogging?: boolean;
+  /** Maximum number of state snapshots to retain for time-travel. Defaults to 20. */
+  maxStateHistory?: number;
+  /** Fine-grained control over which event types are logged to the console. */
+  logEvents?: {
+    updates?: boolean;
+    middleware?: boolean;
+    transactions?: boolean;
+    actions?: boolean;
+    selectors?: boolean;
+  };
+  /** Performance thresholds for triggering console warnings. Values are in milliseconds (ms). */
+  performanceThresholds?: {
+    updateTime?: number;
+    middlewareTime?: number;
+  };
+  /** If true, suppresses all console output and logging regardless of other options. Defaults to false. */
+  silent?: boolean;
+  /** Optional logger instance. Defaults to no-op. */
+  logger?: StoreLogger;
+}
+/**
+ * @class StoreObserver
+ * @description Connects to a DataStore to capture state changes, events, and performance data.
+ * @template T The type of the store's state object.
+ */
+declare class StoreObserver<T extends object> {
+  protected store: DataStore<T>;
+  private eventHistory;
+  private stateHistory;
+  private unsubscribers;
+  private isTimeTraveling;
+  private devTools;
+  private middlewareExecutions;
+  private activeTransactionCount;
+  private activeBatches;
+  private maxEvents;
+  private maxStateHistory;
+  private enableConsoleLogging;
+  private isSilent;
+  private logEvents;
+  private performanceThresholds;
+  private logger;
+  /**
+   * @param store The DataStore instance to observe.
+   * @param options Configuration options for the observer.
+   */
+  constructor(store: DataStore<T>, options?: ObserverOptions);
+  /**
+   * @private
+   * Centralized logging method. Routes to the structured logger for level-based calls
+   * (log, warn, error, debug) and to raw console for group/table calls which have no
+   * logger equivalent. Respects the `isSilent` flag.
+   * @param method The console method to call ('log', 'warn', 'error', 'group', 'groupEnd', 'table', 'debug').
+   * @param args Arguments to pass to the console/log method.
+   */
+  private _consoleLog;
+  /**
+   * @private
+   * Sets up listeners for all relevant store events.
+   */
+  private setupEventListeners;
+  /**
+   * @private
+   * Records a new state snapshot and manages the state history limit.
+   * @param deltas The state changes that led to this snapshot.
+   */
+  private recordStateSnapshot;
+  /**
+   * @private
+   * Records a debug event and manages the event history limit.
+   * @param type The type of event.
+   * @param data The data payload of the event.
+   */
+  private recordEvent;
+  /**
+   * Returns a cloned copy of the recorded event history.
+   * @returns Array of debug events.
+   */
+  getEventHistory(): DebugEvent[];
+  /**
+   * Returns a cloned copy of the recorded state history (snapshots).
+   * @returns Array of state snapshots.
+   */
+  getStateHistory(): Snapshot<T>[];
+  /**
+   * Returns middleware execution history from the state.
+   * @returns Array of middleware executions.
+   */
+  getMiddlewareExecutions(): MiddlewareExecution[];
+  /**
+   * Returns current transaction status.
+   * @returns Object with transaction status information.
+   */
+  getTransactionStatus(): {
+    activeTransactions: number;
+    activeBatches: string[];
+  };
+  /**
+   * Creates a standard middleware that logs all updates.
+   * @param options Options for the logging middleware.
+   * @returns A middleware function.
+   */
+  createLoggingMiddleware(options?: {
+    logLevel?: "debug" | "info" | "warn";
+    logUpdates?: boolean;
+  }): (state: T, update: DeepPartial<T>) => DeepPartial<T>;
+  /**
+   * Creates a middleware that validates updates against a schema.
+   * Uses the internal `_consoleLog` for warnings.
+   * @param validator Function that validates updates.
+   * @returns A blocking middleware function.
+   */
+  createValidationMiddleware(validator: (state: T, update: DeepPartial<T>) => boolean | {
+    valid: boolean;
+    reason?: string;
+  }): (state: T, update: DeepPartial<T>) => boolean;
+  /**
+   * Returns a simplified view of recent state changes.
+   * @param limit Maximum number of state changes to compare. Defaults to 5.
+   * @returns Array of state difference objects.
+   */
+  getRecentChanges(limit?: number): Array<{
+    timestamp: number;
+    changedPaths: string[];
+    from: Partial<T>;
+    to: Partial<T>;
+  }>;
+  /**
+   * Clears both the event and state history, preserving only the initial state snapshot.
+   */
+  clearHistory(): void;
+  /**
+   * Filters and returns events related to a specific action ID.
+   * @param actionId The ID of the action to filter by.
+   * @returns Array of debug events associated with the action.
+   */
+  getHistoryForAction(actionId: string): DebugEvent[];
+  /**
+   * Attempts to replay a state update from history using the recorded update payload.
+   * @param eventIndex The index of the replayable event (an "update:start" event) in the history array.
+   */
+  replay(eventIndex: number): Promise<void>;
+  /**
+   * Creates a time-travel utility object with undo/redo capabilities.
+   * @returns An object with methods for time-travel navigation.
+   */
+  createTimeTravel(): {
+    canUndo: () => boolean;
+    canRedo: () => boolean;
+    undo: () => Promise<void>;
+    redo: () => Promise<void>;
+    length: () => number;
+    clear: () => void;
+  };
+  /**
+   * Saves the current observer session (events and state history) using a persistence mechanism.
+   * @param persistence An object implementing the SimplePersistence interface.
+   * @returns A promise that resolves to true if the session was saved successfully.
+   */
+  saveSession(persistence: SimplePersistence<ObserverSessionData<T>>): Promise<boolean>;
+  /**
+   * Loads a previously saved observer session and restores the state to the latest saved snapshot.
+   * @param persistence An object implementing the SimplePersistence interface.
+   * @returns A promise that resolves to true if a session was loaded.
+   */
+  loadSession(persistence: SimplePersistence<ObserverSessionData<T>>): Promise<boolean>;
+  /**
+   * Exports the current session data as a JSON file, initiating a browser download.
+   */
+  exportSession(): void;
+  /**
+   * Imports a session from a JSON file, restoring event history and state.
+   * @param file The file object (e.g., from an <input type="file"> event) to import.
+   * @returns A promise that resolves when the import is complete.
+   */
+  importSession(file: File): Promise<void>;
+  /**
+   * Cleans up the observer by unsubscribing all event listeners and clearing history.
+   */
+  disconnect(): void;
+  /**
+   * @private
+   * Logs an event to the console with appropriate formatting.
+   * Uses `this._consoleLog` for all output.
+   * @param type Event type.
+   * @param data Event data.
+   */
+  private _log;
+  /**
+   * @private
+   * Checks for performance issues in the events.
+   * Uses `this._consoleLog` for all output.
+   * @param type Event type.
+   * @param data Event data.
+   */
+  private _checkPerformance;
+}
+//#endregion
+//#region src/store/diff.d.ts
+/**
+ * Creates a diff function with configurable options.
+ *
+ * @param {object} options - Configuration options for the diff function.
+ * @param {symbol} [options.deleteMarker] - A custom symbol to mark properties for deletion.
+ */
+declare function createDiff(options?: {
+  deleteMarker?: symbol;
+}): any;
+/**
+ * Creates a derivePaths function with configurable options.
+ *
+ * @param {object} options - Configuration options for the derivePaths function.
+ * @param {symbol} [options.deleteMarker=Symbol.for("delete")] - A custom symbol to mark properties for deletion.
+ */
+declare function createDerivePaths(options?: {
+  deleteMarker?: symbol;
+}): <T>(changes: DeepPartial<T>) => string[];
+/**
+ * @deprecated Use `createDiff()` instead.
+ * Provided for backward compatibility with `Symbol.for("delete")` as the default delete marker.
+ */
+declare const diff: any;
+type DiffFunction = ReturnType<typeof createDiff>;
+/**
+ * @deprecated Use `createDerivePaths()` instead.
+ * Provided for backward compatibility with `Symbol.for("delete")` as the default delete marker.
+ */
+declare const derivePaths: <T>(changes: DeepPartial<T>) => string[];
+//#endregion
+//#region src/store/merge.d.ts
+/**
+ * Creates a shallow clone of an object or array.
+ */
+declare const shallowClone: (obj: any) => any;
+/**
+ * Creates a deep merge function with configurable options.
+ *
+ * @param {object} options - Configuration options for the merge function.
+ * @param {symbol} [options.deleteMarker=Symbol.for("delete")] - A custom symbol to mark properties for deletion during merge.
+ */
+declare function createMerge(options?: {
+  deleteMarker?: symbol;
+}): <T extends object>(original: T, changes: DeepPartial<T> | symbol) => T;
+/**
+ * @deprecated Use `createMerge()` instead.
+ * Provided for backward compatibility with `Symbol.for("delete")` as the default delete marker.
+ */
+declare const merge: <T extends object>(original: T, changes: DeepPartial<T> | symbol) => T;
+type MergeFunction = ReturnType<typeof createMerge>;
+//#endregion
+//#region src/store/actions.d.ts
+declare class ActionCancelledError extends Error {
+  constructor();
+}
+declare class UnknownActionError extends Error {
+  constructor({
+    action
+  }: {
+    action: string;
+  });
+}
+declare class ActionManager<T extends object> {
+  private eventBus;
+  private set;
+  private registrations;
+  constructor(eventBus: EventBus<Record<StoreEvent, any>>, set: (update: StateUpdater<T>, options?: {
+    force?: boolean;
+    actionId?: string;
+  }) => Promise<any>);
+  register<R extends any[]>(action: {
+    name: string;
+    fn: (state: T, ...args: R) => DeepPartial<T> | Promise<DeepPartial<T>>;
+    debounce?: {
+      delay: number;
+      condition?: (previous: R | undefined, current: R) => boolean;
+    };
+  }): () => void;
+  dispatch<R extends any[]>(name: string, ...params: R): Promise<T>;
+  private executeAction;
+  running(name: string): boolean;
+  private subscribe;
+  watch(name: string): {
+    name: string;
+    status: () => boolean;
+    subscribe: (_: () => void) => () => void;
+  };
+  private notifyStatusListeners;
+  private emit;
+  dispose(): void;
+}
+//#endregion
+export { ActionCancelledError, ActionCompletePayload, ActionErrorPayload, ActionManager, ActionStartPayload, ActionWatcher, BlockingMiddleware, DELETE_SYMBOL, DataStore, DeepPartial, DiffFunction, MergeFunction, Middleware, MiddlewareConfig, MiddlewareExecution, type ObserverOptions, PersistenceFailedPayload, PersistenceInitErrorPayload, PersistenceQueueClearedPayload, PersistenceQueuedPayload, PersistenceRetryPayload, PersistenceSuccessPayload, ReactiveDataStore, ReactiveDataStoreOptions, ReactiveSelector, SelectorAccessedPayload, SelectorChangedPayload, StateDelta, StateUpdater, StoreAction, StoreEvent, StoreEvents, StoreExecutionState, StoreLogger, StoreMetrics, StoreObserver, StoreRegistry, StoreRegistryOptions, type SubscribeOptions, TransactionOptions, TransformMiddleware, UnknownActionError, createDerivePaths, createDiff, createMerge, createStoreLogger, derivePaths, diff, merge, shallowClone };