diff --git a/.changeset/paced-mutations.md b/.changeset/paced-mutations.md
new file mode 100644
index 000000000..6329c2963
--- /dev/null
+++ b/.changeset/paced-mutations.md
@@ -0,0 +1,49 @@
+---
+"@tanstack/db": patch
+"@tanstack/react-db": patch
+---
+
+Add paced mutations with pluggable timing strategies
+
+Introduces a new paced mutations system that enables optimistic mutations with pluggable timing strategies. This provides fine-grained control over when and how mutations are persisted to the backend. Powered by [TanStack Pacer](https://github.com/TanStack/pacer).
+
+**Key Design:**
+
+- **Debounce/Throttle**: Only one pending transaction (collecting mutations) and one persisting transaction (writing to backend) at a time. Multiple rapid mutations automatically merge together.
+- **Queue**: Each mutation creates a separate transaction, guaranteed to run in the order they're made (FIFO by default, configurable to LIFO).
+
+**Core Features:**
+
+- **Pluggable Strategy System**: Choose from debounce, queue, or throttle strategies to control mutation timing
+- **Auto-merging Mutations**: Multiple rapid mutations on the same item automatically merge for efficiency (debounce/throttle only)
+- **Transaction Management**: Full transaction lifecycle tracking (pending → persisting → completed/failed)
+- **React Hook**: `usePacedMutations` for easy integration in React applications
+
+**Available Strategies:**
+
+- `debounceStrategy`: Wait for inactivity before persisting. Only final state is saved. (ideal for auto-save, search-as-you-type)
+- `queueStrategy`: Each mutation becomes a separate transaction, processed sequentially in order (defaults to FIFO, configurable to LIFO). All mutations are guaranteed to persist. (ideal for sequential workflows, rate-limited APIs)
+- `throttleStrategy`: Ensure minimum spacing between executions. Mutations between executions are merged. (ideal for analytics, progress updates)
+
+**Example Usage:**
+
+```ts
+import { usePacedMutations, debounceStrategy } from "@tanstack/react-db"
+
+const mutate = usePacedMutations({
+  mutationFn: async ({ transaction }) => {
+    await api.save(transaction.mutations)
+  },
+  strategy: debounceStrategy({ wait: 500 }),
+})
+
+// Trigger a mutation
+const tx = mutate(() => {
+  collection.update(id, (draft) => {
+    draft.value = newValue
+  })
+})
+
+// Optionally await persistence
+await tx.isPersisted.promise
+```
diff --git a/SERIALIZED_TRANSACTION_PLAN.md b/SERIALIZED_TRANSACTION_PLAN.md
new file mode 100644
index 000000000..1736c2afd
--- /dev/null
+++ b/SERIALIZED_TRANSACTION_PLAN.md
@@ -0,0 +1,365 @@
+# Implementation Plan for `useSerializedTransaction` with TanStack Pacer
+
+Based on [GitHub issue #35](https://github.com/TanStack/db/issues/35), using @tanstack/pacer for strategy implementation across all 5 framework integrations.
+
+## Overview
+
+Create a framework-agnostic core in `@tanstack/db` that manages optimistic transactions with pluggable queuing strategies powered by TanStack Pacer. Each framework package wraps the core with framework-specific reactive primitives.
+
+## Architecture Pattern
+
+The core transaction logic stays in one place (`@tanstack/db`) while each framework provides its own wrapper using framework-specific reactive primitives.
+
+```typescript
+// Core in @tanstack/db (framework-agnostic)
+createSerializedTransaction(config) // Returns { mutate, cleanup }
+
+// React wrapper
+useSerializedTransaction(config) // Uses React hooks, returns mutate function
+
+// Solid wrapper
+useSerializedTransaction(config) // Uses Solid signals, matches useLiveQuery pattern
+
+// Svelte/Vue wrappers
+useSerializedTransaction(config) // Framework-specific implementations
+
+// Angular wrapper
+injectSerializedTransaction(config) // Uses Angular DI, follows injectLiveQuery pattern
+```
+
+## Available Strategies (Based on Pacer Utilities)
+
+### 1. **debounceStrategy({ wait, leading?, trailing? })**
+
+- Uses Pacer's `Debouncer` class
+- Waits for pause in activity before committing
+- **Best for:** Search inputs, auto-save fields
+
+### 2. **queueStrategy({ wait?, maxSize?, addItemsTo?, getItemsFrom? })**
+
+- Uses Pacer's `Queuer` class
+- Processes all transactions in order (FIFO/LIFO)
+- FIFO: `{ addItemsTo: 'back', getItemsFrom: 'front' }`
+- LIFO: `{ addItemsTo: 'back', getItemsFrom: 'back' }`
+- **Best for:** Sequential operations that must all complete
+
+### 3. **throttleStrategy({ wait, leading?, trailing? })**
+
+- Uses Pacer's `Throttler` class
+- Evenly spaces transaction executions over time
+- **Best for:** Sliders, scroll handlers, progress bars
+
+### 4. **batchStrategy({ maxSize?, wait?, getShouldExecute? })**
+
+- Uses Pacer's `Batcher` class
+- Groups multiple mutations into batches
+- Triggers on size or time threshold
+- **Best for:** Bulk operations, reducing network calls
+
+## File Structure
+
+```
+packages/db/src/
+  ├── serialized-transaction.ts         # Core framework-agnostic logic
+  └── strategies/
+      ├── index.ts                      # Export all strategies
+      ├── debounceStrategy.ts           # Wraps Pacer Debouncer
+      ├── queueStrategy.ts              # Wraps Pacer Queuer
+      ├── throttleStrategy.ts           # Wraps Pacer Throttler
+      ├── batchStrategy.ts              # Wraps Pacer Batcher
+      └── types.ts                      # Strategy type definitions
+
+packages/db/package.json                # Add @tanstack/pacer dependency
+
+packages/react-db/src/
+  └── useSerializedTransaction.ts       # React hook wrapper
+
+packages/solid-db/src/
+  └── useSerializedTransaction.ts       # Solid wrapper (matches useLiveQuery pattern)
+
+packages/svelte-db/src/
+  └── useSerializedTransaction.svelte.ts # Svelte wrapper
+
+packages/vue-db/src/
+  └── useSerializedTransaction.ts       # Vue wrapper
+
+packages/angular-db/src/
+  └── injectSerializedTransaction.ts    # Angular wrapper (DI pattern)
+
+packages/*/tests/
+  └── serialized-transaction.test.ts    # Tests per package
+```
+
+## Core API Design
+
+```typescript
+// Framework-agnostic core (packages/db)
+import { debounceStrategy } from '@tanstack/db'
+
+const { mutate, cleanup } = createSerializedTransaction({
+  mutationFn: async ({ transaction }) => {
+    await api.save(transaction.mutations)
+  },
+  strategy: debounceStrategy({ wait: 500 }),
+  metadata?: Record<string, unknown>,
+})
+
+// mutate() executes mutations according to strategy and returns Transaction
+const transaction = mutate(() => {
+  collection.update(id, draft => { draft.value = newValue })
+})
+
+// Await persistence and handle errors
+try {
+  await transaction.isPersisted.promise
+  console.log('Transaction committed successfully')
+} catch (error) {
+  console.error('Transaction failed:', error)
+}
+
+// cleanup() when done (frameworks handle this automatically)
+cleanup()
+```
+
+## React Hook Wrapper
+
+```typescript
+// packages/react-db
+import { debounceStrategy } from "@tanstack/react-db"
+
+const mutate = useSerializedTransaction({
+  mutationFn: async ({ transaction }) => {
+    await api.save(transaction.mutations)
+  },
+  strategy: debounceStrategy({ wait: 1000 }),
+})
+
+// Usage in component
+const handleChange = async (value) => {
+  const tx = mutate(() => {
+    collection.update(id, (draft) => {
+      draft.value = value
+    })
+  })
+
+  // Optional: await persistence or handle errors
+  try {
+    await tx.isPersisted.promise
+  } catch (error) {
+    console.error("Update failed:", error)
+  }
+}
+```
+
+## Example: Slider with Different Strategies
+
+```typescript
+// Debounce - wait for user to stop moving slider
+const mutate = useSerializedTransaction({
+  mutationFn: async ({ transaction }) => {
+    await api.updateVolume(transaction.mutations)
+  },
+  strategy: debounceStrategy({ wait: 500 }),
+})
+
+// Throttle - update every 200ms while sliding
+const mutate = useSerializedTransaction({
+  mutationFn: async ({ transaction }) => {
+    await api.updateVolume(transaction.mutations)
+  },
+  strategy: throttleStrategy({ wait: 200 }),
+})
+
+// Debounce with leading/trailing - save first + final value only
+const mutate = useSerializedTransaction({
+  mutationFn: async ({ transaction }) => {
+    await api.updateVolume(transaction.mutations)
+  },
+  strategy: debounceStrategy({ wait: 0, leading: true, trailing: true }),
+})
+
+// Queue - save every change in order (FIFO)
+const mutate = useSerializedTransaction({
+  mutationFn: async ({ transaction }) => {
+    await api.updateVolume(transaction.mutations)
+  },
+  strategy: queueStrategy({
+    wait: 200,
+    addItemsTo: "back",
+    getItemsFrom: "front",
+  }),
+})
+```
+
+## Implementation Steps
+
+### Phase 1: Core Package (@tanstack/db)
+
+1. Add `@tanstack/pacer` dependency to packages/db/package.json
+2. Create strategy type definitions in strategies/types.ts
+3. Implement strategy factories:
+   - `debounceStrategy.ts` - wraps Pacer Debouncer
+   - `queueStrategy.ts` - wraps Pacer Queuer
+   - `throttleStrategy.ts` - wraps Pacer Throttler
+   - `batchStrategy.ts` - wraps Pacer Batcher
+4. Create core `createSerializedTransaction()` function
+5. Export strategies + core function from packages/db/src/index.ts
+
+### Phase 2: Framework Wrappers
+
+6. **React** - Create `useSerializedTransaction` using useRef/useEffect/useCallback
+7. **Solid** - Create `useSerializedTransaction` using createSignal/onCleanup (matches `useLiveQuery` pattern)
+8. **Svelte** - Create `useSerializedTransaction` using Svelte stores
+9. **Vue** - Create `useSerializedTransaction` using ref/onUnmounted
+10. **Angular** - Create `injectSerializedTransaction` using inject/DestroyRef (matches `injectLiveQuery` pattern)
+
+### Phase 3: Testing & Documentation
+
+11. Write tests for core logic in packages/db
+12. Write tests for each framework wrapper
+13. Update README with examples
+14. Add TypeScript examples to docs
+
+## Strategy Type System
+
+```typescript
+export type Strategy =
+  | DebounceStrategy
+  | QueueStrategy
+  | ThrottleStrategy
+  | BatchStrategy
+
+interface BaseStrategy<TName extends string = string> {
+  _type: TName // Discriminator for type narrowing
+  execute: (fn: () => void) => void | Promise<void>
+  cleanup: () => void
+}
+
+export function debounceStrategy(opts: {
+  wait: number
+  leading?: boolean
+  trailing?: boolean
+}): DebounceStrategy
+
+export function queueStrategy(opts?: {
+  wait?: number
+  maxSize?: number
+  addItemsTo?: "front" | "back"
+  getItemsFrom?: "front" | "back"
+}): QueueStrategy
+
+export function throttleStrategy(opts: {
+  wait: number
+  leading?: boolean
+  trailing?: boolean
+}): ThrottleStrategy
+
+export function batchStrategy(opts?: {
+  maxSize?: number
+  wait?: number
+  getShouldExecute?: (items: any[]) => boolean
+}): BatchStrategy
+```
+
+## Technical Implementation Details
+
+### Core createSerializedTransaction
+
+The core function will:
+
+1. Accept a strategy and mutationFn
+2. Create a wrapper around `createTransaction` from existing code
+3. Use the strategy's `execute()` method to control when transactions are committed
+4. Return `{ mutate, cleanup }` where:
+   - `mutate(callback): Transaction` - executes mutations according to strategy and returns the Transaction object
+   - `cleanup()` - cleans up strategy resources
+
+**Important:** The `mutate()` function returns a `Transaction` object so callers can:
+
+- Await `transaction.isPersisted.promise` to know when persistence completes
+- Handle errors via try/catch or `.catch()`
+- Access transaction state and metadata
+
+### Strategy Factories
+
+Each strategy factory returns an object with:
+
+- `execute(fn)` - wraps the function with Pacer's utility
+- `cleanup()` - cleans up the Pacer instance
+
+Example for debounceStrategy:
+
+```typescript
+// NOTE: Import path needs validation - Pacer may export from main entry point
+// Likely: import { Debouncer } from '@tanstack/pacer' or similar
+import { Debouncer } from "@tanstack/pacer" // TODO: Validate actual export path
+
+export function debounceStrategy(opts: {
+  wait: number
+  leading?: boolean
+  trailing?: boolean
+}) {
+  const debouncer = new Debouncer(opts)
+
+  return {
+    _type: "debounce" as const,
+    execute: (fn: () => void) => {
+      debouncer.execute(fn)
+    },
+    cleanup: () => {
+      debouncer.cancel()
+    },
+  }
+}
+```
+
+### React Hook Implementation
+
+```typescript
+export function useSerializedTransaction(config) {
+  // Include strategy in dependencies to handle strategy changes
+  const { mutate, cleanup } = useMemo(() => {
+    return createSerializedTransaction(config)
+  }, [config.mutationFn, config.metadata, config.strategy])
+
+  // Cleanup on unmount or when dependencies change
+  useEffect(() => {
+    return () => cleanup()
+  }, [cleanup])
+
+  // Use useCallback to provide stable reference
+  const stableMutate = useCallback(mutate, [mutate])
+
+  return stableMutate
+}
+```
+
+**Key fixes:**
+
+- Include `config.strategy` in `useMemo` dependencies to handle strategy changes
+- Properly cleanup when strategy changes (via useEffect cleanup)
+- Return stable callback reference via `useCallback`
+
+## Benefits
+
+- ✅ Leverages battle-tested TanStack Pacer utilities
+- ✅ Reduces backend write contention
+- ✅ Framework-agnostic core promotes consistency
+- ✅ Type-safe, composable API
+- ✅ Aligns with TanStack ecosystem patterns
+- ✅ Supports all 5 framework integrations
+- ✅ Simple, declarative API for users
+- ✅ Easy to add custom strategies
+
+## Open Questions
+
+1. Should we support custom strategies? (i.e., users passing their own strategy objects)
+2. Do we need lifecycle callbacks like `onSuccess`, `onError` for each mutate call?
+3. Should batching strategy automatically merge mutations or keep them separate?
+4. Rate limiting strategy - useful or skip for now?
+
+## Notes
+
+- ❌ Dropped merge strategy for now (more complex to design, less clear use case)
+- The pattern follows existing TanStack patterns where core is framework-agnostic
+- Similar to how `useLiveQuery` wraps core query logic per framework
diff --git a/docs/guides/mutations.md b/docs/guides/mutations.md
index 24e8aba92..f81fea8e6 100644
--- a/docs/guides/mutations.md
+++ b/docs/guides/mutations.md
@@ -100,6 +100,7 @@ The benefits:
 - [Operation Handlers](#operation-handlers)
 - [Creating Custom Actions](#creating-custom-actions)
 - [Manual Transactions](#manual-transactions)
+- [Paced Mutations](#paced-mutations)
 - [Mutation Merging](#mutation-merging)
 - [Controlling Optimistic Behavior](#controlling-optimistic-behavior)
 - [Transaction States](#transaction-states)
@@ -892,6 +893,238 @@ tx.isPersisted.promise.then(() => {
 console.log(tx.state) // 'pending', 'persisting', 'completed', or 'failed'
 ```
 
+## Paced Mutations
+
+Paced mutations provide fine-grained control over **when and how** mutations are persisted to your backend. Instead of persisting every mutation immediately, you can use timing strategies to batch, delay, or queue mutations based on your application's needs.
+
+Powered by [TanStack Pacer](https://github.com/TanStack/pacer), paced mutations are ideal for scenarios like:
+- **Auto-save forms** that wait for the user to stop typing
+- **Slider controls** that need smooth updates without overwhelming the backend
+- **Sequential workflows** where order matters and every mutation must persist
+
+### Key Design
+
+The fundamental difference between strategies is how they handle transactions:
+
+**Debounce/Throttle**: Only one pending transaction (collecting mutations) and one persisting transaction (writing to backend) at a time. Multiple rapid mutations automatically merge together into a single transaction.
+
+**Queue**: Each mutation creates a separate transaction, guaranteed to run in the order they're made (FIFO by default, configurable to LIFO). All mutations are guaranteed to persist.
+
+### Available Strategies
+
+| Strategy | Behavior | Best For |
+|----------|----------|----------|
+| **`debounceStrategy`** | Wait for inactivity before persisting. Only final state is saved. | Auto-save forms, search-as-you-type |
+| **`throttleStrategy`** | Ensure minimum spacing between executions. Mutations between executions are merged. | Sliders, progress updates, analytics |
+| **`queueStrategy`** | Each mutation becomes a separate transaction, processed sequentially in order (FIFO by default, configurable to LIFO). All mutations guaranteed to persist. | Sequential workflows, file uploads, rate-limited APIs |
+
+### Debounce Strategy
+
+The debounce strategy waits for a period of inactivity before persisting. This is perfect for auto-save scenarios where you want to wait until the user stops typing before saving their work.
+
+```tsx
+import { usePacedMutations, debounceStrategy } from "@tanstack/react-db"
+
+function AutoSaveForm() {
+  const mutate = usePacedMutations({
+    mutationFn: async ({ transaction }) => {
+      // Persist the final merged state to the backend
+      await api.forms.save(transaction.mutations)
+    },
+    // Wait 500ms after the last change before persisting
+    strategy: debounceStrategy({ wait: 500 }),
+  })
+
+  const handleChange = (field: string, value: string) => {
+    // Multiple rapid changes merge into a single transaction
+    mutate(() => {
+      formCollection.update(formId, (draft) => {
+        draft[field] = value
+      })
+    })
+  }
+
+  return (
+    <form>
+      <input onChange={(e) => handleChange('title', e.target.value)} />
+      <textarea onChange={(e) => handleChange('content', e.target.value)} />
+    </form>
+  )
+}
+```
+
+**Key characteristics**:
+- Timer resets on each mutation
+- Only the final merged state persists
+- Reduces backend writes significantly for rapid changes
+
+### Throttle Strategy
+
+The throttle strategy ensures a minimum spacing between executions. This is ideal for scenarios like sliders or progress updates where you want smooth, consistent updates without overwhelming your backend.
+
+```tsx
+import { usePacedMutations, throttleStrategy } from "@tanstack/react-db"
+
+function VolumeSlider() {
+  const mutate = usePacedMutations({
+    mutationFn: async ({ transaction }) => {
+      await api.settings.updateVolume(transaction.mutations)
+    },
+    // Persist at most once every 200ms
+    strategy: throttleStrategy({
+      wait: 200,
+      leading: true,   // Execute immediately on first call
+      trailing: true,  // Execute after wait period if there were mutations
+    }),
+  })
+
+  const handleVolumeChange = (volume: number) => {
+    mutate(() => {
+      settingsCollection.update('volume', (draft) => {
+        draft.value = volume
+      })
+    })
+  }
+
+  return (
+    <input
+      type="range"
+      min={0}
+      max={100}
+      onChange={(e) => handleVolumeChange(Number(e.target.value))}
+    />
+  )
+}
+```
+
+**Key characteristics**:
+- Guarantees minimum spacing between persists
+- Can execute on leading edge, trailing edge, or both
+- Mutations between executions are merged
+
+### Queue Strategy
+
+The queue strategy creates a separate transaction for each mutation and processes them sequentially in order. Unlike debounce/throttle, **every mutation is guaranteed to persist**, making it ideal for workflows where you can't lose any operations.
+
+```tsx
+import { usePacedMutations, queueStrategy } from "@tanstack/react-db"
+
+function FileUploader() {
+  const mutate = usePacedMutations({
+    mutationFn: async ({ transaction }) => {
+      // Each file upload is its own transaction
+      const mutation = transaction.mutations[0]
+      await api.files.upload(mutation.modified)
+    },
+    // Process each upload sequentially with 500ms between them
+    strategy: queueStrategy({
+      wait: 500,
+      addItemsTo: 'back',    // FIFO: add to back of queue
+      getItemsFrom: 'front', // FIFO: process from front of queue
+    }),
+  })
+
+  const handleFileSelect = (files: FileList) => {
+    // Each file creates its own transaction, queued for sequential processing
+    Array.from(files).forEach((file, idx) => {
+      mutate(() => {
+        uploadCollection.insert({
+          id: crypto.randomUUID(),
+          file,
+          status: 'pending',
+        })
+      })
+    })
+  }
+
+  return <input type="file" multiple onChange={(e) => handleFileSelect(e.target.files!)} />
+}
+```
+
+**Key characteristics**:
+- Each mutation becomes its own transaction
+- Processes sequentially in order (FIFO by default)
+- Can configure to LIFO by setting `getItemsFrom: 'back'`
+- All mutations guaranteed to persist
+- Waits for each transaction to complete before starting the next
+
+### Choosing a Strategy
+
+Use this guide to pick the right strategy for your use case:
+
+**Use `debounceStrategy` when:**
+- You want to wait for the user to finish their action
+- Only the final state matters (intermediate states can be discarded)
+- You want to minimize backend writes
+- Examples: auto-save forms, search-as-you-type, settings panels
+
+**Use `throttleStrategy` when:**
+- You want smooth, consistent updates at a controlled rate
+- Some intermediate states should persist, but not all
+- You need updates to feel responsive without overwhelming the backend
+- Examples: volume sliders, progress bars, analytics tracking, live cursor position
+
+**Use `queueStrategy` when:**
+- Every mutation must persist (no operations can be lost)
+- Order of operations matters
+- You're working with a rate-limited API
+- You need sequential processing with delays
+- Examples: file uploads, batch operations, audit trails, multi-step wizards
+
+### Using in React
+
+The `usePacedMutations` hook makes it easy to use paced mutations in React components:
+
+```tsx
+import { usePacedMutations, debounceStrategy } from "@tanstack/react-db"
+
+function MyComponent() {
+  const mutate = usePacedMutations({
+    mutationFn: async ({ transaction }) => {
+      await api.save(transaction.mutations)
+    },
+    strategy: debounceStrategy({ wait: 500 }),
+  })
+
+  // Each mutate call returns a Transaction you can await
+  const handleSave = async () => {
+    const tx = mutate(() => {
+      collection.update(id, (draft) => {
+        draft.value = newValue
+      })
+    })
+
+    // Optionally wait for persistence
+    try {
+      await tx.isPersisted.promise
+      console.log('Saved successfully!')
+    } catch (error) {
+      console.error('Save failed:', error)
+    }
+  }
+
+  return <button onClick={handleSave}>Save</button>
+}
+```
+
+The hook automatically memoizes the strategy and mutation function to prevent unnecessary recreations. You can also use `createPacedMutations` directly outside of React:
+
+```ts
+import { createPacedMutations, queueStrategy } from "@tanstack/db"
+
+const { mutate } = createPacedMutations({
+  mutationFn: async ({ transaction }) => {
+    await api.save(transaction.mutations)
+  },
+  strategy: queueStrategy({ wait: 200 }),
+})
+
+// Use anywhere in your application
+mutate(() => {
+  collection.update(id, updater)
+})
+```
+
 ## Mutation Merging
 
 When multiple mutations operate on the same item within a transaction, TanStack DB intelligently merges them to:
diff --git a/examples/react/paced-mutations-demo/index.html b/examples/react/paced-mutations-demo/index.html
new file mode 100644
index 000000000..c410ccd20
--- /dev/null
+++ b/examples/react/paced-mutations-demo/index.html
@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Paced Mutations Demo</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
diff --git a/examples/react/paced-mutations-demo/package.json b/examples/react/paced-mutations-demo/package.json
new file mode 100644
index 000000000..ec14c651f
--- /dev/null
+++ b/examples/react/paced-mutations-demo/package.json
@@ -0,0 +1,25 @@
+{
+  "name": "@tanstack/db-example-paced-mutations-demo",
+  "version": "0.0.1",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@tanstack/db": "workspace:*",
+    "@tanstack/react-db": "workspace:*",
+    "mitt": "^3.0.1",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.12",
+    "@types/react-dom": "^18.3.1",
+    "@vitejs/plugin-react": "^4.3.4",
+    "typescript": "^5.7.2",
+    "vite": "^6.0.3"
+  }
+}
diff --git a/examples/react/paced-mutations-demo/src/App.tsx b/examples/react/paced-mutations-demo/src/App.tsx
new file mode 100644
index 000000000..57f1ad33c
--- /dev/null
+++ b/examples/react/paced-mutations-demo/src/App.tsx
@@ -0,0 +1,448 @@
+import { useEffect, useMemo, useState } from "react"
+import mitt from "mitt"
+import {
+  createCollection,
+  debounceStrategy,
+  queueStrategy,
+  throttleStrategy,
+  usePacedMutations,
+} from "@tanstack/react-db"
+import type { PendingMutation, Transaction } from "@tanstack/react-db"
+
+interface Item {
+  id: number
+  value: number
+  timestamp: number
+}
+
+// Create event emitter for fake server communication
+const serverEmitter = mitt()
+
+// Fake server store - initialize with a single item
+const fakeServer = new Map<number, Item>([
+  [1, { id: 1, value: 0, timestamp: Date.now() }],
+])
+
+// Create a collection with fake sync
+const itemCollection = createCollection<Item>({
+  id: `items`,
+  getKey: (item) => item.id,
+  startSync: true,
+  sync: {
+    sync: ({ begin, write, commit, markReady }) => {
+      // Initial sync - load the initial item from fake server
+      begin()
+      fakeServer.forEach((item) => {
+        write({
+          type: `insert`,
+          value: item,
+        })
+      })
+      commit()
+      markReady()
+
+      // Listen for server updates and sync them back
+      // @ts-expect-error mitt typing
+      serverEmitter.on(`*`, (_, changes: Array<PendingMutation<Item>>) => {
+        begin()
+        changes.forEach((change) => {
+          if (change.type === `update`) {
+            write({
+              type: change.type,
+              // @ts-expect-error pending mutation type
+              value: change.modified,
+            })
+          } else {
+            write({
+              type: change.type,
+              // @ts-expect-error pending mutation type
+              value: change.changes,
+            })
+          }
+        })
+        commit()
+      })
+    },
+  },
+})
+
+// Track transaction state for visualization
+interface TrackedTransaction {
+  id: string
+  transaction: Transaction
+  state: `pending` | `executing` | `completed` | `failed`
+  mutations: Array<PendingMutation<Item>>
+  createdAt: number
+  executingAt?: number
+  completedAt?: number
+}
+
+type StrategyType = `debounce` | `queue` | `throttle`
+
+export function App() {
+  const [strategyType, setStrategyType] = useState<StrategyType>(`debounce`)
+  const [wait, setWait] = useState(300)
+  const [leading, setLeading] = useState(false)
+  const [trailing, setTrailing] = useState(true)
+
+  const [transactions, setTransactions] = useState<Array<TrackedTransaction>>(
+    []
+  )
+  const [optimisticState, setOptimisticState] = useState<Item | null>(null)
+  const [syncedState, setSyncedState] = useState<Item>(fakeServer.get(1)!)
+
+  // Initialize optimistic state from collection when ready
+  useEffect(() => {
+    itemCollection.stateWhenReady().then(() => {
+      setOptimisticState(itemCollection.get(1))
+    })
+  }, [])
+
+  // Create the strategy based on current settings
+  // Memoize to prevent recreation on every render
+  const strategy = useMemo(() => {
+    if (strategyType === `debounce`) {
+      return debounceStrategy({ wait, leading, trailing })
+    } else if (strategyType === `queue`) {
+      return queueStrategy({ wait })
+    } else {
+      return throttleStrategy({ wait, leading, trailing })
+    }
+  }, [strategyType, wait, leading, trailing])
+
+  // Create the paced mutations hook with onMutate for optimistic updates
+  const mutate = usePacedMutations<number>({
+    onMutate: (newValue) => {
+      // Apply optimistic update immediately
+      itemCollection.update(1, (draft) => {
+        draft.value = newValue
+        draft.timestamp = Date.now()
+      })
+    },
+    mutationFn: async ({ transaction }) => {
+      console.log(`mutationFn called with transaction:`, transaction)
+
+      // Update transaction state to executing when commit starts
+      const executingAt = Date.now()
+      setTransactions((prev) =>
+        prev.map((t) => {
+          if (t.id === transaction.id) {
+            return { ...t, state: `executing` as const, executingAt }
+          }
+          return t
+        })
+      )
+
+      // Simulate network delay to fake server (random 100-600ms)
+      const delay = Math.random() * 500 + 100
+      await new Promise((resolve) => setTimeout(resolve, delay))
+
+      // Write mutations to fake server
+      transaction.mutations.forEach((mutation) => {
+        console.log(`Processing mutation:`, mutation)
+        if (mutation.type === `insert`) {
+          const item = mutation.changes as Item
+          fakeServer.set(item.id, item)
+        } else if (mutation.type === `update`) {
+          const item = mutation.modified as Item
+          fakeServer.set(item.id, item)
+        } else {
+          // delete
+          fakeServer.delete(mutation.key as number)
+        }
+      })
+
+      // Update synced state
+      setSyncedState(fakeServer.get(1)!)
+
+      console.log(`Emitting sync event`)
+      // Sync back from server
+      serverEmitter.emit(`sync`, transaction.mutations)
+    },
+    strategy,
+  })
+
+  // Trigger a mutation with a specific value
+  const triggerMutation = (newValue: number) => {
+    // Pass the value directly - onMutate will apply the optimistic update
+    const tx = mutate(newValue)
+
+    // Update optimistic state after onMutate has been called
+    setOptimisticState(itemCollection.get(1))
+
+    // Track this transaction
+    const tracked: TrackedTransaction = {
+      id: tx.id,
+      transaction: tx,
+      state: `pending`,
+      mutations: tx.mutations,
+      createdAt: Date.now(),
+    }
+
+    setTransactions((prev) => {
+      // Only add if this transaction ID isn't already tracked
+      if (prev.some((t) => t.id === tx.id)) {
+        return prev
+      }
+      return [...prev, tracked]
+    })
+
+    // Listen for completion
+    tx.isPersisted.promise
+      .then(() => {
+        setTransactions((prev) =>
+          prev.map((t) => {
+            if (t.id === tx.id) {
+              return {
+                ...t,
+                state: `completed` as const,
+                completedAt: Date.now(),
+              }
+            }
+            return t
+          })
+        )
+        // Update optimistic state after completion
+        setOptimisticState(itemCollection.get(1))
+      })
+      .catch((error) => {
+        console.error(`Transaction failed:`, error)
+        setTransactions((prev) =>
+          prev.map((t) => {
+            if (t.id === tx.id) {
+              return { ...t, state: `failed` as const, completedAt: Date.now() }
+            }
+            return t
+          })
+        )
+        // Update optimistic state after failure
+        setOptimisticState(itemCollection.get(1))
+      })
+  }
+
+  const pending = transactions.filter((t) => t.state === `pending`)
+  const executing = transactions.filter((t) => t.state === `executing`)
+  const completed = transactions.filter((t) => t.state === `completed`)
+
+  return (
+    <div className="app">
+      <h1>Paced Mutations Demo</h1>
+      <p className="subtitle">
+        Drag the slider to trigger mutations and see how different strategies
+        batch, queue, and persist changes
+      </p>
+
+      <div className="stats">
+        <div className="stat-card">
+          <div className="stat-value">{optimisticState?.value ?? 0}</div>
+          <div className="stat-label">Optimistic Value</div>
+        </div>
+        <div className="stat-card">
+          <div className="stat-value">{syncedState.value}</div>
+          <div className="stat-label">Synced Value</div>
+        </div>
+      </div>
+
+      <div className="stats">
+        <div className="stat-card">
+          <div className="stat-value">{pending.length}</div>
+          <div className="stat-label">Pending</div>
+        </div>
+        <div className="stat-card">
+          <div className="stat-value">{executing.length}</div>
+          <div className="stat-label">Executing</div>
+        </div>
+        <div className="stat-card">
+          <div className="stat-value">{completed.length}</div>
+          <div className="stat-label">Completed</div>
+        </div>
+      </div>
+
+      <div className="grid">
+        <div className="panel">
+          <h2>Strategy Configuration</h2>
+
+          <div className="control-group">
+            <label>Strategy Type</label>
+            <select
+              value={strategyType}
+              onChange={(e) => setStrategyType(e.target.value as StrategyType)}
+            >
+              <option value="debounce">Debounce</option>
+              <option value="queue">Queue</option>
+              <option value="throttle">Throttle</option>
+            </select>
+          </div>
+
+          <div className="control-group">
+            <label>Wait Time (ms)</label>
+            <input
+              type="number"
+              value={wait}
+              onChange={(e) => setWait(Number(e.target.value))}
+              min={0}
+              step={100}
+            />
+          </div>
+
+          {(strategyType === `debounce` || strategyType === `throttle`) && (
+            <>
+              <div className="checkbox-group">
+                <input
+                  type="checkbox"
+                  id="leading"
+                  checked={leading}
+                  onChange={(e) => setLeading(e.target.checked)}
+                />
+                <label htmlFor="leading">Leading edge execution</label>
+              </div>
+
+              <div className="checkbox-group">
+                <input
+                  type="checkbox"
+                  id="trailing"
+                  checked={trailing}
+                  onChange={(e) => setTrailing(e.target.checked)}
+                />
+                <label htmlFor="trailing">Trailing edge execution</label>
+              </div>
+            </>
+          )}
+
+          <div className="control-group">
+            <label>Slider Value: {optimisticState?.value ?? 0}</label>
+            <input
+              type="range"
+              min={0}
+              max={100}
+              value={optimisticState?.value ?? 0}
+              onChange={(e) => triggerMutation(Number(e.target.value))}
+              style={{ width: `100%` }}
+            />
+            <div
+              style={{
+                display: `flex`,
+                justifyContent: `space-between`,
+                fontSize: `12px`,
+                color: `#999`,
+              }}
+            >
+              <span>0</span>
+              <span>50</span>
+              <span>100</span>
+            </div>
+          </div>
+
+          <div style={{ marginTop: `20px`, fontSize: `13px`, color: `#666` }}>
+            <h3 style={{ fontSize: `14px`, marginBottom: `8px` }}>
+              Strategy Info:
+            </h3>
+            {strategyType === `debounce` && (
+              <p>
+                <strong>Debounce:</strong> Waits for {wait}ms of inactivity
+                before persisting.
+                {leading && ` Executes immediately on first call.`}
+                {trailing && ` Executes after wait period.`}
+              </p>
+            )}
+            {strategyType === `queue` && (
+              <p>
+                <strong>Queue:</strong> Processes mutations sequentially in
+                order received (FIFO) with {wait}ms between each.
+              </p>
+            )}
+            {strategyType === `throttle` && (
+              <p>
+                <strong>Throttle:</strong> Ensures at least {wait}ms between
+                executions.
+                {leading && ` Executes immediately on first call.`}
+                {trailing && ` Executes after wait period.`}
+              </p>
+            )}
+          </div>
+        </div>
+
+        <div className="panel">
+          <h2>Transaction Timeline</h2>
+
+          {transactions.length === 0 ? (
+            <div className="empty-state">
+              No mutations yet. Drag the slider to start!
+            </div>
+          ) : (
+            <div className="transaction-list">
+              {[...transactions].reverse().map((tracked) => (
+                <div
+                  key={tracked.id}
+                  className={`transaction-card ${tracked.state}`}
+                >
+                  <div className="transaction-header">
+                    <span className="transaction-id">
+                      ID: {tracked.id.slice(0, 8)}
+                    </span>
+                    <span className={`transaction-status ${tracked.state}`}>
+                      {tracked.state}
+                    </span>
+                  </div>
+                  <div className="transaction-details">
+                    <div>
+                      Created:{` `}
+                      {new Date(tracked.createdAt).toLocaleTimeString()}
+                    </div>
+                    {tracked.executingAt && (
+                      <div>
+                        Started Executing:{` `}
+                        {new Date(tracked.executingAt).toLocaleTimeString()}
+                        {` `}(pending: {tracked.executingAt - tracked.createdAt}
+                        ms)
+                      </div>
+                    )}
+                    {tracked.completedAt && (
+                      <div>
+                        Completed:{` `}
+                        {new Date(tracked.completedAt).toLocaleTimeString()}
+                        {tracked.executingAt && (
+                          <>
+                            {` `}(persisting:{` `}
+                            {tracked.completedAt - tracked.executingAt}ms)
+                          </>
+                        )}
+                      </div>
+                    )}
+                    {tracked.completedAt && (
+                      <div style={{ fontWeight: `bold`, marginTop: `4px` }}>
+                        Total Duration:{` `}
+                        {tracked.completedAt - tracked.createdAt}ms
+                      </div>
+                    )}
+                  </div>
+                  <div className="transaction-mutations">
+                    <div style={{ fontWeight: `bold`, marginBottom: `4px` }}>
+                      Mutations ({tracked.mutations.length}):
+                    </div>
+                    {tracked.mutations.map((mut, idx) => {
+                      if (mut.type === `update`) {
+                        const item = mut.modified
+                        return (
+                          <div key={idx} className="mutation">
+                            <span className="mutation-type">{mut.type}</span>
+                            <>: value = {item.value}</>
+                          </div>
+                        )
+                      }
+                      return (
+                        <div key={idx} className="mutation">
+                          <span className="mutation-type">{mut.type}</span>
+                        </div>
+                      )
+                    })}
+                  </div>
+                </div>
+              ))}
+            </div>
+          )}
+        </div>
+      </div>
+    </div>
+  )
+}
diff --git a/examples/react/paced-mutations-demo/src/index.css b/examples/react/paced-mutations-demo/src/index.css
new file mode 100644
index 000000000..d863dbaf4
--- /dev/null
+++ b/examples/react/paced-mutations-demo/src/index.css
@@ -0,0 +1,285 @@
+* {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+}
+
+body {
+  font-family:
+    -apple-system, BlinkMacSystemFont, "Segoe UI", "Roboto", "Oxygen", "Ubuntu",
+    "Cantarell", "Fira Sans", "Droid Sans", "Helvetica Neue", sans-serif;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  background: #f5f5f5;
+  padding: 20px;
+}
+
+code {
+  font-family:
+    source-code-pro, Menlo, Monaco, Consolas, "Courier New", monospace;
+  background: #f0f0f0;
+  padding: 2px 6px;
+  border-radius: 3px;
+  font-size: 0.9em;
+}
+
+.app {
+  max-width: 1400px;
+  margin: 0 auto;
+}
+
+h1 {
+  margin-bottom: 8px;
+  color: #333;
+}
+
+.subtitle {
+  color: #666;
+  margin-bottom: 24px;
+  font-size: 14px;
+}
+
+.grid {
+  display: grid;
+  grid-template-columns: 400px 1fr;
+  gap: 20px;
+  margin-bottom: 20px;
+}
+
+.panel {
+  background: white;
+  border-radius: 8px;
+  padding: 20px;
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+}
+
+.panel h2 {
+  margin-bottom: 16px;
+  font-size: 18px;
+  color: #333;
+  border-bottom: 2px solid #e0e0e0;
+  padding-bottom: 8px;
+}
+
+.control-group {
+  margin-bottom: 20px;
+}
+
+.control-group label {
+  display: block;
+  margin-bottom: 6px;
+  font-weight: 500;
+  color: #555;
+  font-size: 14px;
+}
+
+.control-group select,
+.control-group input[type="number"] {
+  width: 100%;
+  padding: 8px;
+  border: 1px solid #ddd;
+  border-radius: 4px;
+  font-size: 14px;
+}
+
+.checkbox-group {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin-bottom: 8px;
+}
+
+.checkbox-group input[type="checkbox"] {
+  width: 16px;
+  height: 16px;
+}
+
+.checkbox-group label {
+  margin: 0 !important;
+  font-weight: normal !important;
+}
+
+.action-buttons {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+  margin-top: 20px;
+}
+
+button {
+  padding: 12px 20px;
+  border: none;
+  border-radius: 6px;
+  font-size: 14px;
+  font-weight: 600;
+  cursor: pointer;
+  transition: all 0.2s;
+}
+
+.btn-primary {
+  background: #007bff;
+  color: white;
+}
+
+.btn-primary:hover {
+  background: #0056b3;
+}
+
+.btn-secondary {
+  background: #6c757d;
+  color: white;
+}
+
+.btn-secondary:hover {
+  background: #545b62;
+}
+
+.btn-danger {
+  background: #dc3545;
+  color: white;
+}
+
+.btn-danger:hover {
+  background: #c82333;
+}
+
+.transaction-list {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+
+.transaction-card {
+  background: #f8f9fa;
+  border-radius: 6px;
+  padding: 12px;
+  border-left: 4px solid #ccc;
+}
+
+.transaction-card.pending {
+  border-left-color: #ffc107;
+  background: #fff3cd;
+}
+
+.transaction-card.executing {
+  border-left-color: #17a2b8;
+  background: #d1ecf1;
+}
+
+.transaction-card.completed {
+  border-left-color: #28a745;
+  background: #d4edda;
+}
+
+.transaction-card.failed {
+  border-left-color: #dc3545;
+  background: #f8d7da;
+}
+
+.transaction-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 8px;
+}
+
+.transaction-id {
+  font-weight: 600;
+  font-size: 12px;
+  color: #666;
+  font-family: monospace;
+}
+
+.transaction-status {
+  display: inline-block;
+  padding: 2px 8px;
+  border-radius: 12px;
+  font-size: 11px;
+  font-weight: 600;
+  text-transform: uppercase;
+}
+
+.transaction-status.pending {
+  background: #ffc107;
+  color: #856404;
+}
+
+.transaction-status.executing {
+  background: #17a2b8;
+  color: #0c5460;
+}
+
+.transaction-status.completed {
+  background: #28a745;
+  color: #155724;
+}
+
+.transaction-status.failed {
+  background: #dc3545;
+  color: #721c24;
+}
+
+.transaction-details {
+  font-size: 13px;
+  color: #555;
+}
+
+.transaction-mutations {
+  margin-top: 8px;
+  padding: 8px;
+  background: white;
+  border-radius: 4px;
+  font-size: 12px;
+}
+
+.mutation {
+  padding: 4px 0;
+  border-bottom: 1px solid #eee;
+}
+
+.mutation:last-child {
+  border-bottom: none;
+}
+
+.mutation-type {
+  font-weight: 600;
+  color: #007bff;
+  text-transform: uppercase;
+  font-size: 11px;
+}
+
+.empty-state {
+  text-align: center;
+  padding: 40px 20px;
+  color: #999;
+  font-style: italic;
+}
+
+.stats {
+  display: grid;
+  grid-template-columns: repeat(3, 1fr);
+  gap: 12px;
+  margin-bottom: 20px;
+}
+
+.stat-card {
+  background: white;
+  border-radius: 8px;
+  padding: 16px;
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+  text-align: center;
+}
+
+.stat-value {
+  font-size: 32px;
+  font-weight: 700;
+  color: #333;
+}
+
+.stat-label {
+  font-size: 12px;
+  color: #666;
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+  margin-top: 4px;
+}
diff --git a/examples/react/paced-mutations-demo/src/main.tsx b/examples/react/paced-mutations-demo/src/main.tsx
new file mode 100644
index 000000000..8def6fa63
--- /dev/null
+++ b/examples/react/paced-mutations-demo/src/main.tsx
@@ -0,0 +1,10 @@
+import React from "react"
+import ReactDOM from "react-dom/client"
+import { App } from "./App"
+import "./index.css"
+
+ReactDOM.createRoot(document.getElementById(`root`)!).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>
+)
diff --git a/examples/react/paced-mutations-demo/tsconfig.json b/examples/react/paced-mutations-demo/tsconfig.json
new file mode 100644
index 000000000..14ff1a28c
--- /dev/null
+++ b/examples/react/paced-mutations-demo/tsconfig.json
@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["src", "vite.config.ts"]
+}
diff --git a/examples/react/paced-mutations-demo/vite.config.ts b/examples/react/paced-mutations-demo/vite.config.ts
new file mode 100644
index 000000000..ea1889ae7
--- /dev/null
+++ b/examples/react/paced-mutations-demo/vite.config.ts
@@ -0,0 +1,6 @@
+import { defineConfig } from "vite"
+import react from "@vitejs/plugin-react"
+
+export default defineConfig({
+  plugins: [react()],
+})
diff --git a/examples/react/todo/src/components/TodoApp.tsx b/examples/react/todo/src/components/TodoApp.tsx
index 1a1e152d8..0fbcb65ed 100644
--- a/examples/react/todo/src/components/TodoApp.tsx
+++ b/examples/react/todo/src/components/TodoApp.tsx
@@ -1,7 +1,8 @@
 import React, { useState } from "react"
 import { Link } from "@tanstack/react-router"
+import { debounceStrategy, usePacedMutations } from "@tanstack/react-db"
 import type { FormEvent } from "react"
-import type { Collection } from "@tanstack/react-db"
+import type { Collection, Transaction } from "@tanstack/react-db"
 
 import type { SelectConfig, SelectTodo } from "@/db/validation"
 import { getComplementaryColor } from "@/lib/color"
@@ -12,6 +13,7 @@ interface TodoAppProps {
   todoCollection: Collection<SelectTodo>
   configCollection: Collection<SelectConfig>
   title: string
+  configMutationFn?: (params: { transaction: Transaction }) => Promise<void>
 }
 
 export function TodoApp({
@@ -20,9 +22,19 @@ export function TodoApp({
   todoCollection,
   configCollection,
   title,
+  configMutationFn,
 }: TodoAppProps) {
   const [newTodo, setNewTodo] = useState(``)
 
+  // Use paced mutations with debounce strategy for color picker if mutationFn provided
+  // Waits for 2500ms of inactivity before persisting - only the final value is saved
+  const mutateConfig = configMutationFn
+    ? usePacedMutations({
+        mutationFn: configMutationFn,
+        strategy: debounceStrategy({ wait: 2500 }),
+      })
+    : undefined
+
   // Define a type-safe helper function to get config values
   const getConfigValue = (key: string): string | undefined => {
     for (const config of configData) {
@@ -35,23 +47,47 @@ export function TodoApp({
 
   // Define a helper function to update config values
   const setConfigValue = (key: string, value: string): void => {
-    for (const config of configData) {
-      if (config.key === key) {
-        configCollection.update(config.id, (draft) => {
-          draft.value = value
+    if (mutateConfig) {
+      // Use paced mutations for updates (optimistic + batched persistence)
+      mutateConfig(() => {
+        for (const config of configData) {
+          if (config.key === key) {
+            configCollection.update(config.id, (draft) => {
+              draft.value = value
+            })
+            return
+          }
+        }
+
+        // If the config doesn't exist yet, create it
+        configCollection.insert({
+          id: Math.round(Math.random() * 1000000),
+          key,
+          value,
+          created_at: new Date(),
+          updated_at: new Date(),
         })
-        return
+      })
+    } else {
+      // Use naked collection calls (collection handlers will be invoked)
+      for (const config of configData) {
+        if (config.key === key) {
+          configCollection.update(config.id, (draft) => {
+            draft.value = value
+          })
+          return
+        }
       }
-    }
 
-    // If the config doesn't exist yet, create it
-    configCollection.insert({
-      id: Math.round(Math.random() * 1000000),
-      key,
-      value,
-      created_at: new Date(),
-      updated_at: new Date(),
-    })
+      // If the config doesn't exist yet, create it
+      configCollection.insert({
+        id: Math.round(Math.random() * 1000000),
+        key,
+        value,
+        created_at: new Date(),
+        updated_at: new Date(),
+      })
+    }
   }
 
   const backgroundColor = getConfigValue(`backgroundColor`)
diff --git a/examples/react/todo/src/routes/electric.tsx b/examples/react/todo/src/routes/electric.tsx
index 8d4f068f6..c361d1686 100644
--- a/examples/react/todo/src/routes/electric.tsx
+++ b/examples/react/todo/src/routes/electric.tsx
@@ -5,6 +5,8 @@ import {
   electricTodoCollection,
 } from "../lib/collections"
 import { TodoApp } from "../components/TodoApp"
+import { api } from "../lib/api"
+import type { Transaction } from "@tanstack/react-db"
 
 export const Route = createFileRoute(`/electric`)({
   component: ElectricPage,
@@ -31,6 +33,40 @@ function ElectricPage() {
     q.from({ config: electricConfigCollection })
   )
 
+  // Electric collections use txid to track sync
+  const configMutationFn = async ({
+    transaction,
+  }: {
+    transaction: Transaction
+  }) => {
+    const txids: Array<number> = []
+
+    // Handle inserts
+    const inserts = transaction.mutations.filter((m) => m.type === `insert`)
+    for (const mutation of inserts) {
+      const response = await api.config.create(mutation.modified)
+      txids.push(response.txid)
+    }
+
+    // Handle updates
+    const updates = transaction.mutations.filter((m) => m.type === `update`)
+    for (const mutation of updates) {
+      if (!(`id` in mutation.original)) {
+        throw new Error(`Original config not found for update`)
+      }
+      const response = await api.config.update(
+        mutation.original.id,
+        mutation.changes
+      )
+      txids.push(response.txid)
+    }
+
+    // Wait for all txids to sync back to the collection
+    await Promise.all(
+      txids.map((txid) => electricConfigCollection.utils.awaitTxid(txid))
+    )
+  }
+
   return (
     <TodoApp
       todos={todos}
@@ -38,6 +74,7 @@ function ElectricPage() {
       todoCollection={electricTodoCollection}
       configCollection={electricConfigCollection}
       title="todos (electric)"
+      configMutationFn={configMutationFn}
     />
   )
 }
diff --git a/examples/react/todo/src/routes/query.tsx b/examples/react/todo/src/routes/query.tsx
index 129ab0cd4..99aa80197 100644
--- a/examples/react/todo/src/routes/query.tsx
+++ b/examples/react/todo/src/routes/query.tsx
@@ -2,6 +2,8 @@ import { createFileRoute } from "@tanstack/react-router"
 import { useLiveQuery } from "@tanstack/react-db"
 import { queryConfigCollection, queryTodoCollection } from "../lib/collections"
 import { TodoApp } from "../components/TodoApp"
+import { api } from "../lib/api"
+import type { Transaction } from "@tanstack/react-db"
 
 export const Route = createFileRoute(`/query`)({
   component: QueryPage,
@@ -28,6 +30,35 @@ function QueryPage() {
     q.from({ config: queryConfigCollection })
   )
 
+  // Query collections automatically refetch after handler completes
+  const configMutationFn = async ({
+    transaction,
+  }: {
+    transaction: Transaction
+  }) => {
+    // Handle inserts
+    const inserts = transaction.mutations.filter((m) => m.type === `insert`)
+    await Promise.all(
+      inserts.map(async (mutation) => {
+        await api.config.create(mutation.modified)
+      })
+    )
+
+    // Handle updates
+    const updates = transaction.mutations.filter((m) => m.type === `update`)
+    await Promise.all(
+      updates.map(async (mutation) => {
+        if (!(`id` in mutation.original)) {
+          throw new Error(`Original config not found for update`)
+        }
+        await api.config.update(mutation.original.id, mutation.changes)
+      })
+    )
+
+    // Trigger refetch to get confirmed server state
+    await queryConfigCollection.utils.refetch()
+  }
+
   return (
     <TodoApp
       todos={todos}
@@ -35,6 +66,7 @@ function QueryPage() {
       todoCollection={queryTodoCollection}
       configCollection={queryConfigCollection}
       title="todos (query)"
+      configMutationFn={configMutationFn}
     />
   )
 }
diff --git a/examples/react/todo/src/routes/trailbase.tsx b/examples/react/todo/src/routes/trailbase.tsx
index 4ed7458f7..4ef397e66 100644
--- a/examples/react/todo/src/routes/trailbase.tsx
+++ b/examples/react/todo/src/routes/trailbase.tsx
@@ -31,6 +31,13 @@ function TrailBasePage() {
     q.from({ config: trailBaseConfigCollection })
   )
 
+  // Note: TrailBase collections use recordApi internally, which is not exposed
+  // as a collection utility. For this example, we're not using serialized
+  // transactions with TrailBase - the color picker will use naked collection
+  // calls which invoke the collection's built-in handlers automatically.
+  // In a real app, you could expose the recordApi via utils to enable
+  // serialized transactions with TrailBase collections.
+
   return (
     <TodoApp
       todos={todos}
diff --git a/feedback-1.md b/feedback-1.md
new file mode 100644
index 000000000..92cbdebc7
--- /dev/null
+++ b/feedback-1.md
@@ -0,0 +1,7 @@
+- High – The proposed core API drops the `Transaction` surface returned by `createTransaction`; `mutate` is shown as `void` with only a `cleanup()` companion (`SERIALIZED_TRANSACTION_PLAN.md:95`). Without propagating the `Transaction` object (or at least its `isPersisted` promise/error handling), callers lose the only way to await persistence or detect failures, which is central to today’s transaction workflow. Please plan to surface the existing `Transaction` or equivalent signals instead of returning bare callbacks.
+
+- High – The React hook sketch keeps a stale strategy instance: it creates `strategyRef` but never reads it, and `useMemo` ignores `config.strategy` in its dependency array (`SERIALIZED_TRANSACTION_PLAN.md:234`). Any consumer that swaps strategies (or mutates strategy options) would continue using the first instance and never trigger the tear-down path. The plan should either require stable strategy instances or include strategy in the memo/effect dependencies and actually dispose/recreate when it changes.
+
+- Medium – The Angular deliverable is listed as `useSerializedTransaction.ts`, but the Angular package currently follows the `inject…` pattern (`packages/angular-db/src/index.ts` exports `injectLiveQuery`). Shipping a `use`-prefixed API would stick out and miss Angular’s DI guards; please align the plan with the existing injection-based naming/structure (`SERIALIZED_TRANSACTION_PLAN.md:84`).
+
+- Medium – The strategy example imports `Debouncer` via the `@tanstack/pacer/debouncer` subpath (`SERIALIZED_TRANSACTION_PLAN.md:266`), but Pacer’s public API is bundled behind its main entry points. Depending on subpath files risks breaking when the package layout shifts. I’d recommend validating the actual export surface (likely `import { createDebouncer } from '@tanstack/pacer'`) before committing to this shape.
diff --git a/feedback-2.md b/feedback-2.md
new file mode 100644
index 000000000..e9e90f2f2
--- /dev/null
+++ b/feedback-2.md
@@ -0,0 +1 @@
+- High – The Solid deliverable name still conflicts with the core export. `packages/solid-db/src/index.ts` re-exports `createSerializedTransaction` from `@tanstack/db`, so shipping a Solid wrapper with the same name (`createSerializedTransaction(config)` in the plan) will cause the barrel to re-export the identifier twice and TypeScript will emit TS2308. Please rename the Solid-specific helper or stop re-exporting the core helper from the Solid package to avoid the collision.
diff --git a/feedback-3.md b/feedback-3.md
new file mode 100644
index 000000000..3c5729294
--- /dev/null
+++ b/feedback-3.md
@@ -0,0 +1,5 @@
+- High – Trailing strategies leave earlier transactions permanently pending. Each `mutate` call in `createSerializedTransaction` creates a fresh transaction and immediately returns it (`packages/db/src/serialized-transaction.ts:80-103`), but the debouncer/throttler only runs the _latest_ scheduled callback (`packages/db/src/strategies/debounceStrategy.ts:31-45`, `packages/db/src/strategies/throttleStrategy.ts:45-58`). When a later call supersedes an earlier one, the earlier transaction never commits or rolls back, so `tx.isPersisted.promise` never resolves and the transaction stays in the global pending list. We need to either reuse a single transaction per manager or explicitly cancel/rollback superseded transactions whenever a strategy drops them.
+
+- High – `cleanup()` can leave optimistic mutations stuck in a pending transaction. If the consumer unmounts while a trailing debounce/throttle call is waiting, `cleanup()` only cancels the strategy (`packages/db/src/serialized-transaction.ts:109-111`). The transaction we already created remains `pending`, its optimistic changes stay applied, and `isPersisted.promise` never settles. `cleanup()` should flush or rollback any in-flight transaction before returning.
+
+- High – The queue strategy does not serialize commits. `queueStrategy` wires `Queuer`’s synchronous `onGetNextItem` callback directly to `transaction.commit()` (`packages/db/src/strategies/queueStrategy.ts:48-65`), but `Queuer` keeps pulling items without waiting for that callback to finish. As a result, every queued transaction starts committing immediately and we lose sequencing guarantees. Switching to `AsyncQueuer` (or awaiting the `commit()` promise before processing the next item) should fix this.
diff --git a/feedback-4.md b/feedback-4.md
new file mode 100644
index 000000000..fc6dfb1b5
--- /dev/null
+++ b/feedback-4.md
@@ -0,0 +1,5 @@
+- High – `queueStrategy` now runs every transaction’s `commit()` a second time. `createSerializedMutations` already calls `transaction.commit()` inside the scheduled callback (`packages/db/src/serialized-mutations.ts:101-127`), but the queue worker awaits `transaction.commit()` again (`packages/db/src/strategies/queueStrategy.ts:61-66`). The second call happens while the transaction state is `persisting`, so the queue immediately hits `TransactionNotPendingCommitError` and aborts the item. The queue should wait on `transaction.isPersisted.promise` (or let the strategy callback return the commit promise) instead of invoking `commit()` itself.
+
+- High – `cleanup()` can throw and/or corrupt completed transactions. If the active commit finishes right before cleanup runs, the transaction is already in the `completed` state when we call `executingTransaction.rollback()` (`packages/db/src/serialized-mutations.ts:149-152`), so `TransactionAlreadyCompletedRollbackError` bubbles out of cleanup. Even when the commit is still in flight, forcing a rollback races with the resolver `then` handlers. Please guard the rollback with a state check (or await `isPersisted.promise`) so teardown stays safe.
+
+- High – Strategies that drop callbacks leave returned transactions pending forever. We only remove/rollback entries inside the strategy callback (`packages/db/src/serialized-mutations.ts:101-113`), but Pacer’s debouncer/throttler simply skip calling `fn` when `trailing` is disabled (see `packages/db/src/strategies/debounceStrategy.ts:31-40`). In that configuration every suppressed `mutate` returns a transaction whose `isPersisted.promise` never settles unless another call eventually fires or cleanup runs. We need to settle those transactions immediately when the strategy decides not to run them (e.g. cancel/rollback on reschedule, or reuse a single transaction per manager).
diff --git a/packages/db/package.json b/packages/db/package.json
index 9cfb30767..b5cbbf159 100644
--- a/packages/db/package.json
+++ b/packages/db/package.json
@@ -4,7 +4,8 @@
   "version": "0.4.14",
   "dependencies": {
     "@standard-schema/spec": "^1.0.0",
-    "@tanstack/db-ivm": "workspace:*"
+    "@tanstack/db-ivm": "workspace:*",
+    "@tanstack/pacer": "^0.1.0"
   },
   "devDependencies": {
     "@vitest/coverage-istanbul": "^3.2.4",
diff --git a/packages/db/src/index.ts b/packages/db/src/index.ts
index a41cf51aa..c58c7a5d5 100644
--- a/packages/db/src/index.ts
+++ b/packages/db/src/index.ts
@@ -13,6 +13,8 @@ export * from "./optimistic-action"
 export * from "./local-only"
 export * from "./local-storage"
 export * from "./errors"
+export * from "./paced-mutations"
+export * from "./strategies/index.js"
 
 // Index system exports
 export * from "./indexes/base-index.js"
diff --git a/packages/db/src/paced-mutations.ts b/packages/db/src/paced-mutations.ts
new file mode 100644
index 000000000..1a85957c7
--- /dev/null
+++ b/packages/db/src/paced-mutations.ts
@@ -0,0 +1,169 @@
+import { createTransaction } from "./transactions"
+import type { MutationFn, Transaction } from "./types"
+import type { Strategy } from "./strategies/types"
+
+/**
+ * Configuration for creating a paced mutations manager
+ */
+export interface PacedMutationsConfig<
+  TVariables = unknown,
+  T extends object = Record<string, unknown>,
+> {
+  /**
+   * Callback to apply optimistic updates immediately.
+   * Receives the variables passed to the mutate function.
+   */
+  onMutate: (variables: TVariables) => void
+  /**
+   * Function to execute the mutation on the server.
+   * Receives the transaction parameters containing all merged mutations.
+   */
+  mutationFn: MutationFn<T>
+  /**
+   * Strategy for controlling mutation execution timing
+   * Examples: debounceStrategy, queueStrategy, throttleStrategy
+   */
+  strategy: Strategy
+  /**
+   * Custom metadata to associate with transactions
+   */
+  metadata?: Record<string, unknown>
+}
+
+/**
+ * Creates a paced mutations manager with pluggable timing strategies.
+ *
+ * This function provides a way to control when and how optimistic mutations
+ * are persisted to the backend, using strategies like debouncing, queuing,
+ * or throttling. The optimistic updates are applied immediately via `onMutate`,
+ * and the actual persistence is controlled by the strategy.
+ *
+ * The returned function accepts variables of type TVariables and returns a
+ * Transaction object that can be awaited to know when persistence completes
+ * or to handle errors.
+ *
+ * @param config - Configuration including onMutate, mutationFn and strategy
+ * @returns A function that accepts variables and returns a Transaction
+ *
+ * @example
+ * ```ts
+ * // Debounced mutations for auto-save
+ * const updateTodo = createPacedMutations<string>({
+ *   onMutate: (text) => {
+ *     // Apply optimistic update immediately
+ *     collection.update(id, draft => { draft.text = text })
+ *   },
+ *   mutationFn: async (text, { transaction }) => {
+ *     await api.save(transaction.mutations)
+ *   },
+ *   strategy: debounceStrategy({ wait: 500 })
+ * })
+ *
+ * // Call with variables, returns a transaction
+ * const tx = updateTodo('New text')
+ *
+ * // Await persistence or handle errors
+ * await tx.isPersisted.promise
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Queue strategy for sequential processing
+ * const addTodo = createPacedMutations<{ text: string }>({
+ *   onMutate: ({ text }) => {
+ *     collection.insert({ id: uuid(), text, completed: false })
+ *   },
+ *   mutationFn: async ({ text }, { transaction }) => {
+ *     await api.save(transaction.mutations)
+ *   },
+ *   strategy: queueStrategy({
+ *     wait: 200,
+ *     addItemsTo: 'back',
+ *     getItemsFrom: 'front'
+ *   })
+ * })
+ * ```
+ */
+export function createPacedMutations<
+  TVariables = unknown,
+  T extends object = Record<string, unknown>,
+>(
+  config: PacedMutationsConfig<TVariables, T>
+): (variables: TVariables) => Transaction<T> {
+  const { onMutate, mutationFn, strategy, ...transactionConfig } = config
+
+  // The currently active transaction (pending, not yet persisting)
+  let activeTransaction: Transaction<T> | null = null
+
+  // Commit callback that the strategy will call when it's time to persist
+  const commitCallback = () => {
+    if (!activeTransaction) {
+      throw new Error(
+        `Strategy callback called but no active transaction exists. This indicates a bug in the strategy implementation.`
+      )
+    }
+
+    if (activeTransaction.state !== `pending`) {
+      throw new Error(
+        `Strategy callback called but active transaction is in state "${activeTransaction.state}". Expected "pending".`
+      )
+    }
+
+    const txToCommit = activeTransaction
+
+    // Clear active transaction reference before committing
+    activeTransaction = null
+
+    // Commit the transaction
+    txToCommit.commit().catch(() => {
+      // Errors are handled via transaction.isPersisted.promise
+      // This catch prevents unhandled promise rejections
+    })
+
+    return txToCommit
+  }
+
+  /**
+   * Executes a mutation with the given variables. Creates a new transaction if none is active,
+   * or adds to the existing active transaction. The strategy controls when
+   * the transaction is actually committed.
+   */
+  function mutate(variables: TVariables): Transaction<T> {
+    // Create a new transaction if we don't have an active one
+    if (!activeTransaction || activeTransaction.state !== `pending`) {
+      activeTransaction = createTransaction<T>({
+        ...transactionConfig,
+        mutationFn,
+        autoCommit: false,
+      })
+    }
+
+    // Execute onMutate with variables to apply optimistic updates
+    activeTransaction.mutate(() => {
+      onMutate(variables)
+    })
+
+    // Save reference before calling strategy.execute
+    const txToReturn = activeTransaction
+
+    // For queue strategy, pass a function that commits the captured transaction
+    // This prevents the error when commitCallback tries to access the cleared activeTransaction
+    if (strategy._type === `queue`) {
+      const capturedTx = activeTransaction
+      activeTransaction = null // Clear so next mutation creates a new transaction
+      strategy.execute(() => {
+        capturedTx.commit().catch(() => {
+          // Errors are handled via transaction.isPersisted.promise
+        })
+        return capturedTx
+      })
+    } else {
+      // For debounce/throttle, use commitCallback which manages activeTransaction
+      strategy.execute(commitCallback)
+    }
+
+    return txToReturn
+  }
+
+  return mutate
+}
diff --git a/packages/db/src/strategies/debounceStrategy.ts b/packages/db/src/strategies/debounceStrategy.ts
new file mode 100644
index 000000000..57edc323c
--- /dev/null
+++ b/packages/db/src/strategies/debounceStrategy.ts
@@ -0,0 +1,45 @@
+import { Debouncer } from "@tanstack/pacer/debouncer"
+import type { DebounceStrategy, DebounceStrategyOptions } from "./types"
+import type { Transaction } from "../transactions"
+
+/**
+ * Creates a debounce strategy that delays transaction execution until after
+ * a period of inactivity.
+ *
+ * Ideal for scenarios like search inputs or auto-save fields where you want
+ * to wait for the user to stop typing before persisting changes.
+ *
+ * @param options - Configuration for the debounce behavior
+ * @returns A debounce strategy instance
+ *
+ * @example
+ * ```ts
+ * const mutate = useSerializedTransaction({
+ *   mutationFn: async ({ transaction }) => {
+ *     await api.save(transaction.mutations)
+ *   },
+ *   strategy: debounceStrategy({ wait: 500 })
+ * })
+ * ```
+ */
+export function debounceStrategy(
+  options: DebounceStrategyOptions
+): DebounceStrategy {
+  const debouncer = new Debouncer(
+    (callback: () => Transaction) => callback(),
+    options
+  )
+
+  return {
+    _type: `debounce`,
+    options,
+    execute: <T extends object = Record<string, unknown>>(
+      fn: () => Transaction<T>
+    ) => {
+      debouncer.maybeExecute(fn as () => Transaction)
+    },
+    cleanup: () => {
+      debouncer.cancel()
+    },
+  }
+}
diff --git a/packages/db/src/strategies/index.ts b/packages/db/src/strategies/index.ts
new file mode 100644
index 000000000..734842617
--- /dev/null
+++ b/packages/db/src/strategies/index.ts
@@ -0,0 +1,17 @@
+// Export all strategy factories
+export { debounceStrategy } from "./debounceStrategy"
+export { queueStrategy } from "./queueStrategy"
+export { throttleStrategy } from "./throttleStrategy"
+
+// Export strategy types
+export type {
+  Strategy,
+  BaseStrategy,
+  DebounceStrategy,
+  DebounceStrategyOptions,
+  QueueStrategy,
+  QueueStrategyOptions,
+  ThrottleStrategy,
+  ThrottleStrategyOptions,
+  StrategyOptions,
+} from "./types"
diff --git a/packages/db/src/strategies/queueStrategy.ts b/packages/db/src/strategies/queueStrategy.ts
new file mode 100644
index 000000000..a0dafac9f
--- /dev/null
+++ b/packages/db/src/strategies/queueStrategy.ts
@@ -0,0 +1,75 @@
+import { AsyncQueuer } from "@tanstack/pacer/async-queuer"
+import type { QueueStrategy, QueueStrategyOptions } from "./types"
+import type { Transaction } from "../transactions"
+
+/**
+ * Creates a queue strategy that processes all mutations in order with proper serialization.
+ *
+ * Unlike other strategies that may drop executions, queue ensures every
+ * mutation is processed sequentially. Each transaction commit completes before
+ * the next one starts. Useful when data consistency is critical and
+ * every operation must complete in order.
+ *
+ * @param options - Configuration for queue behavior (FIFO/LIFO, timing, size limits)
+ * @returns A queue strategy instance
+ *
+ * @example
+ * ```ts
+ * // FIFO queue - process in order received
+ * const mutate = usePacedMutations({
+ *   mutationFn: async ({ transaction }) => {
+ *     await api.save(transaction.mutations)
+ *   },
+ *   strategy: queueStrategy({
+ *     wait: 200,
+ *     addItemsTo: 'back',
+ *     getItemsFrom: 'front'
+ *   })
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // LIFO queue - process most recent first
+ * const mutate = usePacedMutations({
+ *   mutationFn: async ({ transaction }) => {
+ *     await api.save(transaction.mutations)
+ *   },
+ *   strategy: queueStrategy({
+ *     wait: 200,
+ *     addItemsTo: 'back',
+ *     getItemsFrom: 'back'
+ *   })
+ * })
+ * ```
+ */
+export function queueStrategy(options?: QueueStrategyOptions): QueueStrategy {
+  const queuer = new AsyncQueuer<void>({
+    concurrency: 1, // Process one at a time to ensure serialization
+    wait: options?.wait,
+    maxSize: options?.maxSize,
+    addItemsTo: options?.addItemsTo ?? `back`, // Default FIFO: add to back
+    getItemsFrom: options?.getItemsFrom ?? `front`, // Default FIFO: get from front
+    started: true, // Start processing immediately
+  })
+
+  return {
+    _type: `queue`,
+    options,
+    execute: <T extends object = Record<string, unknown>>(
+      fn: () => Transaction<T>
+    ) => {
+      // Wrap the callback in an async function that waits for persistence
+      queuer.addItem(async () => {
+        const transaction = fn()
+        // Wait for the transaction to be persisted before processing next item
+        // Note: fn() already calls commit(), we just wait for it to complete
+        await transaction.isPersisted.promise
+      })
+    },
+    cleanup: () => {
+      queuer.stop()
+      queuer.clear()
+    },
+  }
+}
diff --git a/packages/db/src/strategies/throttleStrategy.ts b/packages/db/src/strategies/throttleStrategy.ts
new file mode 100644
index 000000000..83cdc7f7a
--- /dev/null
+++ b/packages/db/src/strategies/throttleStrategy.ts
@@ -0,0 +1,62 @@
+import { Throttler } from "@tanstack/pacer/throttler"
+import type { ThrottleStrategy, ThrottleStrategyOptions } from "./types"
+import type { Transaction } from "../transactions"
+
+/**
+ * Creates a throttle strategy that ensures transactions are evenly spaced
+ * over time.
+ *
+ * Provides smooth, controlled execution patterns ideal for UI updates like
+ * sliders, progress bars, or scroll handlers where you want consistent
+ * execution timing.
+ *
+ * @param options - Configuration for throttle behavior
+ * @returns A throttle strategy instance
+ *
+ * @example
+ * ```ts
+ * // Throttle slider updates to every 200ms
+ * const mutate = useSerializedTransaction({
+ *   mutationFn: async ({ transaction }) => {
+ *     await api.updateVolume(transaction.mutations)
+ *   },
+ *   strategy: throttleStrategy({ wait: 200 })
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Throttle with leading and trailing execution
+ * const mutate = useSerializedTransaction({
+ *   mutationFn: async ({ transaction }) => {
+ *     await api.save(transaction.mutations)
+ *   },
+ *   strategy: throttleStrategy({
+ *     wait: 500,
+ *     leading: true,
+ *     trailing: true
+ *   })
+ * })
+ * ```
+ */
+export function throttleStrategy(
+  options: ThrottleStrategyOptions
+): ThrottleStrategy {
+  const throttler = new Throttler(
+    (callback: () => Transaction) => callback(),
+    options
+  )
+
+  return {
+    _type: `throttle`,
+    options,
+    execute: <T extends object = Record<string, unknown>>(
+      fn: () => Transaction<T>
+    ) => {
+      throttler.maybeExecute(fn as () => Transaction)
+    },
+    cleanup: () => {
+      throttler.cancel()
+    },
+  }
+}
diff --git a/packages/db/src/strategies/types.ts b/packages/db/src/strategies/types.ts
new file mode 100644
index 000000000..3514fea61
--- /dev/null
+++ b/packages/db/src/strategies/types.ts
@@ -0,0 +1,130 @@
+import type { Transaction } from "../transactions"
+
+/**
+ * Base strategy interface that all strategy implementations must conform to
+ */
+export interface BaseStrategy<TName extends string = string> {
+  /** Type discriminator for strategy identification */
+  _type: TName
+
+  /**
+   * Execute a function according to the strategy's timing rules
+   * @param fn - The function to execute
+   * @returns The result of the function execution (if applicable)
+   */
+  execute: <T extends object = Record<string, unknown>>(
+    fn: () => Transaction<T>
+  ) => void | Promise<void>
+
+  /**
+   * Clean up any resources held by the strategy
+   * Should be called when the strategy is no longer needed
+   */
+  cleanup: () => void
+}
+
+/**
+ * Options for debounce strategy
+ * Delays execution until after a period of inactivity
+ */
+export interface DebounceStrategyOptions {
+  /** Wait time in milliseconds before execution */
+  wait: number
+  /** Execute immediately on the first call */
+  leading?: boolean
+  /** Execute after the wait period on the last call */
+  trailing?: boolean
+}
+
+/**
+ * Debounce strategy that delays execution until activity stops
+ */
+export interface DebounceStrategy extends BaseStrategy<`debounce`> {
+  options: DebounceStrategyOptions
+}
+
+/**
+ * Options for queue strategy
+ * Processes all executions in order (FIFO/LIFO)
+ */
+export interface QueueStrategyOptions {
+  /** Wait time between processing queue items (milliseconds) */
+  wait?: number
+  /** Maximum queue size (items are dropped if exceeded) */
+  maxSize?: number
+  /** Where to add new items in the queue */
+  addItemsTo?: `front` | `back`
+  /** Where to get items from when processing */
+  getItemsFrom?: `front` | `back`
+}
+
+/**
+ * Queue strategy that processes all executions in order
+ * FIFO: { addItemsTo: 'back', getItemsFrom: 'front' }
+ * LIFO: { addItemsTo: 'back', getItemsFrom: 'back' }
+ */
+export interface QueueStrategy extends BaseStrategy<`queue`> {
+  options?: QueueStrategyOptions
+}
+
+/**
+ * Options for throttle strategy
+ * Ensures executions are evenly spaced over time
+ */
+export interface ThrottleStrategyOptions {
+  /** Minimum wait time between executions (milliseconds) */
+  wait: number
+  /** Execute immediately on the first call */
+  leading?: boolean
+  /** Execute on the last call after wait period */
+  trailing?: boolean
+}
+
+/**
+ * Throttle strategy that spaces executions evenly over time
+ */
+export interface ThrottleStrategy extends BaseStrategy<`throttle`> {
+  options: ThrottleStrategyOptions
+}
+
+/**
+ * Options for batch strategy
+ * Groups multiple executions together
+ */
+export interface BatchStrategyOptions {
+  /** Maximum items per batch */
+  maxSize?: number
+  /** Maximum wait time before processing batch (milliseconds) */
+  wait?: number
+  /** Custom logic to determine when to execute batch */
+  getShouldExecute?: (items: Array<any>) => boolean
+}
+
+/**
+ * Batch strategy that groups multiple executions together
+ */
+export interface BatchStrategy extends BaseStrategy<`batch`> {
+  options?: BatchStrategyOptions
+}
+
+/**
+ * Union type of all available strategies
+ */
+export type Strategy =
+  | DebounceStrategy
+  | QueueStrategy
+  | ThrottleStrategy
+  | BatchStrategy
+
+/**
+ * Extract the options type from a strategy
+ */
+export type StrategyOptions<T extends Strategy> = T extends DebounceStrategy
+  ? DebounceStrategyOptions
+  : T extends QueueStrategy
+    ? QueueStrategyOptions
+    : T extends ThrottleStrategy
+      ? ThrottleStrategyOptions
+      : T extends BatchStrategy
+        ? BatchStrategyOptions
+        : never
diff --git a/packages/react-db/src/index.ts b/packages/react-db/src/index.ts
index bb3cd3ad5..dd1729e95 100644
--- a/packages/react-db/src/index.ts
+++ b/packages/react-db/src/index.ts
@@ -1,5 +1,6 @@
 // Re-export all public APIs
 export * from "./useLiveQuery"
+export * from "./usePacedMutations"
 export * from "./useLiveInfiniteQuery"
 
 // Re-export everything from @tanstack/db
diff --git a/packages/react-db/src/usePacedMutations.ts b/packages/react-db/src/usePacedMutations.ts
new file mode 100644
index 000000000..a86e4efdc
--- /dev/null
+++ b/packages/react-db/src/usePacedMutations.ts
@@ -0,0 +1,138 @@
+import { useCallback, useMemo, useRef } from "react"
+import { createPacedMutations } from "@tanstack/db"
+import type { PacedMutationsConfig, Transaction } from "@tanstack/db"
+
+/**
+ * React hook for managing paced mutations with timing strategies.
+ *
+ * Provides optimistic mutations with pluggable strategies like debouncing,
+ * queuing, or throttling. The optimistic updates are applied immediately via
+ * `onMutate`, and the actual persistence is controlled by the strategy.
+ *
+ * @param config - Configuration including onMutate, mutationFn and strategy
+ * @returns A mutate function that accepts variables and returns Transaction objects
+ *
+ * @example
+ * ```tsx
+ * // Debounced auto-save
+ * function AutoSaveForm({ formId }: { formId: string }) {
+ *   const mutate = usePacedMutations<string>({
+ *     onMutate: (value) => {
+ *       // Apply optimistic update immediately
+ *       formCollection.update(formId, draft => {
+ *         draft.content = value
+ *       })
+ *     },
+ *     mutationFn: async ({ transaction }) => {
+ *       await api.save(transaction.mutations)
+ *     },
+ *     strategy: debounceStrategy({ wait: 500 })
+ *   })
+ *
+ *   const handleChange = async (value: string) => {
+ *     const tx = mutate(value)
+ *
+ *     // Optional: await persistence or handle errors
+ *     try {
+ *       await tx.isPersisted.promise
+ *       console.log('Saved!')
+ *     } catch (error) {
+ *       console.error('Save failed:', error)
+ *     }
+ *   }
+ *
+ *   return <textarea onChange={e => handleChange(e.target.value)} />
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Throttled slider updates
+ * function VolumeSlider() {
+ *   const mutate = usePacedMutations<number>({
+ *     onMutate: (volume) => {
+ *       settingsCollection.update('volume', draft => {
+ *         draft.value = volume
+ *       })
+ *     },
+ *     mutationFn: async ({ transaction }) => {
+ *       await api.updateVolume(transaction.mutations)
+ *     },
+ *     strategy: throttleStrategy({ wait: 200 })
+ *   })
+ *
+ *   return <input type="range" onChange={e => mutate(+e.target.value)} />
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Debounce with leading/trailing for color picker (persist first + final only)
+ * function ColorPicker() {
+ *   const mutate = usePacedMutations<string>({
+ *     onMutate: (color) => {
+ *       themeCollection.update('primary', draft => {
+ *         draft.color = color
+ *       })
+ *     },
+ *     mutationFn: async ({ transaction }) => {
+ *       await api.updateTheme(transaction.mutations)
+ *     },
+ *     strategy: debounceStrategy({ wait: 0, leading: true, trailing: true })
+ *   })
+ *
+ *   return (
+ *     <input
+ *       type="color"
+ *       onChange={e => mutate(e.target.value)}
+ *     />
+ *   )
+ * }
+ * ```
+ */
+export function usePacedMutations<
+  TVariables = unknown,
+  T extends object = Record<string, unknown>,
+>(
+  config: PacedMutationsConfig<TVariables, T>
+): (variables: TVariables) => Transaction<T> {
+  // Keep refs to the latest callbacks so we can call them without recreating the instance
+  const onMutateRef = useRef(config.onMutate)
+  onMutateRef.current = config.onMutate
+
+  const mutationFnRef = useRef(config.mutationFn)
+  mutationFnRef.current = config.mutationFn
+
+  // Create stable wrappers that always call the latest version
+  const stableOnMutate = useCallback<typeof config.onMutate>((variables) => {
+    return onMutateRef.current(variables)
+  }, [])
+
+  const stableMutationFn = useCallback<typeof config.mutationFn>((params) => {
+    return mutationFnRef.current(params)
+  }, [])
+
+  // Create paced mutations instance with proper dependency tracking
+  // Serialize strategy for stable comparison since strategy objects are recreated on each render
+  const mutate = useMemo(() => {
+    return createPacedMutations<TVariables, T>({
+      ...config,
+      onMutate: stableOnMutate,
+      mutationFn: stableMutationFn,
+    })
+  }, [
+    stableOnMutate,
+    stableMutationFn,
+    config.metadata,
+    // Serialize strategy to avoid recreating when object reference changes but values are same
+    JSON.stringify({
+      type: config.strategy._type,
+      options: config.strategy.options,
+    }),
+  ])
+
+  // Return stable mutate callback
+  const stableMutate = useCallback(mutate, [mutate])
+
+  return stableMutate
+}
diff --git a/packages/react-db/tests/usePacedMutations.test.tsx b/packages/react-db/tests/usePacedMutations.test.tsx
new file mode 100644
index 000000000..61d1643e4
--- /dev/null
+++ b/packages/react-db/tests/usePacedMutations.test.tsx
@@ -0,0 +1,472 @@
+import { describe, expect, it, vi } from "vitest"
+import { act, renderHook } from "@testing-library/react"
+import {
+  createCollection,
+  debounceStrategy,
+  queueStrategy,
+  throttleStrategy,
+} from "@tanstack/db"
+import { usePacedMutations } from "../src/usePacedMutations"
+import { mockSyncCollectionOptionsNoInitialState } from "../../db/tests/utils"
+
+type Item = {
+  id: number
+  value: number
+}
+
+describe(`usePacedMutations with debounce strategy`, () => {
+  it(`should batch multiple rapid mutations into a single transaction`, async () => {
+    const mutationFn = vi.fn(async () => {})
+
+    const collection = createCollection(
+      mockSyncCollectionOptionsNoInitialState<Item>({
+        id: `test`,
+        getKey: (item) => item.id,
+      })
+    )
+
+    // Setup collection
+    const preloadPromise = collection.preload()
+    collection.utils.begin()
+    collection.utils.commit()
+    collection.utils.markReady()
+    await preloadPromise
+
+    let insertCount = 0
+    const { result } = renderHook(() =>
+      usePacedMutations<{ id: number; value: number }>({
+        onMutate: (item) => {
+          if (insertCount === 0) {
+            collection.insert(item)
+            insertCount++
+          } else {
+            collection.update(item.id, (draft) => {
+              draft.value = item.value
+            })
+          }
+        },
+        mutationFn,
+        strategy: debounceStrategy({ wait: 50 }),
+      })
+    )
+
+    let tx1, tx2, tx3
+
+    // Trigger three rapid mutations (all within 50ms debounce window)
+    act(() => {
+      tx1 = result.current({ id: 1, value: 1 })
+    })
+
+    act(() => {
+      tx2 = result.current({ id: 1, value: 2 })
+    })
+
+    act(() => {
+      tx3 = result.current({ id: 1, value: 3 })
+    })
+
+    // All three calls should return the SAME transaction object
+    expect(tx1).toBe(tx2)
+    expect(tx2).toBe(tx3)
+
+    // Mutations get auto-merged (insert + updates on same key = single insert with final value)
+    expect(tx1!.mutations).toHaveLength(1)
+    expect(tx1!.mutations[0]).toMatchObject({
+      type: `insert`,
+      changes: { id: 1, value: 3 }, // Final merged value
+    })
+
+    // mutationFn should NOT have been called yet (still debouncing)
+    expect(mutationFn).not.toHaveBeenCalled()
+
+    // Wait for debounce period
+    await new Promise((resolve) => setTimeout(resolve, 100))
+
+    // Now mutationFn should have been called ONCE with the merged mutation
+    expect(mutationFn).toHaveBeenCalledTimes(1)
+    expect(mutationFn).toHaveBeenCalledWith({
+      transaction: expect.objectContaining({
+        mutations: [
+          expect.objectContaining({
+            type: `insert`,
+            changes: { id: 1, value: 3 },
+          }),
+        ],
+      }),
+    })
+
+    // Transaction should be completed
+    expect(tx1!.state).toBe(`completed`)
+  })
+
+  it(`should reset debounce timer on each new mutation`, async () => {
+    const mutationFn = vi.fn(async () => {})
+
+    const collection = createCollection(
+      mockSyncCollectionOptionsNoInitialState<Item>({
+        id: `test`,
+        getKey: (item) => item.id,
+      })
+    )
+
+    const preloadPromise = collection.preload()
+    collection.utils.begin()
+    collection.utils.commit()
+    collection.utils.markReady()
+    await preloadPromise
+
+    let insertCount = 0
+    const { result } = renderHook(() =>
+      usePacedMutations<{ id: number; value: number }>({
+        onMutate: (item) => {
+          if (insertCount === 0) {
+            collection.insert(item)
+            insertCount++
+          } else {
+            collection.update(item.id, (draft) => {
+              draft.value = item.value
+            })
+          }
+        },
+        mutationFn,
+        strategy: debounceStrategy({ wait: 50 }),
+      })
+    )
+
+    // First mutation at t=0
+    act(() => {
+      result.current({ id: 1, value: 1 })
+    })
+
+    // Wait 40ms (still within 50ms debounce window)
+    await new Promise((resolve) => setTimeout(resolve, 40))
+
+    // mutationFn should NOT have been called yet
+    expect(mutationFn).not.toHaveBeenCalled()
+
+    // Second mutation at t=40 (resets the timer)
+    act(() => {
+      result.current({ id: 1, value: 2 })
+    })
+
+    // Wait another 40ms (t=80, but only 40ms since last mutation)
+    await new Promise((resolve) => setTimeout(resolve, 40))
+
+    // mutationFn still should NOT have been called (timer was reset)
+    expect(mutationFn).not.toHaveBeenCalled()
+
+    // Wait another 20ms (t=100, now 60ms since last mutation, past the 50ms debounce)
+    await new Promise((resolve) => setTimeout(resolve, 20))
+
+    // NOW mutationFn should have been called
+    expect(mutationFn).toHaveBeenCalledTimes(1)
+    const firstCall = mutationFn.mock.calls[0] as unknown as [
+      { transaction: { mutations: Array<unknown> } },
+    ]
+    expect(firstCall[0].transaction.mutations).toHaveLength(1) // Merged to 1 mutation
+  })
+})
+
+describe(`usePacedMutations with queue strategy`, () => {
+  it(`should accumulate mutations then process sequentially`, async () => {
+    const mutationFn = vi.fn(async () => {
+      // Quick execution
+      await new Promise((resolve) => setTimeout(resolve, 5))
+    })
+
+    const collection = createCollection(
+      mockSyncCollectionOptionsNoInitialState<Item>({
+        id: `test`,
+        getKey: (item) => item.id,
+      })
+    )
+
+    // Setup collection
+    const preloadPromise = collection.preload()
+    collection.utils.begin()
+    collection.utils.commit()
+    collection.utils.markReady()
+    await preloadPromise
+
+    const { result } = renderHook(() =>
+      usePacedMutations<Item>({
+        onMutate: (item) => {
+          collection.insert(item)
+        },
+        mutationFn,
+        strategy: queueStrategy({ wait: 10 }),
+      })
+    )
+
+    let tx1
+
+    // Trigger rapid mutations - queue creates separate transactions
+    act(() => {
+      tx1 = result.current({ id: 1, value: 1 })
+    })
+    act(() => {
+      result.current({ id: 2, value: 2 })
+    })
+    act(() => {
+      result.current({ id: 3, value: 3 })
+    })
+
+    // Queue starts processing immediately
+    await new Promise((resolve) => setTimeout(resolve, 5))
+    expect(mutationFn).toHaveBeenCalledTimes(1)
+
+    // Wait for transaction to complete
+    await tx1!.isPersisted.promise
+    expect(tx1!.state).toBe(`completed`)
+
+    // Each mutation should be in its own transaction
+    expect(tx1!.mutations).toHaveLength(1)
+  })
+})
+
+describe(`usePacedMutations with throttle strategy`, () => {
+  it(`should throttle mutations with leading and trailing execution`, async () => {
+    const mutationFn = vi.fn(async () => {})
+
+    const collection = createCollection(
+      mockSyncCollectionOptionsNoInitialState<Item>({
+        id: `test`,
+        getKey: (item) => item.id,
+      })
+    )
+
+    // Setup collection
+    const preloadPromise = collection.preload()
+    collection.utils.begin()
+    collection.utils.commit()
+    collection.utils.markReady()
+    await preloadPromise
+
+    const { result } = renderHook(() =>
+      usePacedMutations<Item>({
+        onMutate: (item) => {
+          collection.insert(item)
+        },
+        mutationFn,
+        strategy: throttleStrategy({
+          wait: 100,
+          leading: true,
+          trailing: true,
+        }),
+      })
+    )
+
+    let tx1, tx2, tx3
+
+    // First mutation at t=0 (should execute immediately due to leading: true)
+    act(() => {
+      tx1 = result.current({ id: 1, value: 1 })
+    })
+
+    // Leading edge should execute immediately
+    await new Promise((resolve) => setTimeout(resolve, 10))
+    expect(mutationFn).toHaveBeenCalledTimes(1)
+    expect(tx1!.state).toBe(`completed`)
+
+    // Second mutation at t=20 (during throttle period, should batch)
+    act(() => {
+      tx2 = result.current({ id: 2, value: 2 })
+    })
+
+    // Third mutation at t=30 (during throttle period, should batch with second)
+    await new Promise((resolve) => setTimeout(resolve, 10))
+    act(() => {
+      tx3 = result.current({ id: 3, value: 3 })
+    })
+
+    // tx2 and tx3 should be the same transaction (batched)
+    expect(tx2).toBe(tx3)
+
+    // Still only 1 call (waiting for throttle period to end)
+    expect(mutationFn).toHaveBeenCalledTimes(1)
+
+    // Wait for throttle period to complete (100ms from first mutation)
+    await new Promise((resolve) => setTimeout(resolve, 110))
+
+    // Trailing edge should have executed
+    expect(mutationFn).toHaveBeenCalledTimes(2)
+    expect(tx2!.state).toBe(`completed`)
+    expect(tx3!.state).toBe(`completed`)
+
+    // Verify the batched transaction has 2 inserts
+    expect(tx2!.mutations).toHaveLength(2)
+  })
+
+  it(`should respect trailing: true with leading: false option`, async () => {
+    const mutationFn = vi.fn(async () => {})
+
+    const collection = createCollection(
+      mockSyncCollectionOptionsNoInitialState<Item>({
+        id: `test`,
+        getKey: (item) => item.id,
+      })
+    )
+
+    const preloadPromise = collection.preload()
+    collection.utils.begin()
+    collection.utils.commit()
+    collection.utils.markReady()
+    await preloadPromise
+
+    const { result } = renderHook(() =>
+      usePacedMutations<Item>({
+        onMutate: (item) => {
+          collection.insert(item)
+        },
+        mutationFn,
+        strategy: throttleStrategy({
+          wait: 50,
+          leading: false,
+          trailing: true,
+        }),
+      })
+    )
+
+    let tx1
+
+    // First mutation should NOT execute immediately with leading: false
+    act(() => {
+      tx1 = result.current({ id: 1, value: 1 })
+    })
+
+    // Should not have been called yet
+    await new Promise((resolve) => setTimeout(resolve, 10))
+    expect(mutationFn).not.toHaveBeenCalled()
+
+    // Add another mutation during throttle period to ensure trailing fires
+    act(() => {
+      result.current({ id: 2, value: 2 })
+    })
+
+    // Wait for throttle period to complete
+    await new Promise((resolve) => setTimeout(resolve, 70))
+
+    // Now trailing edge should have executed
+    expect(mutationFn).toHaveBeenCalledTimes(1)
+    await tx1!.isPersisted.promise
+    expect(tx1!.state).toBe(`completed`)
+  })
+})
+
+describe(`usePacedMutations memoization`, () => {
+  it(`should not recreate instance when strategy object changes but values are same`, () => {
+    const mutationFn = vi.fn(async () => {})
+    const onMutate = vi.fn(() => {})
+
+    // Simulate a custom hook that creates strategy inline on each render
+    const useCustomHook = (wait: number) => {
+      return usePacedMutations({
+        onMutate,
+        mutationFn,
+        // Strategy is created inline on every render - new object reference each time
+        strategy: debounceStrategy({ wait }),
+      })
+    }
+
+    const { result, rerender } = renderHook(({ wait }) => useCustomHook(wait), {
+      initialProps: { wait: 3000 },
+    })
+
+    const firstMutate = result.current
+
+    // Rerender with same wait value - strategy object will be different reference
+    rerender({ wait: 3000 })
+    const secondMutate = result.current
+
+    // mutate function should be stable (same reference)
+    expect(secondMutate).toBe(firstMutate)
+
+    // Rerender with different wait value - should create new instance
+    rerender({ wait: 5000 })
+    const thirdMutate = result.current
+
+    // mutate function should be different now
+    expect(thirdMutate).not.toBe(firstMutate)
+  })
+
+  it(`should not recreate instance when wrapped in custom hook with inline strategy`, () => {
+    const mutationFn = vi.fn(async () => {})
+    const onMutate = vi.fn(() => {})
+
+    // Simulate the exact user scenario: custom hook wrapping usePacedMutations
+    const useDebouncedTransaction = (opts?: {
+      wait?: number
+      trailing?: boolean
+      leading?: boolean
+    }) => {
+      return usePacedMutations({
+        onMutate,
+        mutationFn,
+        strategy: debounceStrategy({
+          wait: opts?.wait ?? 3000,
+          trailing: opts?.trailing ?? true,
+          leading: opts?.leading ?? false,
+        }),
+      })
+    }
+
+    const { result, rerender } = renderHook(() => useDebouncedTransaction())
+
+    const firstMutate = result.current
+
+    // Multiple rerenders with no options - should not recreate instance
+    rerender()
+    expect(result.current).toBe(firstMutate)
+
+    rerender()
+    expect(result.current).toBe(firstMutate)
+
+    rerender()
+    expect(result.current).toBe(firstMutate)
+
+    // All should still be the same mutate function
+    expect(result.current).toBe(firstMutate)
+  })
+
+  it(`should recreate instance when strategy options actually change`, () => {
+    const mutationFn = vi.fn(async () => {})
+    const onMutate = vi.fn(() => {})
+
+    const useDebouncedTransaction = (opts?: {
+      wait?: number
+      trailing?: boolean
+      leading?: boolean
+    }) => {
+      return usePacedMutations({
+        onMutate,
+        mutationFn,
+        strategy: debounceStrategy({
+          wait: opts?.wait ?? 3000,
+          trailing: opts?.trailing ?? true,
+          leading: opts?.leading ?? false,
+        }),
+      })
+    }
+
+    const { result, rerender } = renderHook(
+      ({ opts }) => useDebouncedTransaction(opts),
+      { initialProps: { opts: { wait: 3000 } } }
+    )
+
+    const firstMutate = result.current
+
+    // Rerender with different wait value
+    rerender({ opts: { wait: 5000 } })
+    const secondMutate = result.current
+
+    // Should be different instance since wait changed
+    expect(secondMutate).not.toBe(firstMutate)
+
+    // Rerender with same wait value again
+    rerender({ opts: { wait: 5000 } })
+    const thirdMutate = result.current
+
+    // Should be same as second since value didn't change
+    expect(thirdMutate).toBe(secondMutate)
+  })
+})
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index c00207ff1..a2608e353 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -187,6 +187,40 @@ importers:
         specifier: ~5.8.2
         version: 5.8.3
 
+  examples/react/paced-mutations-demo:
+    dependencies:
+      '@tanstack/db':
+        specifier: workspace:*
+        version: link:../../../packages/db
+      '@tanstack/react-db':
+        specifier: workspace:*
+        version: link:../../../packages/react-db
+      mitt:
+        specifier: ^3.0.1
+        version: 3.0.1
+      react:
+        specifier: ^18.3.1
+        version: 18.3.1
+      react-dom:
+        specifier: ^18.3.1
+        version: 18.3.1(react@18.3.1)
+    devDependencies:
+      '@types/react':
+        specifier: ^18.3.12
+        version: 18.3.26
+      '@types/react-dom':
+        specifier: ^18.3.1
+        version: 18.3.7(@types/react@18.3.26)
+      '@vitejs/plugin-react':
+        specifier: ^4.3.4
+        version: 4.7.0(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+      typescript:
+        specifier: ^5.7.2
+        version: 5.9.3
+      vite:
+        specifier: ^6.0.3
+        version: 6.4.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
+
   examples/react/projects:
     dependencies:
       '@tailwindcss/vite':
@@ -285,7 +319,7 @@ importers:
         version: 8.46.2(eslint@9.38.0(jiti@2.6.1))(typescript@5.9.3)
       '@vitejs/plugin-react':
         specifier: ^5.0.4
-        version: 5.1.0(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        version: 5.0.4(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
       concurrently:
         specifier: ^9.2.1
         version: 9.2.1
@@ -415,7 +449,7 @@ importers:
         version: 8.46.2(eslint@9.38.0(jiti@2.6.1))(typescript@5.9.3)
       '@vitejs/plugin-react':
         specifier: ^5.0.3
-        version: 5.1.0(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        version: 5.0.4(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
       concurrently:
         specifier: ^9.2.1
         version: 9.2.1
@@ -478,7 +512,7 @@ importers:
         version: 0.44.7(@types/pg@8.15.5)(gel@2.1.1)(kysely@0.28.5)(pg@8.16.3)(postgres@3.4.7)
       drizzle-zod:
         specifier: ^0.8.3
-        version: 0.8.3(drizzle-orm@0.44.7(@types/pg@8.15.5)(gel@2.1.1)(kysely@0.28.5)(pg@8.16.3)(postgres@3.4.7))(zod@3.25.76)
+        version: 0.8.3(drizzle-orm@0.44.7(@types/pg@8.15.5)(gel@2.1.1)(kysely@0.28.5)(pg@8.16.3)(postgres@3.4.7))(zod@4.1.11)
       express:
         specifier: ^4.21.2
         version: 4.21.2
@@ -592,6 +626,9 @@ importers:
       '@tanstack/db-ivm':
         specifier: workspace:*
         version: link:../db-ivm
+      '@tanstack/pacer':
+        specifier: ^0.1.0
+        version: 0.1.0
       typescript:
         specifier: '>=4.7'
         version: 5.9.3
@@ -2840,9 +2877,15 @@ packages:
     resolution: {integrity: sha512-S+9ANAvUmjutrshV4jZjaiG8XQyuJIZ8a4utWmN/vW1sgQ9IfBnPndwkmQYw53QmouOIytT874u65HEmu6H5jw==}
     engines: {node: '>=18'}
 
+  '@rolldown/pluginutils@1.0.0-beta.27':
+    resolution: {integrity: sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA==}
+
   '@rolldown/pluginutils@1.0.0-beta.29':
     resolution: {integrity: sha512-NIJgOsMjbxAXvoGq/X0gD7VPMQ8j9g0BiDaNjVNVjvl+iKXxL3Jre0v31RmBYeLEmkbj2s02v8vFTbUXi5XS2Q==}
 
+  '@rolldown/pluginutils@1.0.0-beta.38':
+    resolution: {integrity: sha512-N/ICGKleNhA5nc9XXQG/kkKHJ7S55u0x0XUJbbkmdCnFuoRkM1Il12q9q0eX19+M7KKUEPw/daUPIRnxhcxAIw==}
+
   '@rolldown/pluginutils@1.0.0-beta.40':
     resolution: {integrity: sha512-s3GeJKSQOwBlzdUrj4ISjJj5SfSh+aqn0wjOar4Bx95iV1ETI7F6S/5hLcfAxZ9kXDcyrAkxPlqmd1ZITttf+w==}
 
@@ -3402,6 +3445,10 @@ packages:
     resolution: {integrity: sha512-B7+x7eP2FFvi3fgd3rNH9o/Eixt+pp0zCIdGhnQbAJjFrlwIKGjGnwyJjhWJ5fMQlGks/E2LdDTqEV4W9Plx7g==}
     engines: {node: '>=12'}
 
+  '@tanstack/pacer@0.1.0':
+    resolution: {integrity: sha512-QVzkGO5clvGj/qdX8H2wUj0QCXCLZ/pwPMnfSqhoYfpzDRkRHDj+3D+VzdcehBIVnE+GCd1D/P1tGMzfjmfrzQ==}
+    engines: {node: '>=18'}
+
   '@tanstack/publish-config@0.2.1':
     resolution: {integrity: sha512-URVXmXwlZXL75AFyvyOORef1tv2f16dEaFntwLYnBHoKLQMxyWYRzQrnXooxO1xf+GidJuDSZSC6Rc9UX1aK7g==}
     engines: {node: '>=18'}
@@ -3729,17 +3776,28 @@ packages:
   '@types/pg@8.15.5':
     resolution: {integrity: sha512-LF7lF6zWEKxuT3/OR8wAZGzkg4ENGXFNyiV/JeOt9z5B+0ZVwbql9McqX5c/WStFq1GaGso7H1AzP/qSzmlCKQ==}
 
+  '@types/prop-types@15.7.15':
+    resolution: {integrity: sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw==}
+
   '@types/qs@6.14.0':
     resolution: {integrity: sha512-eOunJqu0K1923aExK6y8p6fsihYEn/BYuQ4g0CxAAgFc4b/ZLN4CrsRZ55srTdqoiLzU2B2evC+apEIxprEzkQ==}
 
   '@types/range-parser@1.2.7':
     resolution: {integrity: sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==}
 
+  '@types/react-dom@18.3.7':
+    resolution: {integrity: sha512-MEe3UeoENYVFXzoXEWsvcpg6ZvlrFNlOQ7EOsvhI3CfAXwzPfO8Qwuxd40nepsYKqyyVQnTdEfv68q91yLcKrQ==}
+    peerDependencies:
+      '@types/react': ^18.0.0
+
   '@types/react-dom@19.2.2':
     resolution: {integrity: sha512-9KQPoO6mZCi7jcIStSnlOWn2nEF3mNmyr3rIAsGnAbQKYbRLyqmeSc39EVgtxXVia+LMT8j3knZLAZAh+xLmrw==}
     peerDependencies:
       '@types/react': ^19.2.0
 
+  '@types/react@18.3.26':
+    resolution: {integrity: sha512-RFA/bURkcKzx/X9oumPG9Vp3D3JUgus/d0b67KB0t5S/raciymilkOa66olh78MUI92QLbEJevO7rvqU/kjwKA==}
+
   '@types/react@19.2.2':
     resolution: {integrity: sha512-6mDvHUFSjyT2B2yeNx2nUgMxh9LtOWvkhIU3uePn2I2oyNymUAX1NIsdgviM4CH+JSrp2D2hsMvJOkxY+0wNRA==}
 
@@ -3803,6 +3861,12 @@ packages:
     peerDependencies:
       typescript: '>=4.8.4 <6.0.0'
 
+  '@typescript-eslint/project-service@8.46.1':
+    resolution: {integrity: sha512-FOIaFVMHzRskXr5J4Jp8lFVV0gz5ngv3RHmn+E4HYxSJ3DgDzU7fVI1/M7Ijh1zf6S7HIoaIOtln1H5y8V+9Zg==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      typescript: '>=4.8.4 <6.0.0'
+
   '@typescript-eslint/project-service@8.46.2':
     resolution: {integrity: sha512-PULOLZ9iqwI7hXcmL4fVfIsBi6AN9YxRc0frbvmg8f+4hQAjQ5GYNKK0DIArNo+rOKmR/iBYwkpBmnIwin4wBg==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
@@ -3813,6 +3877,10 @@ packages:
     resolution: {integrity: sha512-NdhWHgmynpSvyhchGLXh+w12OMT308Gm25JoRIyTZqEbApiBiQHD/8xgb6LqCWCFcxFtWwaVdFsLPQI3jvhywg==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
+  '@typescript-eslint/scope-manager@8.46.1':
+    resolution: {integrity: sha512-weL9Gg3/5F0pVQKiF8eOXFZp8emqWzZsOJuWRUNtHT+UNV2xSJegmpCNQHy37aEQIbToTq7RHKhWvOsmbM680A==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
   '@typescript-eslint/scope-manager@8.46.2':
     resolution: {integrity: sha512-LF4b/NmGvdWEHD2H4MsHD8ny6JpiVNDzrSZr3CsckEgCbAGZbYM4Cqxvi9L+WqDMT+51Ozy7lt2M+d0JLEuBqA==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
@@ -3823,6 +3891,12 @@ packages:
     peerDependencies:
       typescript: '>=4.8.4 <6.0.0'
 
+  '@typescript-eslint/tsconfig-utils@8.46.1':
+    resolution: {integrity: sha512-X88+J/CwFvlJB+mK09VFqx5FE4H5cXD+H/Bdza2aEWkSb8hnWIQorNcscRl4IEo1Cz9VI/+/r/jnGWkbWPx54g==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      typescript: '>=4.8.4 <6.0.0'
+
   '@typescript-eslint/tsconfig-utils@8.46.2':
     resolution: {integrity: sha512-a7QH6fw4S57+F5y2FIxxSDyi5M4UfGF+Jl1bCGd7+L4KsaUY80GsiF/t0UoRFDHAguKlBaACWJRmdrc6Xfkkag==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
@@ -3847,6 +3921,10 @@ packages:
     resolution: {integrity: sha512-Lk7uj7y9uQUOEguiDIDLYLJOrYHQa7oBiURYVFqIpGxclAFQ78f6VUOM8lI2XEuNOKNB7XuvM2+2cMXAoq4ALQ==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
+  '@typescript-eslint/types@8.46.1':
+    resolution: {integrity: sha512-C+soprGBHwWBdkDpbaRC4paGBrkIXxVlNohadL5o0kfhsXqOC6GYH2S/Obmig+I0HTDl8wMaRySwrfrXVP8/pQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
   '@typescript-eslint/types@8.46.2':
     resolution: {integrity: sha512-lNCWCbq7rpg7qDsQrd3D6NyWYu+gkTENkG5IKYhUIcxSb59SQC/hEQ+MrG4sTgBVghTonNWq42bA/d4yYumldQ==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
@@ -3857,6 +3935,12 @@ packages:
     peerDependencies:
       typescript: '>=4.8.4 <6.0.0'
 
+  '@typescript-eslint/typescript-estree@8.46.1':
+    resolution: {integrity: sha512-uIifjT4s8cQKFQ8ZBXXyoUODtRoAd7F7+G8MKmtzj17+1UbdzFl52AzRyZRyKqPHhgzvXunnSckVu36flGy8cg==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      typescript: '>=4.8.4 <6.0.0'
+
   '@typescript-eslint/typescript-estree@8.46.2':
     resolution: {integrity: sha512-f7rW7LJ2b7Uh2EiQ+7sza6RDZnajbNbemn54Ob6fRwQbgcIn+GWfyuHDHRYgRoZu1P4AayVScrRW+YfbTvPQoQ==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
@@ -3870,6 +3954,13 @@ packages:
       eslint: ^8.57.0 || ^9.0.0
       typescript: '>=4.8.4 <6.0.0'
 
+  '@typescript-eslint/utils@8.46.1':
+    resolution: {integrity: sha512-vkYUy6LdZS7q1v/Gxb2Zs7zziuXN0wxqsetJdeZdRe/f5dwJFglmuvZBfTUivCtjH725C1jWCDfpadadD95EDQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      eslint: ^8.57.0 || ^9.0.0
+      typescript: '>=4.8.4 <6.0.0'
+
   '@typescript-eslint/utils@8.46.2':
     resolution: {integrity: sha512-sExxzucx0Tud5tE0XqR0lT0psBQvEpnpiul9XbGUB1QwpWJJAps1O/Z7hJxLGiZLBKMCutjTzDgmd1muEhBnVg==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
@@ -3881,6 +3972,10 @@ packages:
     resolution: {integrity: sha512-576+u0QD+Jp3tZzvfRfxon0EA2lzcDt3lhUbsC6Lgzy9x2VR4E+JUiNyGHi5T8vk0TV+fpJ5GLG1JsJuWCaKhw==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
+  '@typescript-eslint/visitor-keys@8.46.1':
+    resolution: {integrity: sha512-ptkmIf2iDkNUjdeu2bQqhFPV1m6qTnFFjg7PPDjxKWaMaP0Z6I9l30Jr3g5QqbZGdw8YdYvLp+XnqnWWZOg/NA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
   '@typescript-eslint/visitor-keys@8.46.2':
     resolution: {integrity: sha512-tUFMXI4gxzzMXt4xpGJEsBsTox0XbNQ1y94EwlD/CuZwFcQP79xfQqMhau9HsRc/J0cAPA/HZt1dZPtGn9V/7w==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
@@ -3989,6 +4084,18 @@ packages:
     peerDependencies:
       vite: ^6.0.0 || ^7.0.0
 
+  '@vitejs/plugin-react@4.7.0':
+    resolution: {integrity: sha512-gUu9hwfWvvEDBBmgtAowQCojwZmJ5mcLn3aufeCsitijs3+f2NsrPtlAWIR6OPiqljl96GVCUbLe0HyqIpVaoA==}
+    engines: {node: ^14.18.0 || >=16.0.0}
+    peerDependencies:
+      vite: ^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0
+
+  '@vitejs/plugin-react@5.0.4':
+    resolution: {integrity: sha512-La0KD0vGkVkSk6K+piWDKRUyg8Rl5iAIKRMH0vMJI0Eg47bq1eOxmoObAaQG37WMW9MSyk7Cs8EIWwJC1PtzKA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    peerDependencies:
+      vite: ^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0
+
   '@vitejs/plugin-react@5.1.0':
     resolution: {integrity: sha512-4LuWrg7EKWgQaMJfnN+wcmbAW+VSsCmqGohftWjuct47bv8uE4n/nPpq4XjJPsxgq00GGG5J8dvBczp8uxScew==}
     engines: {node: ^20.19.0 || >=22.12.0}
@@ -6017,6 +6124,10 @@ packages:
     resolution: {integrity: sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==}
     hasBin: true
 
+  jiti@2.6.0:
+    resolution: {integrity: sha512-VXe6RjJkBPj0ohtqaO8vSWP3ZhAKo66fKrFNCll4BTcwljPLz03pCbaNKfzGP5MbrCYcbJ7v0nOYYwUzTEIdXQ==}
+    hasBin: true
+
   jiti@2.6.1:
     resolution: {integrity: sha512-ekilCSN1jwRvIbgeg/57YFh8qQDNbwDb9xT/qu2DAHbFFZUicIl4ygVaAvzveMhMVr3LnpSKTNnwt8PoOfmKhQ==}
     hasBin: true
@@ -7169,6 +7280,11 @@ packages:
     resolution: {integrity: sha512-9G8cA+tuMS75+6G/TzW8OtLzmBDMo8p1JRxN5AZ+LAp8uxGA8V8GZm4GQ4/N5QNQEnLmg6SS7wyuSmbKepiKqA==}
     engines: {node: '>= 0.10'}
 
+  react-dom@18.3.1:
+    resolution: {integrity: sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==}
+    peerDependencies:
+      react: ^18.3.1
+
   react-dom@19.2.0:
     resolution: {integrity: sha512-UlbRu4cAiGaIewkPyiRGJk0imDN2T3JjieT6spoL2UeSf5od4n5LB/mQ4ejmxhCFT1tYe8IvaFulzynWovsEFQ==}
     peerDependencies:
@@ -7180,10 +7296,18 @@ packages:
   react-is@17.0.2:
     resolution: {integrity: sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==}
 
+  react-refresh@0.17.0:
+    resolution: {integrity: sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==}
+    engines: {node: '>=0.10.0'}
+
   react-refresh@0.18.0:
     resolution: {integrity: sha512-QgT5//D3jfjJb6Gsjxv0Slpj23ip+HtOpnNgnb2S5zU3CB26G/IDPGoy4RJB42wzFE46DRsstbW6tKHoKbhAxw==}
     engines: {node: '>=0.10.0'}
 
+  react@18.3.1:
+    resolution: {integrity: sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==}
+    engines: {node: '>=0.10.0'}
+
   react@19.2.0:
     resolution: {integrity: sha512-tmbWg6W31tQLeB5cdIBOicJDJRR2KzXsV7uSK9iNfLWQ5bIZfxuPEHp7M8wiHyHnn0DD1i7w3Zmin0FtkrwoCQ==}
     engines: {node: '>=0.10.0'}
@@ -7358,6 +7482,9 @@ packages:
     resolution: {integrity: sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==}
     engines: {node: '>=v12.22.7'}
 
+  scheduler@0.23.2:
+    resolution: {integrity: sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==}
+
   scheduler@0.27.0:
     resolution: {integrity: sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==}
 
@@ -10660,8 +10787,12 @@ snapshots:
 
   '@publint/pack@0.1.2': {}
 
+  '@rolldown/pluginutils@1.0.0-beta.27': {}
+
   '@rolldown/pluginutils@1.0.0-beta.29': {}
 
+  '@rolldown/pluginutils@1.0.0-beta.38': {}
+
   '@rolldown/pluginutils@1.0.0-beta.40': {}
 
   '@rolldown/pluginutils@1.0.0-beta.43': {}
@@ -11036,7 +11167,7 @@ snapshots:
 
   '@stylistic/eslint-plugin@4.4.1(eslint@9.38.0(jiti@2.6.1))(typescript@5.9.3)':
     dependencies:
-      '@typescript-eslint/utils': 8.46.2(eslint@9.38.0(jiti@2.6.1))(typescript@5.9.3)
+      '@typescript-eslint/utils': 8.46.1(eslint@9.38.0(jiti@2.6.1))(typescript@5.9.3)
       eslint: 9.38.0(jiti@2.6.1)
       eslint-visitor-keys: 4.2.1
       espree: 10.4.0
@@ -11049,7 +11180,7 @@ snapshots:
   '@stylistic/eslint-plugin@5.4.0(eslint@9.38.0(jiti@2.6.1))':
     dependencies:
       '@eslint-community/eslint-utils': 4.9.0(eslint@9.38.0(jiti@2.6.1))
-      '@typescript-eslint/types': 8.46.2
+      '@typescript-eslint/types': 8.46.1
       eslint: 9.38.0(jiti@2.6.1)
       eslint-visitor-keys: 4.2.1
       espree: 10.4.0
@@ -11236,6 +11367,8 @@ snapshots:
 
   '@tanstack/history@1.133.28': {}
 
+  '@tanstack/pacer@0.1.0': {}
+
   '@tanstack/publish-config@0.2.1':
     dependencies:
       '@commitlint/parse': 19.8.1
@@ -11828,14 +11961,25 @@ snapshots:
       pg-protocol: 1.10.3
       pg-types: 2.2.0
 
+  '@types/prop-types@15.7.15': {}
+
   '@types/qs@6.14.0': {}
 
   '@types/range-parser@1.2.7': {}
 
+  '@types/react-dom@18.3.7(@types/react@18.3.26)':
+    dependencies:
+      '@types/react': 18.3.26
+
   '@types/react-dom@19.2.2(@types/react@19.2.2)':
     dependencies:
       '@types/react': 19.2.2
 
+  '@types/react@18.3.26':
+    dependencies:
+      '@types/prop-types': 15.7.15
+      csstype: 3.1.3
+
   '@types/react@19.2.2':
     dependencies:
       csstype: 3.1.3
@@ -11929,8 +12073,17 @@ snapshots:
 
   '@typescript-eslint/project-service@8.44.1(typescript@5.9.3)':
     dependencies:
-      '@typescript-eslint/tsconfig-utils': 8.46.2(typescript@5.9.3)
-      '@typescript-eslint/types': 8.46.2
+      '@typescript-eslint/tsconfig-utils': 8.46.1(typescript@5.9.3)
+      '@typescript-eslint/types': 8.46.1
+      debug: 4.4.3
+      typescript: 5.9.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/project-service@8.46.1(typescript@5.9.3)':
+    dependencies:
+      '@typescript-eslint/tsconfig-utils': 8.46.1(typescript@5.9.3)
+      '@typescript-eslint/types': 8.46.1
       debug: 4.4.3
       typescript: 5.9.3
     transitivePeerDependencies:
@@ -11950,6 +12103,11 @@ snapshots:
       '@typescript-eslint/types': 8.44.1
       '@typescript-eslint/visitor-keys': 8.44.1
 
+  '@typescript-eslint/scope-manager@8.46.1':
+    dependencies:
+      '@typescript-eslint/types': 8.46.1
+      '@typescript-eslint/visitor-keys': 8.46.1
+
   '@typescript-eslint/scope-manager@8.46.2':
     dependencies:
       '@typescript-eslint/types': 8.46.2
@@ -11959,6 +12117,10 @@ snapshots:
     dependencies:
       typescript: 5.9.3
 
+  '@typescript-eslint/tsconfig-utils@8.46.1(typescript@5.9.3)':
+    dependencies:
+      typescript: 5.9.3
+
   '@typescript-eslint/tsconfig-utils@8.46.2(typescript@5.9.3)':
     dependencies:
       typescript: 5.9.3
@@ -11989,6 +12151,8 @@ snapshots:
 
   '@typescript-eslint/types@8.44.1': {}
 
+  '@typescript-eslint/types@8.46.1': {}
+
   '@typescript-eslint/types@8.46.2': {}
 
   '@typescript-eslint/typescript-estree@8.44.1(typescript@5.9.3)':
@@ -12007,6 +12171,22 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  '@typescript-eslint/typescript-estree@8.46.1(typescript@5.9.3)':
+    dependencies:
+      '@typescript-eslint/project-service': 8.46.1(typescript@5.9.3)
+      '@typescript-eslint/tsconfig-utils': 8.46.1(typescript@5.9.3)
+      '@typescript-eslint/types': 8.46.1
+      '@typescript-eslint/visitor-keys': 8.46.1
+      debug: 4.4.3
+      fast-glob: 3.3.3
+      is-glob: 4.0.3
+      minimatch: 9.0.5
+      semver: 7.7.3
+      ts-api-utils: 2.1.0(typescript@5.9.3)
+      typescript: 5.9.3
+    transitivePeerDependencies:
+      - supports-color
+
   '@typescript-eslint/typescript-estree@8.46.2(typescript@5.9.3)':
     dependencies:
       '@typescript-eslint/project-service': 8.46.2(typescript@5.9.3)
@@ -12034,6 +12214,17 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  '@typescript-eslint/utils@8.46.1(eslint@9.38.0(jiti@2.6.1))(typescript@5.9.3)':
+    dependencies:
+      '@eslint-community/eslint-utils': 4.9.0(eslint@9.38.0(jiti@2.6.1))
+      '@typescript-eslint/scope-manager': 8.46.1
+      '@typescript-eslint/types': 8.46.1
+      '@typescript-eslint/typescript-estree': 8.46.1(typescript@5.9.3)
+      eslint: 9.38.0(jiti@2.6.1)
+      typescript: 5.9.3
+    transitivePeerDependencies:
+      - supports-color
+
   '@typescript-eslint/utils@8.46.2(eslint@9.38.0(jiti@2.6.1))(typescript@5.9.3)':
     dependencies:
       '@eslint-community/eslint-utils': 4.9.0(eslint@9.38.0(jiti@2.6.1))
@@ -12050,6 +12241,11 @@ snapshots:
       '@typescript-eslint/types': 8.44.1
       eslint-visitor-keys: 4.2.1
 
+  '@typescript-eslint/visitor-keys@8.46.1':
+    dependencies:
+      '@typescript-eslint/types': 8.46.1
+      eslint-visitor-keys: 4.2.1
+
   '@typescript-eslint/visitor-keys@8.46.2':
     dependencies:
       '@typescript-eslint/types': 8.46.2
@@ -12120,14 +12316,26 @@ snapshots:
     dependencies:
       vite: 7.1.11(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
 
-  '@vitejs/plugin-react@5.1.0(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))':
+  '@vitejs/plugin-react@4.7.0(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))':
     dependencies:
       '@babel/core': 7.28.4
       '@babel/plugin-transform-react-jsx-self': 7.27.1(@babel/core@7.28.4)
       '@babel/plugin-transform-react-jsx-source': 7.27.1(@babel/core@7.28.4)
-      '@rolldown/pluginutils': 1.0.0-beta.43
+      '@rolldown/pluginutils': 1.0.0-beta.27
       '@types/babel__core': 7.20.5
-      react-refresh: 0.18.0
+      react-refresh: 0.17.0
+      vite: 6.4.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
+    transitivePeerDependencies:
+      - supports-color
+
+  '@vitejs/plugin-react@5.0.4(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))':
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/plugin-transform-react-jsx-self': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-react-jsx-source': 7.27.1(@babel/core@7.28.4)
+      '@rolldown/pluginutils': 1.0.0-beta.38
+      '@types/babel__core': 7.20.5
+      react-refresh: 0.17.0
       vite: 6.4.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
     transitivePeerDependencies:
       - supports-color
@@ -13119,11 +13327,6 @@ snapshots:
       pg: 8.16.3
       postgres: 3.4.7
 
-  drizzle-zod@0.8.3(drizzle-orm@0.44.7(@types/pg@8.15.5)(gel@2.1.1)(kysely@0.28.5)(pg@8.16.3)(postgres@3.4.7))(zod@3.25.76):
-    dependencies:
-      drizzle-orm: 0.44.7(@types/pg@8.15.5)(gel@2.1.1)(kysely@0.28.5)(pg@8.16.3)(postgres@3.4.7)
-      zod: 3.25.76
-
   drizzle-zod@0.8.3(drizzle-orm@0.44.7(@types/pg@8.15.5)(gel@2.1.1)(kysely@0.28.5)(pg@8.16.3)(postgres@3.4.7))(zod@4.1.11):
     dependencies:
       drizzle-orm: 0.44.7(@types/pg@8.15.5)(gel@2.1.1)(kysely@0.28.5)(pg@8.16.3)(postgres@3.4.7)
@@ -13454,7 +13657,7 @@ snapshots:
 
   eslint-plugin-import-x@4.16.1(@typescript-eslint/utils@8.46.2(eslint@9.38.0(jiti@2.6.1))(typescript@5.9.3))(eslint@9.38.0(jiti@2.6.1)):
     dependencies:
-      '@typescript-eslint/types': 8.46.2
+      '@typescript-eslint/types': 8.46.1
       comment-parser: 1.4.1
       debug: 4.4.3
       eslint: 9.38.0(jiti@2.6.1)
@@ -13525,7 +13728,7 @@ snapshots:
 
   eslint-plugin-solid@0.14.5(eslint@9.38.0(jiti@2.6.1))(typescript@5.9.3):
     dependencies:
-      '@typescript-eslint/utils': 8.46.2(eslint@9.38.0(jiti@2.6.1))(typescript@5.9.3)
+      '@typescript-eslint/utils': 8.46.1(eslint@9.38.0(jiti@2.6.1))(typescript@5.9.3)
       eslint: 9.38.0(jiti@2.6.1)
       estraverse: 5.3.0
       is-html: 2.0.0
@@ -14486,6 +14689,8 @@ snapshots:
 
   jiti@1.21.7: {}
 
+  jiti@2.6.0: {}
+
   jiti@2.6.1: {}
 
   jju@1.4.0: {}
@@ -14648,7 +14853,7 @@ snapshots:
       '@types/node': 24.7.0
       fast-glob: 3.3.3
       formatly: 0.3.0
-      jiti: 2.6.1
+      jiti: 2.6.0
       js-yaml: 4.1.0
       minimist: 1.2.8
       oxc-resolver: 11.8.4
@@ -15684,6 +15889,12 @@ snapshots:
       iconv-lite: 0.7.0
       unpipe: 1.0.0
 
+  react-dom@18.3.1(react@18.3.1):
+    dependencies:
+      loose-envify: 1.4.0
+      react: 18.3.1
+      scheduler: 0.23.2
+
   react-dom@19.2.0(react@19.2.0):
     dependencies:
       react: 19.2.0
@@ -15693,8 +15904,14 @@ snapshots:
 
   react-is@17.0.2: {}
 
+  react-refresh@0.17.0: {}
+
   react-refresh@0.18.0: {}
 
+  react@18.3.1:
+    dependencies:
+      loose-envify: 1.4.0
+
   react@19.2.0: {}
 
   read-cache@1.0.0:
@@ -15975,6 +16192,10 @@ snapshots:
     dependencies:
       xmlchars: 2.2.0
 
+  scheduler@0.23.2:
+    dependencies:
+      loose-envify: 1.4.0
+
   scheduler@0.27.0: {}
 
   semver@5.7.2: {}
@@ -16993,11 +17214,11 @@ snapshots:
 
   vite@6.4.1(@types/node@22.18.1)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1):
     dependencies:
-      esbuild: 0.25.11
+      esbuild: 0.25.9
       fdir: 6.5.0(picomatch@4.0.3)
       picomatch: 4.0.3
       postcss: 8.5.6
-      rollup: 4.52.5
+      rollup: 4.52.3
       tinyglobby: 0.2.15
     optionalDependencies:
       '@types/node': 22.18.1
@@ -17011,11 +17232,11 @@ snapshots:
 
   vite@6.4.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1):
     dependencies:
-      esbuild: 0.25.11
+      esbuild: 0.25.9
       fdir: 6.5.0(picomatch@4.0.3)
       picomatch: 4.0.3
       postcss: 8.5.6
-      rollup: 4.52.5
+      rollup: 4.52.3
       tinyglobby: 0.2.15
     optionalDependencies:
       '@types/node': 24.7.0